FreeBSD Manual Pages
std::reduce(3) C++ Standard Libary std::reduce(3) NAME std::reduce - std::reduce Synopsis Defined in header <numeric> template< class InputIt > (since C++17) typename std::iterator_traits<InputIt>::value_type (until C++20) reduce( InputIt first, InputIt last ); template< class InputIt > constexpr typename (since std::iterator_traits<InputIt>::value_type C++20) reduce( InputIt first, InputIt last ); template< class ExecutionPolicy, class ForwardIt > typename std::iterator_traits<ForwardIt>::value_type (2) (since reduce( ExecutionPolicy&& policy, C++17) ForwardIt first, ForwardIt last ); (since template< class InputIt, class T > C++17) T reduce( InputIt first, InputIt last, T init ); (until C++20) template< class InputIt, class T > (1) (since constexpr T reduce( InputIt first, InputIt last, T C++20) init ); template< class ExecutionPolicy, class ForwardIt, class T > (4) (since T reduce( ExecutionPolicy&& policy, C++17) ForwardIt first, ForwardIt last, T init ); template< class InputIt, class T, class BinaryOp > (3) (since T reduce( InputIt first, InputIt last, T init, C++17) BinaryOp binary_op ); (until C++20) template< class InputIt, class T, class BinaryOp > (since constexpr T reduce( InputIt first, InputIt last, T C++20) init, BinaryOp binary_op ); (5) template< class ExecutionPolicy, class ForwardIt, class T, class BinaryOp > (since T reduce( ExecutionPolicy&& policy, (6) C++17) ForwardIt first, ForwardIt last, T init, BinaryOp binary_op ); 1) same as reduce(first, last, typename std::iterator_traits<In- putIt>::value_type{}) 3) same as reduce(first, last, init, std::plus<>()) 5) Reduces the range [first; last), possibly permuted and aggregated in unspecified manner, along with the initial value init over binary_op. 2,4,6) Same as (1,3,5), but executed according to policy. These overloads do not participate in overload resolution unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (until C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (since C++20) is true. The behavior is non-deterministic if binary_op is not associative or not commutative. The behavior is undefined if binary_op modifies any element or in- validates any iterator in [first; last], including the end iterator. Parameters first, last - the range of elements to apply the algorithm to init - the initial value of the generalized sum policy - the execution policy to use. See execution pol- icy for details. binary FunctionObject that will be applied in unspecified order binary_op - to the result of dereferencing the input itera- tors, the results of other binary_op and init. Type requirements - InputIt must meet the requirements of LegacyInputIterator. - ForwardIt must meet the requirements of LegacyForwardIterator. - T must meet the requirements of MoveConstructible. and bi- nary_op(init, *first), binary_op(*first, init), binary_op(init, init), and bi- nary_op(*first, *first) must be convertible to T. Return value Generalized sum of init and *first, *(first+1), ... *(last-1) over binary_op, where generalized sum GSUM(op, a 1, ..., a N) is defined as follows: * if N=1, a 1 * if N > 1, op(GSUM(op, b 1, ..., b K), GSUM(op, b M, ..., b N)) where * b 1, ..., b N may be any permutation of a1, ..., aN and * 1 < K+1 = M N in other words, reduce behaves like std::accumulate except the ele- ments of the range may be grouped and rearranged in arbitrary order Complexity O(last - first) applications of binary_op. Exceptions The overloads with a template parameter named ExecutionPolicy report errors as follows: * If execution of a function invoked as part of the algorithm throws an exception and ExecutionPolicy is one of the standard policies, std::termi- nate is called. For any other ExecutionPolicy, the behavior is implementation- defined. * If the algorithm fails to allocate memory, std::bad_alloc is thrown. Notes If the range is empty, init is returned, unmodified Example side-by-side comparison between reduce and std::accumulate: // Run this code #include <chrono> #include <execution> #include <iomanip> #include <iostream> #include <numeric> #include <utility> #include <vector> int main() { auto eval = [](auto fun) { const auto t1 = std::chrono::high_resolution_clock::now(); const auto [name, result] = fun(); const auto t2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration<double, std::milli> ms = t2 - t1; std::cout << std::fixed << std::setprecision(1) << name << " result " << result << " took " << ms.count() << " ms\n"; }; { const std::vector<double> v(100'000'007, 0.1); eval([&v]{ return std::pair{"std::accumulate (double)", std::accumulate(v.cbegin(), v.cend(), 0.0)}; } ); eval([&v]{ return std::pair{"std::reduce (seq, double)", std::reduce(std::execution::seq, v.cbegin(), v.cend())}; } ); eval([&v]{ return std::pair{"std::reduce (par, double)", std::reduce(std::execution::par, v.cbegin(), v.cend())}; } ); }{ const std::vector<long> v(100'000'007, 1); eval([&v]{ return std::pair{"std::accumulate (long)", std::accumulate(v.cbegin(), v.cend(), 0)}; } ); eval([&v]{ return std::pair{"std::reduce (seq, long)", std::reduce(std::execution::seq, v.cbegin(), v.cend())}; } ); eval([&v]{ return std::pair{"std::reduce (par, long)", std::reduce(std::execution::par, v.cbegin(), v.cend())}; } ); } } Possible output: std::accumulate (double) result 10000000.7 took 163.6 ms std::reduce (seq, double) result 10000000.7 took 162.9 ms std::reduce (par, double) result 10000000.7 took 97.5 ms std::accumulate (long) result 100000007 took 62.3 ms std::reduce (seq, long) result 100000007 took 64.3 ms std::reduce (par, long) result 100000007 took 49.0 ms See also accumulate sums up a range of elements (function template) applies a function to a range of elements, storing results in a transform destination range (function template) transform_reduce applies an invocable, then reduces out of order (C++17) (function template) http://cppreference.com 2022.07.31 std::reduce(3)
NAME | Synopsis | Parameters | Type requirements | Return value | Complexity | Exceptions | Notes | Example | Possible output: | See also
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::reduce&sektion=3&manpath=FreeBSD+Ports+15.0>