%!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 C library,

as summarized in \tref{algorithms.summary}.

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

\ref{algorithms.requirements} & Algorithms requirements & \\

\ref{algorithms.parallel} & Parallel algorithms & \tcode{<execution>} \\ \rowsep

\ref{algorithms.results} & Algorithm result types & \tcode{<algorithm>} \\

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

\ref{alg.modifying.operations} & Mutating sequence operations & \\

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

\ref{numeric.ops} & Generalized numeric operations & \tcode{<numeric>} \\ \rowsep

\ref{specialized.algorithms} & Specialized \tcode{<memory>} algorithms & \tcode{<memory>} \\ \rowsep

\ref{alg.rand} & Specialized \tcode{<random>} algorithms & \tcode{<random>} \\ \rowsep

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

\end{libsumtab}

\rSec1[algorithms.requirements]{Algorithms requirements}

\pnum

All of the algorithms

are separated from the particular implementations of data structures and

are parameterized by iterator types.

Because of this, they can work with program-defined data structures,

as long as these data structures have iterator types

satisfying the assumptions on the algorithms.

\pnum

The entities defined in the \tcode{std::ranges} namespace in this Clause and

specified as function templates are

algorithm function objects\iref{alg.func.obj}.

\pnum

For purposes of determining the existence of data races,

algorithms shall not modify objects referenced through an iterator argument

unless the specification requires such modification.

\pnum

Throughout this Clause, where the template parameters are not constrained,

the names of template parameters are used to express type requirements.

\begin{itemize}

\item

If an algorithm's \Fundescx{Effects} element specifies

that a value pointed to by any iterator passed as an argument is modified,

then the type of that argument shall meet

the requirements of a mutable iterator\iref{iterator.requirements}.

\item

If an algorithm's template parameter is named

\tcode{InputIterator},

\tcode{InputIterator1}, or

\tcode{Input\-Iterator2},

the template argument shall meet the

\oldconcept{InputIterator} requirements\iref{input.iterators}.

\item

If an algorithm's template parameter is named

\tcode{OutputIterator},

\tcode{OutputIterator1}, or

\tcode{Output\-Iterator2},

the template argument shall meet the

\oldconcept{OutputIterator} requirements\iref{output.iterators}.

\item

If an algorithm's template parameter is named

\tcode{ForwardIterator},

\tcode{ForwardIterator1},

\tcode{ForwardItera\-tor2}, or

\tcode{NoThrowForwardIterator},

the template argument shall meet the

\oldconcept{ForwardIterator} requirements\iref{forward.iterators}

if it is required to be a mutable iterator, or

model \libconcept{forward_iterator}\iref{iterator.concept.forward} otherwise.

\item

If an algorithm's template parameter is named

\tcode{NoThrowForwardIterator},

the template argument

is also required to have the property that no exceptions are thrown

from increment, assignment, or comparison of, or

indirection through, valid iterators.

\item

If an algorithm's template parameter is named

\tcode{BidirectionalIterator},

\tcode{Bidirectional\-Iterator1}, or

\tcode{BidirectionalIterator2},

the template argument shall meet the

\oldconcept{BidirectionalIterator} requirements\iref{bidirectional.iterators}

if it is required to be a mutable iterator, or model

\libconcept{bidirectional_iterator}\iref{iterator.concept.bidir} otherwise.

\item

If an algorithm's template parameter is named

\tcode{RandomAccessIterator},

\tcode{Random\-AccessIterator1}, or

\tcode{RandomAccessIterator2},

the template argument shall meet the

\oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}

if it is required to be a mutable iterator, or model

\libconcept{random_access_iterator}\iref{iterator.concept.random.access} otherwise.

\end{itemize}

\begin{note}

These requirements do not affect iterator arguments that are constrained,

for which iterator category and mutability requirements

are expressed explicitly.

\end{note}

\pnum

Both in-place and copying versions are provided for certain algorithms.

\begin{footnote}

The decision whether to include a copying version was

usually based on complexity considerations.

When the cost of doing the operation dominates the cost of copy,

the copying version is not included.

For example, \tcode{sort_copy} is not included

because the cost of sorting is much more significant,

and users can invoke \tcode{copy} followed by \tcode{sort}.

\end{footnote}

When such a version is provided for \textit{algorithm} it is called

