size_t size() const noexcept;

Returns:

The number of exception_ptr objects contained within the exception_list.

Complexity:

Constant time.

iterator begin() const noexcept;

Returns:

An iterator referring to the first exception_ptr object contained within the exception_list.

iterator end() const noexcept;

Returns:

An iterator that is the past-the-end value of the owned sequence.

virtual const char* what() const noexcept;

Returns:

An implementation-defined NTBS.

template<class ExecutionPolicy,
      class InputIterator, class Function>
void for_each(ExecutionPolicy&& exec,
              InputIterator first, InputIterator last,
              Function f);

Requires:

Function shall meet the requirements of CopyConstructible.

Effects:

Applies f to the result of dereferencing every iterator in the range [first,last). [ Note: If the type of first satisfies the requirements of a mutable iterator, f may apply nonconstant functions through the dereferenced iterator. — end note ]

Complexity:

Applies f exactly last - first times.

Remarks:

If f returns a result, the result is ignored.

Notes:

Does not return a copy of its Function parameter, since parallelization may not permit efficient state accumulation.

template<class InputIterator, class Size, class Function>
InputIterator for_each_n(InputIterator first, Size n,
                         Function f);

Requires:

Function shall meet the requirements of MoveConstructible [ Note: Function need not meet the requirements of CopyConstructible. — end note ]

Requires:

n >= 0.

Effects:

Applies f to the result of dereferencing every iterator in the range [first,first + n) in order. [ Note: If the type of first satisfies the requirements of a mutable iterator, f may apply nonconstant functions through the dereferenced iterator. — end note ]

Returns:

first + n.

Remarks:

If f returns a result, the result is ignored.

template<class ExecutionPolicy,
      class InputIterator, class Size, class Function>
InputIterator for_each_n(ExecutionPolicy&& exec,
                         InputIterator first, Size n,
                         Function f);

Requires:

Function shall meet the requirements of CopyConstructible.

Requires:

n >= 0.

Effects:

Applies f to the result of dereferencing every iterator in the range [first,first + n). [ Note: If the type of first satisfies the requirements of a mutable iterator, f may apply nonconstant functions through the dereferenced iterator. — end note ]

Returns:

first + n.

Remarks:

If f returns a result, the result is ignored.

template<class InputIterator>
typename iterator_traits<InputIterator>::value_type
    reduce(InputIterator first, InputIterator last);

Effects:

Equivalent to return reduce(first, last, typename iterator_traits<InputIterator>::value_type{}).

template<class InputIterator, class T>
T reduce(InputIterator first, InputIterator last, T init);

Effects:

Equivalent to return reduce(first, last, init, plus<>()).

template<class InputIterator, class T, class BinaryOperation>
T reduce(InputIterator first, InputIterator last, T init,
         BinaryOperation binary_op);

Returns:

GENERALIZED_SUM(binary_op, init, *i, ...) for every i in [first, last).

Requires:

binary_op shall neither invalidate iterators or subranges, nor modify elements in the range [first,last).

Complexity:

O(last - first) applications of binary_op.

Notes:

The difference between reduce and accumulate is that reduce applies binary_op in an unspecified order, which yields a non-deterministic result for non-associative or non-commutative binary_op such as floating-point addition.

template<class InputIterator, class OutputIterator, class T>
OutputIterator exclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              T init);

Effects:

Equivalent to return exclusive_scan(first, last, result, init, plus<>()).

template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
OutputIterator exclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              T init, BinaryOperation binary_op);

Effects:

Assigns through each iterator i in [result,result + (last - first)) the value of

• init, if i is result, otherwise
• GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, *j, ...) for every j in [first,first + (i - result) - 1).

Returns:

The end of the resulting range beginning at result.

Requires:

binary_op shall neither invalidate iterators or subranges, nor modify elements in the ranges [first,last) or [result,result + (last - first)).

Complexity:

O(last - first) applications of binary_op.

Notes:

