[ edit ] Return value

The generalized sum of a group of elements over an binary operation binary_op is defined as follows:

• If the group only has one element, the sum is the value of the element.
• Otherwise, performs the following operations in order:
  1. Takes any two elements elem1 and elem2 from the group.
  2. Calculates binary_op ( elem1, elem2 ) and puts the result back to the group.
  3. Repeats steps 1 and 2 until there is only one element in the group.

     [ edit ] Complexity

     Given \(\scriptsize N\) N as std:: distance ( first, last ) :

     1-4) \(\scriptsize O(N)\) O(N) applications of std:: plus <> ( ) .
     5,6) \(\scriptsize O(N)\) O(N) applications of op .

     [ edit ] 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::terminate is called. For any other ExecutionPolicy , the behavior is implementation-defined.
     • If the algorithm fails to allocate memory, std::bad_alloc is thrown.

       [ edit ] Notes

       std::reduce behaves like std::accumulate except the elements of the range may be grouped and rearranged in arbitrary order.

       [ edit ] Example

       side-by-side comparison between std::reduce and std::accumulate :

       Run this code

       #if PARALLEL
       #include <execution>
       #define SEQ std::execution::seq,
       #define PAR std::execution::par,
       #else
       #define SEQ
       #define PAR
       #endif
       #include <chrono>
       #include <iomanip>
       #include <iostream>
       #include <numeric>
       #include <utility>
       #include <vector>
       int main()
           std::cout.imbue(std::locale("en_US.UTF-8"));
           std::cout << std::fixed << std::setprecision(1);
           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::setw(28) << std::left << name << "sum: "
                         << result << '\t' << "time: " << 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(SEQ v.cbegin(), v.cend())}; });
               eval([&v]{ return std::pair{"std::reduce (par, double)",
                   std::reduce(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(), 0l)}; });
               eval([&v]{ return std::pair{"std::reduce (seq, long)",
                   std::reduce(SEQ v.cbegin(), v.cend())}; });
               eval([&v]{ return std::pair{"std::reduce (par, long)",
                   std::reduce(PAR v.cbegin(), v.cend())}; });
       Possible output:
       // POSIX: g++ -std=c++23 ./example.cpp -ltbb -O3; ./a.out
       std::accumulate (double)    sum: 10,000,000.7	time: 356.9 ms
       std::reduce (seq, double)   sum: 10,000,000.7	time: 140.1 ms
       std::reduce (par, double)   sum: 10,000,000.7	time: 140.1 ms
       std::accumulate (long)      sum: 100,000,007	time: 46.0 ms
       std::reduce (seq, long)     sum: 100,000,007	time: 67.3 ms
       std::reduce (par, long)     sum: 100,000,007	time: 63.3 ms
       // POSIX: g++ -std=c++23 ./example.cpp -ltbb -O3 -DPARALLEL; ./a.out
       std::accumulate (double)    sum: 10,000,000.7	time: 353.4 ms
       std::reduce (seq, double)   sum: 10,000,000.7	time: 140.7 ms
       std::reduce (par, double)   sum: 10,000,000.7	time: 24.7 ms
       std::accumulate (long)      sum: 100,000,007	time: 42.4 ms
       std::reduce (seq, long)     sum: 100,000,007	time: 52.0 ms
       std::reduce (par, long)     sum: 100,000,007	time: 23.1 ms
        
       [edit] See also