\textit{algorithm\tcode{_copy}}.

Algorithms that take predicates end with the suffix \tcode{_if}

(which follows the suffix \tcode{_copy}).

\pnum

When not otherwise constrained, the \tcode{Predicate} parameter is used

whenever an algorithm expects a function object\iref{function.objects} that,

when applied to the result of dereferencing the corresponding iterator,

returns a value testable as \tcode{true}.

If an algorithm takes \tcode{Predicate pred} as its argument and

\tcode{first} as its iterator argument with value type \tcode{T},

the expression \tcode{pred(*first)} shall be well-formed and

the type \tcode{decltype(pred(*first))} shall model

\exposconcept{boolean-testable}\iref{concept.booleantestable}.

The function object \tcode{pred} shall not apply any non-constant function

through its argument.

Given a glvalue \tcode{u} of type (possibly const) \tcode{T}

that designates the same object as \tcode{*first},

\tcode{pred(u)} shall be a valid expression

that is equal to \tcode{pred(*first)}.

\pnum

When not otherwise constrained, the \tcode{BinaryPredicate} parameter is used

whenever an algorithm expects a function object that, when applied

to the result of dereferencing two corresponding iterators or

to dereferencing an iterator and type \tcode{T}

when \tcode{T} is part of the signature,

returns a value testable as \tcode{true}.

If an algorithm takes \tcode{BinaryPredicate binary_pred} as its argument and

\tcode{first1} and \tcode{first2} as its iterator arguments

with respective value types \tcode{T1} and \tcode{T2},

the expression \tcode{binary_pred(*first1, *first2)} shall be well-formed and

the type \tcode{decltype(binary_pred(*first1, *first2))} shall model

\exposconcept{boolean-testable}.

Unless otherwise specified,

\tcode{BinaryPredicate} always takes the first iterator's \tcode{value_type}

as its first argument, that is, in those cases when \tcode{T value}

is part of the signature,

the expression \tcode{binary_pred(*first1, value)} shall be well-formed and

the type \tcode{decltype(binary_pred(*first1, value))} shall model

\exposconcept{boolean-testable}.

\tcode{binary_pred} shall not apply any non-constant function

through any of its arguments.

Given a glvalue \tcode{u} of type (possibly const) \tcode{T1}

that designates the same object as \tcode{*first1}, and

a glvalue \tcode{v} of type (possibly const) \tcode{T2}

that designates the same object as \tcode{*first2},

\tcode{binary_pred(u, *first2)},

\tcode{binary_pred(*first1, v)}, and

\tcode{binary_pred(u, v)}

shall each be a valid expression that is equal to

\tcode{binary_pred(*first1, *first2)}, and

\tcode{binary_pred(u, value)}

shall be a valid expression that is equal to

\tcode{binary_pred(*first1, value)}.

\pnum

The parameters

\tcode{UnaryOperation},

\tcode{BinaryOperation},

\tcode{BinaryOperation1},

and \tcode{BinaryOperation2}

are used

whenever an algorithm expects a function object\iref{function.objects}.

\pnum

\begin{note}

Unless otherwise specified, algorithms that take function objects as arguments

can copy those function objects freely.

If object identity is important,

a wrapper class that points to a non-copied implementation object

such as \tcode{reference_wrapper<T>}\iref{refwrap}, or some equivalent solution,

can be used.

\end{note}

\pnum

When the description of an algorithm gives an expression such as

\tcode{*first == value} for a condition, the expression

shall evaluate to either \tcode{true} or \tcode{false} in boolean contexts.

\pnum

In the description of the algorithms, operator \tcode{+}

is used for some of the iterator categories

for which it does not have to be defined.

In these cases the semantics of \tcode{a + n} are the same as those of

\begin{codeblock}

auto tmp = a;

for (; n < 0; ++n) --tmp;

for (; n > 0; --n) ++tmp;

return tmp;

\end{codeblock}

Similarly, operator \tcode{-} is used

for some combinations of iterators and sentinel types

for which it does not have to be defined.

If \range{a}{b} denotes a range,

the semantics of \tcode{b - a} in these cases are the same as those of

\begin{codeblock}

iter_difference_t<decltype(a)> n = 0;

for (auto tmp = a; tmp != b; ++tmp) ++n;

return n;

\end{codeblock}