The difference between exclusive_scan and inclusive_scan is that exclusive_scan excludes the ith input element from the ith sum. If binary_op is not mathematically associative, the behavior of exclusive_scan may be non-deterministic.

Remarks:

result may be equal to first.

template<class InputIterator, class OutputIterator>
OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result);

Effects:

Equivalent to return inclusive_scan(first, last, result, plus<>()).

template<class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              BinaryOperation binary_op);template<class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              BinaryOperation binary_op, T init);

Effects:

Assigns through each iterator i in [result,result + (last - first)) the value of GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, *j, ...) for every j in [first,first + (i - result)) or GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, *j, ...) for every j in [first,first + (i - result)) if init is provided.

Returns:

The end of the resulting range beginning at result.

Requires:

binary_op shall not invalidate iterators or subranges, nor modify elements in the ranges [first,last) or [result,result + (last - first)).

Complexity:

O(last - first) applications of binary_op.

Remarks:

result may be equal to first.

Notes:

The difference between exclusive_scan and inclusive_scan is that inclusive_scan includes the ith input element in the ith sum. If binary_op is not mathematically associative, the behavior of inclusive_scan may be non-deterministic.

template<class InputIterator, class UnaryFunction, class T, class BinaryOperation>
T transform_reduce(InputIterator first, InputIterator last,
                   UnaryOperation unary_op, T init, BinaryOperation binary_op);

Returns:

GENERALIZED_SUM(binary_op, init, unary_op(*i), ...) for every i in [first,last).

Requires:

Neither unary_op nor binary_op shall invalidate subranges, or modify elements in the range [first,last)

Complexity:

O(last - first) applications each of unary_op and binary_op.

Notes:

transform_reduce does not apply unary_op to init.

template<class InputIterator, class OutputIterator,
      class UnaryOperation,
      class T, class BinaryOperation>
OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
                                        OutputIterator result,
                                        UnaryOperation unary_op,
                                        T init, BinaryOperation binary_op);

Effects:

Assigns through each iterator i in [result,result + (last - first)) the value of

• init, if i is result, otherwise
• GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, unary_op(*j), ...) for every j in [first,first + (i - result) - 1).

Returns:

The end of the resulting range beginning at result.

Requires:

Neither unary_op nor binary_op shall invalidate iterators or subranges, or modify elements in the ranges [first,last) or [result,result + (last - first)).

Complexity:

O(last - first) applications each of unary_op and binary_op.

Remarks:

result may be equal to first.

Notes:

The difference between transform_exclusive_scan and transform_inclusive_scan is that transform_exclusive_scan excludes the ith input element from the ith sum. If binary_op is not mathematically associative, the behavior of transform_exclusive_scan may be non-deterministic. transform_exclusive_scan does not apply unary_op to init.

template<class InputIterator, class OutputIterator,
      class UnaryOperation,
      class BinaryOperation>
OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
                                        OutputIterator result,
                                        UnaryOperation unary_op,
                                        BinaryOperation binary_op);template<class InputIterator, class OutputIterator,
      class UnaryOperation,
      class BinaryOperation, class T>
OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
                                        OutputIterator result,
                                        UnaryOperation unary_op,
                                        BinaryOperation binary_op, T init);

Effects:

Assigns through each iterator i in [result,result + (last - first)) the value of GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, unary_op(*j), ...) for every j in [first,first + (i - result)) or GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, unary_op(*j), ...) for every j in [first,first + (i - result)) if init is provided.

Returns:

The end of the resulting range beginning at result.

Requires:

Neither unary_op nor binary_op shall invalidate iterators or subranges, or modify elements in the ranges [first,last) or [result,result + (last - first)).

Complexity:

O(last - first) applications each of unary_op and binary_op.

Remarks:

result may be equal to first.

Notes:

The difference between transform_exclusive_scan and transform_inclusive_scan is that transform_inclusive_scan includes the ith input element in the ith sum. If binary_op is not mathematically associative, the behavior of transform_inclusive_scan may be non-deterministic. transform_inclusive_scan does not apply unary_op to init.