Appliesunary_op to each element in the range[first, last) and reduces the results (possibly permuted and aggregated in unspecified manner) along with the initial valueinit overbinary_op.

The behavior is non-deterministic ifbinary_op is not associative or not commutative.

The behavior is undefined ifunary_op orbinary_op modifies any element or invalidates any iterator in[first, last).

[edit]Parameters

[edit]Return value

Generalized sum ofinit andunary_op(*first),unary_op(*(first+1)), ...unary_op(*(last-1)) overbinary_op,where generalized sumGSUM(op, a1, ..., aN) is defined as follows:

• ifN = 1,a1,
• ifN > 1,op(GSUM(op, b1, ..., bK), GSUM(op, bM, ..., bN)) where

• b1, ..., bN may be any permutation ofa1, ..., aN and
• 1 < K + 1 = M ≤ N

in other words, the results ofunary_op may be grouped and arranged in arbitrary order.

[edit]Complexity

O(last - first) applications each ofunary_op andbinary_op.

[edit]Exceptions

• If execution of a function invoked as part of the algorithm throws an exception,

• ifpolicy isparallel_vector_execution_policy,std::terminate is called.
• ifpolicy issequential_execution_policy orparallel_execution_policy, the algorithm exits with anexception_list containing all uncaught exceptions. If there was only one uncaught exception, the algorithm may rethrow it without wrapping inexception_list. It is unspecified how much work the algorithm will perform before returning after the first exception was encountered.
• ifpolicy is some other type, the behavior is implementation-defined.

• If the algorithm fails to allocate memory (either for itself or to construct anexception_list when handling a user exception),std::bad_alloc is thrown.

[edit]Notes

unary_op is not applied toinit.

If the range is empty,init is returned, unmodified.

• Ifpolicy is an instance ofsequential_execution_policy, all operations are performed in the calling thread.
• Ifpolicy is an instance ofparallel_execution_policy, operations may be performed in unspecified number of threads, indeterminately sequenced with each other.
• Ifpolicy is an instance ofparallel_vector_execution_policy, execution may be both parallelized and vectorized: function body boundaries are not respected and user code may be overlapped and combined in arbitrary manner (in particular, this implies that a user-provided Callable must not acquire a mutex to access a shared resource).

[edit]Example

#include <boost/iterator/zip_iterator.hpp>#include <boost/tuple.hpp>#include <experimental/execution_policy>#include <experimental/numeric>#include <functional>#include <iostream>#include <iterator>#include <vector> int main(){std::vector<double> xvalues(10007,1.0), yvalues(10007,1.0); double result= std::experimental::parallel::transform_reduce(std::experimental::parallel::par,        boost::iterators::make_zip_iterator(            boost::make_tuple(std::begin(xvalues),std::begin(yvalues))),        boost::iterators::make_zip_iterator(            boost::make_tuple(std::end(xvalues),std::end(yvalues))),[](auto r){return boost::get<0>(r)* boost::get<1>(r);}0.0,std::plus<>());std::cout<< result<<'\n';}

10007

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文