and if \range{b}{a} denotes a range, the same as those of

\begin{codeblock}

iter_difference_t<decltype(b)> n = 0;

for (auto tmp = b; tmp != a; ++tmp) --n;

return n;

\end{codeblock}

For each iterator \tcode{i} and sentinel \tcode{s}

produced from a range \tcode{r},

the semantics of \tcode{s - i}

are the same as those of an expression that

has the same type, value, and value category

as \tcode{ranges::distance(i, s)}.

\begin{note}

The implementation can use \tcode{ranges::distance(r)}

when that produces the same value as \tcode{ranges::\-distance(i, s)}.

This can be more efficient for sized ranges.

\end{note}

\pnum

In the description of the algorithms,

given an iterator \tcode{a} whose difference type is \tcode{D}, and

an expression \tcode{n} of integer-like type other than \cv{} \tcode{D},

the semantics of \tcode{a + n} and \tcode{a - n} are, respectively,

those of \tcode{a + D(n)} and \tcode{a - D(n)}.

\pnum

In the description of algorithm return values,

a sentinel value \tcode{s} denoting the end of a range \range{i}{s}

is sometimes returned where an iterator is expected.

In these cases,

the semantics are as if the sentinel is converted into an iterator using

\tcode{ranges::next(i, s)}.

\pnum

Overloads of algorithms that take \libconcept{range} arguments\iref{range.range}

behave as if they are implemented by

dispatching to the overload in namespace \tcode{ranges}

that takes separate iterator and sentinel arguments,

where for each range argument \tcode{r}

\begin{itemize}

\item

a corresponding iterator argument is initialized with \tcode{ranges::begin(r)} and

\item

a corresponding sentinel argument is initialized with \tcode{ranges::end(r)},

or \tcode{ranges::next(ranges::\brk{}begin(r), ranges::end(r))}

if the type of \tcode{r} models \libconcept{forward_range}

and computing \tcode{ranges::next} meets the specified complexity requirements.

\end{itemize}

\pnum

The well-formedness and behavior of a call to an algorithm with

an explicitly-specified template argument list

is unspecified, except where explicitly stated otherwise.

\begin{note}

Consequently, an implementation can declare an algorithm with

different template parameters than those presented.

\end{note}

\rSec1[algorithms.parallel]{Parallel algorithms}

\rSec2[algorithms.parallel.defns]{Preamble}

\pnum

Subclause \ref{algorithms.parallel} describes components that \Cpp{} programs may use

to perform operations on containers and other sequences in parallel.

\pnum

A \defn{parallel algorithm} is a function template listed in this document

with a template parameter named \tcode{ExecutionPolicy}

or constrained by the following exposition-only concept:

\begin{codeblock}

template<class Ep>

concept @\defexposconcept{execution-policy}@ = is_execution_policy_v<remove_cvref_t<Ep>>; // \expos

\end{codeblock}

Such a template parameter is termed an \defnadj{execution policy}{template parameter}.

\pnum

A parallel algorithm accesses objects indirectly accessible via its arguments

by invoking the following functions:

\begin{itemize}

\item

All operations of the categories of the iterators, sentinels, or \tcode{mdspan} types

that the algorithm is instantiated with.

\item

Operations on those sequence elements that are required by its specification.

\item

User-provided invocable objects

to be applied during the execution of the algorithm,

if required by the specification.

\item

Operations on those invocable objects required by the specification.

\begin{note}

See~\ref{algorithms.requirements}.

\end{note}

\end{itemize}

These functions are herein called \defn{element access functions}.

\pnum

\begin{example}

The \tcode{sort} function may invoke the following element access functions:

\begin{itemize}

\item

Operations of the random-access iterator of the actual template argument

(as per \ref{random.access.iterators}),

as implied by the name of the template parameter \tcode{RandomAccessIterator}.

\item

The \tcode{swap} function on the elements of the sequence

(as per the preconditions specified in \ref{sort}).

\item

The user-provided \tcode{Compare} function object.

\end{itemize}

\end{example}

\pnum

A standard library function is \defn{vectorization-unsafe}

if it is specified to synchronize with another function invocation, or

another function invocation is specified to synchronize with it,

and if it is not a memory allocation or deallocation function

or lock-free atomic modify-write operation\iref{atomics.order}.

\begin{note}

Implementations must ensure that internal synchronization

inside standard library functions does not prevent forward progress

when those functions are executed by threads of execution

with weakly parallel forward progress guarantees.

\end{note}

\begin{example}

\begin{codeblock}

int x = 0;

std::mutex m;

void f() {

int a[] = {1,2};

std::for_each(std::execution::par_unseq, std::begin(a), std::end(a), [&](int) {

std::lock_guard<mutex> guard(m); // incorrect: \tcode{lock_guard} constructor calls \tcode{m.lock()}

++x;

});

}

\end{codeblock}

The above program may result in two consecutive calls to \tcode{m.lock()}

on the same thread of execution (which may deadlock),

because the applications of the function object are not guaranteed

to run on different threads of execution.

\end{example}

\rSec2[algorithms.parallel.user]{Requirements on user-provided function objects}

\pnum

Unless otherwise specified,

invocable objects passed into parallel algorithms as objects of a type

denoted by a template parameter named

\tcode{Predicate},

\tcode{BinaryPredicate},

\tcode{Compare},

\tcode{UnaryOperation},

\tcode{BinaryOperation},

\tcode{BinaryOperation1},

\tcode{BinaryOperation2},

\tcode{BinaryDivideOp}, or

constrained by a concept

whose semantic requirements include

that the type models \libconcept{regular_invocable}

and the operators used by the analogous overloads to these parallel algorithms

that are formed by an invocation

with the specified default predicate or operation (where applicable)

shall not directly or indirectly modify objects via their arguments,

nor shall they rely on the identity of the provided objects.

\rSec2[algorithms.parallel.exec]{Effect of execution policies on algorithm execution}

\pnum

An execution policy template parameter describes

the manner in which the execution of a parallel algorithm may be

parallelized and the manner in which it applies the element access functions.

\pnum

If an object is modified by an element access function,

the algorithm will perform no other unsynchronized accesses to that object.

The modifying element access functions are those

which are specified as modifying the object.

\begin{note}

For example,

\tcode{swap},

\tcode{++},

\tcode{--},

\tcode{@=}, and

assignments

modify the object.

For the assignment and \tcode{@=} operators, only the left argument is modified.

\end{note}

\pnum

Unless otherwise stated, implementations may make arbitrary copies of elements

(with type \tcode{T}) from sequences

where \tcode{is_trivially_copy_constructible_v<T>}

and \tcode{is_trivially_destructible_v<T>} are \tcode{true}.

\begin{note}

This implies that user-supplied function objects cannot rely on

object identity of arguments for such input sequences.

If object identity of the arguments to these function objects

is important, a wrapping iterator

that returns a non-copied implementation object

such as \tcode{reference_wrapper<T>}\iref{refwrap},

or some equivalent solution, can be used.

\end{note}

\pnum

The invocations of element access functions in parallel algorithms invoked with

an execution policy object of type \tcode{execution::sequenced_policy} all occur

in the calling thread of execution.

\begin{note}

The invocations are not interleaved; see~\ref{intro.execution}.

\end{note}

\pnum

The invocations of element access functions in parallel algorithms invoked with

an execution policy object of type \tcode{execution::unsequenced_policy}

are permitted to execute in an unordered fashion

in the calling thread of execution,

unsequenced with respect to one another in the calling thread of execution.

\begin{note}

This means that multiple function object invocations

can be interleaved on a single thread of execution,

which overrides the usual guarantee from \ref{intro.execution}

that function executions do not overlap with one another.

\end{note}

The behavior of a program is undefined if

it invokes a vectorization-unsafe standard library function

from user code

called from an \tcode{execution::unsequenced_policy} algorithm.

\begin{note}

Because \tcode{execution::unsequenced_policy} allows

the execution of element access functions

to be interleaved on a single thread of execution,

blocking synchronization, including the use of mutexes, risks deadlock.

\end{note}

\pnum

The invocations of element access functions in parallel algorithms invoked with

an execution policy object of type \tcode{execution::parallel_policy}

are permitted to execute either

in the invoking thread of execution or

in a thread of execution implicitly created by the library

to support parallel algorithm execution.

If the threads of execution created by \tcode{thread}\iref{thread.thread.class}

or \tcode{jthread}\iref{thread.jthread.class}

provide concurrent forward progress guarantees\iref{intro.progress},

then a thread of execution implicitly created by the library will provide

parallel forward progress guarantees;

otherwise, the provided forward progress guarantee is

\impldef{forward progress guarantees for

implicit threads of parallel algorithms (if not defined for \tcode{thread})}.

Any such invocations executing in the same thread of execution

are indeterminately sequenced with respect to each other.

\begin{note}

It is the caller's responsibility to ensure

that the invocation does not introduce data races or deadlocks.

\end{note}

\begin{example}

\begin{codeblock}

int a[] = {0,1};

std::vector<int> v;

std::for_each(std::execution::par, std::begin(a), std::end(a), [&](int i) {

v.push_back(i*2+1); // incorrect: data race

});

\end{codeblock}

The program above has a data race because of the unsynchronized access to the

container \tcode{v}.

\end{example}

\begin{example}

\begin{codeblock}

std::atomic<int> x{0};

int a[] = {1,2};

std::for_each(std::execution::par, std::begin(a), std::end(a), [&](int) {

x.fetch_add(1, std::memory_order::relaxed);

// spin wait for another iteration to change the value of \tcode{x}

while (x.load(std::memory_order::relaxed) == 1) { } // incorrect: assumes execution order

});

\end{codeblock}

The above example depends on the order of execution of the iterations, and

will not terminate if both iterations are executed sequentially

on the same thread of execution.

\end{example}

\begin{example}

\begin{codeblock}

int x = 0;

std::mutex m;

int a[] = {1,2};

std::for_each(std::execution::par, std::begin(a), std::end(a), [&](int) {

std::lock_guard<mutex> guard(m);

++x;

});

\end{codeblock}

The above example synchronizes access to object \tcode{x}

ensuring that it is incremented correctly.

\end{example}

\pnum

The invocations of element access functions in parallel algorithms invoked with

an execution policy object of type \tcode{execution::parallel_unsequenced_policy} are

permitted to execute

in an unordered fashion in unspecified threads of execution, and

unsequenced with respect to one another within each thread of execution.

These threads of execution are

either the invoking thread of execution

or threads of execution implicitly created by the library;

the latter will provide weakly parallel forward progress guarantees.

\begin{note}

This means that multiple function object invocations can be interleaved

on a single thread of execution,

which overrides the usual guarantee from \ref{intro.execution}

that function executions do not overlap with one another.

\end{note}

The behavior of a program is undefined if

it invokes a vectorization-unsafe standard library function

from user code

called from an \tcode{execution::parallel_unsequenced_policy} algorithm.

\begin{note}

Because \tcode{execution::parallel_unsequenced_policy} allows

the execution of element access functions

to be interleaved on a single thread of execution,

blocking synchronization, including the use of mutexes, risks deadlock.

\end{note}

\pnum

\begin{note}

The semantics of invocation with

\tcode{execution::unsequenced_policy},

\tcode{execution::parallel_policy}, or

\tcode{execution::parallel_unsequenced_policy}

allow the implementation to fall back to sequential execution

if the system cannot parallelize an algorithm invocation,

e.g., due to lack of resources.

\end{note}

\pnum

If an invocation of a parallel algorithm uses threads of execution

implicitly created by the library,

then the invoking thread of execution will either

\begin{itemize}

\item

temporarily block

with forward progress guarantee delegation\iref{intro.progress}

on the completion of these library-managed threads of execution, or

\item

eventually execute an element access function;

\end{itemize}

the thread of execution will continue to do so until the algorithm is finished.

\begin{note}

In blocking with forward progress guarantee delegation in this context,

a thread of execution created by the library

is considered to have finished execution

as soon as it has finished the execution

of the particular element access function

that the invoking thread of execution logically depends on.

\end{note}

\pnum

The semantics of parallel algorithms invoked with an execution policy object of

\impldef{additional execution policies supported by parallel algorithms} type

are \impldef{semantics of parallel algorithms invoked with

imple\-men\-tation-defined execution policies}.

\rSec2[algorithms.parallel.exceptions]{Parallel algorithm exceptions}

\pnum

During the execution of a parallel algorithm,

if temporary memory resources are required for parallelization

and none are available, the algorithm throws a \tcode{bad_alloc} exception.

\pnum

During the execution of a parallel algorithm,

if the invocation of an element access function exits via an uncaught exception,

the behavior is determined by the execution policy.

\rSec2[algorithms.parallel.overloads]{Parallel algorithm overloads}

\pnum

Parallel algorithms are algorithm overloads.

Each parallel algorithm overload

has an additional function parameter $P$ of type \tcode{T\&\&}

as the first function parameter,

where \tcode{T} is the execution policy template parameter.

\begin{note}

Not all algorithms have parallel algorithm overloads.

\end{note}

\pnum

Unless otherwise specified,

the semantics of calling a parallel algorithm overload are identical to

calling the corresponding algorithm overload without the parameter $P$,

using all but the first argument.

\pnum

Unless otherwise specified,

the complexity requirements of a parallel algorithm overload

are relaxed from the complexity requirements of the corresponding overload

without the parameter $P$

as follows:

when the guarantee says ``at most \placeholder{expr}'' or

``exactly \placeholder{expr}''

and does not specify the number of assignments or swaps, and

\placeholder{expr} is not already expressed with \bigoh{} notation,

the complexity of the algorithm shall be \bigoh{\placeholder{expr}}.

\pnum

A parallel algorithm

with a template parameter named \tcode{ExecutionPolicy}

shall not participate in overload resolution unless

that template parameter satisfies \exposconcept{execution-policy}.

\rSec2[execpol]{Execution policies}

\rSec3[execpol.general]{General}

\pnum

Subclause~\ref{execpol} describes classes that are \defn{execution policy} types. An

object of an execution policy type indicates the kinds of parallelism allowed

in the execution of an algorithm and expresses the consequent requirements on

the element access functions.

Execution policy types are declared in header \libheaderref{execution}.

\begin{example}

\begin{codeblock}

using namespace std;

vector<int> v = @\commentellip@;

// standard sequential sort

sort(v.begin(), v.end());

// explicitly sequential sort

sort(execution::seq, v.begin(), v.end());

// permitting parallel execution

sort(execution::par, v.begin(), v.end());

// permitting vectorization as well

sort(execution::par_unseq, v.begin(), v.end());

\end{codeblock}

\end{example}

\begin{note}

Implementations can provide additional execution policies

to those described in this document as extensions

to address parallel architectures that require idiosyncratic

parameters for efficient execution.

\end{note}

\rSec3[execpol.type]{Execution policy type trait}

\indexlibraryglobal{is_execution_policy}%

\begin{itemdecl}

template<class T> struct is_execution_policy;

\end{itemdecl}

\begin{itemdescr}

\pnum

\tcode{is_execution_policy} can be used to detect execution policies for the

purpose of excluding function signatures from otherwise ambiguous overload

resolution participation.

\pnum

\tcode{is_execution_policy<T>} is a \oldconcept{UnaryTypeTrait} with a

base characteristic of \tcode{true_type} if \tcode{T} is the type of a standard

or \impldef{additional execution policies supported by parallel algorithms}

execution policy, otherwise \tcode{false_type}.

\begin{note}

This provision reserves the privilege of creating non-standard execution

policies to the library implementation.

\end{note}

\pnum

The behavior of a program that adds specializations for

\tcode{is_execution_policy} is undefined.

\end{itemdescr}

\rSec3[execpol.seq]{Sequenced execution policy}

\indexlibraryglobal{execution::sequenced_policy}%

\begin{itemdecl}

class execution::sequenced_policy { @\unspec@ };

\end{itemdecl}

\begin{itemdescr}

\pnum

The class \tcode{execution::sequenced_policy} is an execution policy type used

as a unique type to disambiguate parallel algorithm overloading and require

that a parallel algorithm's execution may not be parallelized.

\pnum

During the execution of a parallel algorithm with

the \tcode{execution::sequenced_policy} policy,

if the invocation of an element access function exits via an exception,

\tcode{terminate} is invoked\iref{except.terminate}.

\end{itemdescr}

\rSec3[execpol.par]{Parallel execution policy}

\indexlibraryglobal{execution::parallel_policy}%

\begin{itemdecl}

class execution::parallel_policy { @\unspec@ };

\end{itemdecl}

\begin{itemdescr}

\pnum

The class \tcode{execution::parallel_policy} is an execution policy type used as

a unique type to disambiguate parallel algorithm overloading and indicate that

a parallel algorithm's execution may be parallelized.

\pnum

During the execution of a parallel algorithm with

the \tcode{execution::parallel_policy} policy,

if the invocation of an element access function exits via an exception,

\tcode{terminate} is invoked\iref{except.terminate}.

\end{itemdescr}

\rSec3[execpol.parunseq]{Parallel and unsequenced execution policy}

\indexlibraryglobal{execution::parallel_unsequenced_policy}%

\begin{itemdecl}

class execution::parallel_unsequenced_policy { @\unspec@ };

\end{itemdecl}

\begin{itemdescr}

\pnum

The class \tcode{execution::parallel_unsequenced_policy} is an execution policy type

used as a unique type to disambiguate parallel algorithm overloading and

indicate that a parallel algorithm's execution may be parallelized and

vectorized.

\pnum

During the execution of a parallel algorithm with

the \tcode{execution::parallel_unsequenced_policy} policy,

if the invocation of an element access function exits via an exception,

\tcode{terminate} is invoked\iref{except.terminate}.

\end{itemdescr}

\rSec3[execpol.unseq]{Unsequenced execution policy}

\indexlibraryglobal{execution::unsequenced_policy}%

\begin{itemdecl}

class execution::unsequenced_policy { @\unspec@ };

\end{itemdecl}

\begin{itemdescr}

\pnum

The class \tcode{unsequenced_policy} is an execution policy type

used as a unique type to disambiguate parallel algorithm overloading and

indicate that a parallel algorithm's execution may be vectorized,

e.g., executed on a single thread using instructions

that operate on multiple data items.

\pnum

During the execution of a parallel algorithm with

the \tcode{execution::unsequenced_policy} policy,

if the invocation of an element access function exits via an exception,

\tcode{terminate} is invoked\iref{except.terminate}.

\end{itemdescr}

\rSec3[execpol.objects]{Execution policy objects}

\indexlibraryglobal{seq}%

\indexlibraryglobal{par}%

\indexlibraryglobal{par_unseq}%

\indexlibraryglobal{unseq}%

\indexlibrarymember{execution}{seq}%

\indexlibrarymember{execution}{par}%

\indexlibrarymember{execution}{par_unseq}%

\indexlibrarymember{execution}{unseq}%

\begin{itemdecl}

inline constexpr execution::sequenced_policy execution::seq{ @\unspec@ };

inline constexpr execution::parallel_policy execution::par{ @\unspec@ };

inline constexpr execution::parallel_unsequenced_policy execution::par_unseq{ @\unspec@ };

inline constexpr execution::unsequenced_policy execution::unseq{ @\unspec@ };

\end{itemdecl}

\begin{itemdescr}

\pnum

The header \libheaderref{execution} declares global objects associated with each type of execution policy.

\end{itemdescr}

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

\indexheader{algorithm}%

\begin{codeblock}

// mostly freestanding

#include <initializer_list> // see \ref{initializer.list.syn}

namespace std {

namespace ranges {

// \ref{algorithms.results}, algorithm result types

template<class I, class F>

struct in_fun_result;

template<class I1, class I2>

struct in_in_result;

template<class I, class O>

struct in_out_result;

template<class I1, class I2, class O>

struct in_in_out_result;

template<class I, class O1, class O2>

struct in_out_out_result;

template<class T>

struct min_max_result;

template<class I>

struct in_found_result;

template<class I, class T>

struct in_value_result;

template<class O, class T>

struct out_value_result;

}

// \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, // freestanding-deleted, see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Predicate pred);

namespace ranges {

template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>

constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});

template<@\libconcept{input_range}@ R, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>

constexpr bool all_of(R&& r, Pred pred, Proj proj = {});

template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,

class Proj = identity, @\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>

bool all_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {}); // freestanding-deleted

template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>

bool all_of(Ep&& exec, R&& r, Pred pred, Proj proj = {}); // freestanding-deleted

}

// \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, // freestanding-deleted, see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Predicate pred);

namespace ranges {

template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>

constexpr bool any_of(I first, S last, Pred pred, Proj proj = {});

template<@\libconcept{input_range}@ R, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>

constexpr bool any_of(R&& r, Pred pred, Proj proj = {});

template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,

class Proj = identity, @\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>

bool any_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {}); // freestanding-deleted

template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>

bool any_of(Ep&& exec, R&& r, Pred pred, Proj proj = {}); // freestanding-deleted

}

// \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, // freestanding-deleted, see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Predicate pred);

namespace ranges {

template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>

constexpr bool none_of(I first, S last, Pred pred, Proj proj = {});

template<@\libconcept{input_range}@ R, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>

constexpr bool none_of(R&& r, Pred pred, Proj proj = {});

template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,

class Proj = identity, @\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>

bool none_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {}); // freestanding-deleted

template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,

@\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>

bool none_of(Ep&& exec, R&& r, Pred pred, Proj proj = {}); // freestanding-deleted

}

// \ref{alg.contains}, contains

namespace ranges {

template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,

class T = projected_value_t<I, Proj>>

requires @\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<I, Proj>, const T*>

constexpr bool contains(I first, S last, const T& value, Proj proj = {});

template<@\libconcept{input_range}@ R, class Proj = identity,

class T = projected_value_t<iterator_t<R>, Proj>>

requires

@\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>

constexpr bool contains(R&& r, const T& value, Proj proj = {});

template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,

class Proj = identity, class T = projected_value_t<I, Proj>>

requires @\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<I, Proj>, const T*>

bool contains(Ep&& exec, I first, S last, const T& value,

Proj proj = {}); // freestanding-deleted

template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,

class T = projected_value_t<iterator_t<R>, Proj>>

requires

@\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>

bool contains(Ep&& exec, R&& r, const T& value, Proj proj = {}); // freestanding-deleted

template<@\libconcept{forward_iterator}@ I1, @\libconcept{sentinel_for}@<I1> S1,

@\libconcept{forward_iterator}@ I2, @\libconcept{sentinel_for}@<I2> S2,

class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>

requires @\libconcept{indirectly_comparable}@<I1, I2, Pred, Proj1, Proj2>

constexpr bool contains_subrange(I1 first1, S1 last1, I2 first2, S2 last2,

Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

template<@\libconcept{forward_range}@ R1, @\libconcept{forward_range}@ R2,

class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>

requires @\libconcept{indirectly_comparable}@<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>

constexpr bool contains_subrange(R1&& r1, R2&& r2,

Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});

template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I1, @\libconcept{sized_sentinel_for}@<I1> S1,

@\libconcept{random_access_iterator}@ I2, @\libconcept{sized_sentinel_for}@<I2> S2,

class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>

requires @\libconcept{indirectly_comparable}@<I1, I2, Pred, Proj1, Proj2>

bool contains_subrange(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},

Proj1 proj1 = {}, Proj2 proj2 = {}); // freestanding-deleted

template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R1, @\exposconcept{sized-random-access-range}@ R2,

class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>

requires @\libconcept{indirectly_comparable}@<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>

bool contains_subrange(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {},

Proj2 proj2 = {}); // freestanding-deleted

}

// \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, // freestanding-deleted, see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Function f);

namespace ranges {

template<class I, class F>

using @\libglobal{for_each_result}@ = in_fun_result<I, F>;

template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,

@\libconcept{indirectly_unary_invocable}@<projected<I, Proj>> Fun>

constexpr for_each_result<I, Fun>

for_each(I first, S last, Fun f, Proj proj = {});

template<@\libconcept{input_range}@ R, class Proj = identity,

@\libconcept{indirectly_unary_invocable}@<projected<iterator_t<R>, Proj>> Fun>

constexpr for_each_result<borrowed_iterator_t<R>, Fun>

for_each(R&& r, Fun f, Proj proj = {});

template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,

class Proj = identity,

@\libconcept{indirectly_unary_invocable}@<projected<I, Proj>> Fun>

I for_each(Ep&& exec, I first, S last, Fun f, Proj proj = {}); // freestanding-deleted

template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,

@\libconcept{indirectly_unary_invocable}@<projected<iterator_t<R>, Proj>> Fun>

borrowed_iterator_t<R>

for_each(Ep&& exec, R&& r, Fun f, Proj proj = {}); // freestanding-deleted

}

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, // freestanding-deleted, see \ref{algorithms.parallel.overloads}

ForwardIterator first, Size n, Function f);

namespace ranges {

template<class I, class F>

using @\libglobal{for_each_n_result}@ = in_fun_result<I, F>;