Add std::transform_reduce

Author: alugowski

README.md

@@ -31,6 +31,7 @@ Algorithms are added on an as-needed basis. If you need one that is not present
 
 ### `<numeric>`
 * [std::reduce](https://en.cppreference.com/w/cpp/algorithm/reduce)
+* [std::transform_reduce](https://en.cppreference.com/w/cpp/algorithm/transform_reduce) (C++17 only)
 
 Note: All iterators must be random access.
 

include/poolstl/numeric

@@ -53,6 +53,57 @@ namespace std {
                            typename std::iterator_traits<RandIt>::value_type{});
     }
 
+#if POOLSTL_HAVE_CXX17_LIB
+    /**
+     * NOTE: Iterators are expected to be random access.
+     * See std::transform_reduce https://en.cppreference.com/w/cpp/algorithm/transform_reduce
+     */
+    template <class ExecPolicy, class RandIt1, class T, class BinaryReductionOp, class UnaryTransformOp>
+    poolstl::internal::enable_if_poolstl_execution_policy<ExecPolicy, T>
+    transform_reduce(ExecPolicy&& policy, RandIt1 first1, RandIt1 last1, T init,
+                     BinaryReductionOp reduce_op, UnaryTransformOp transform_op) {
+
+        auto futures = poolstl::internal::parallel_chunk_for(std::forward<ExecPolicy>(policy), first1, last1,
+             [&init, &reduce_op, &transform_op](RandIt1 chunk_first1, RandIt1 chunk_last1) {
+                 return std::transform_reduce(chunk_first1, chunk_last1, init, reduce_op, transform_op);
+             });
+
+        return poolstl::internal::cpp17::reduce(
+            poolstl::internal::get_wrap(futures.begin()),
+            poolstl::internal::get_wrap(futures.end()), init, reduce_op);
+    }
+
+    /**
+     * NOTE: Iterators are expected to be random access.
+     * See std::transform_reduce https://en.cppreference.com/w/cpp/algorithm/transform_reduce
+     */
+    template <class ExecPolicy, class RandIt1, class RandIt2, class T, class BinaryReductionOp, class BinaryTransformOp>
+    poolstl::internal::enable_if_poolstl_execution_policy<ExecPolicy, T>
+    transform_reduce(ExecPolicy&& policy, RandIt1 first1, RandIt1 last1, RandIt2 first2, T init,
+                     BinaryReductionOp reduce_op, BinaryTransformOp transform_op) {
+
+        auto futures = poolstl::internal::parallel_chunk_for(std::forward<ExecPolicy>(policy), first1, last1, first2,
+             [&init, &reduce_op, &transform_op](RandIt1 chunk_first1, RandIt1 chunk_last1, RandIt2 chunk_first2) {
+                 return std::transform_reduce(chunk_first1, chunk_last1, chunk_first2, init, reduce_op, transform_op);
+             });
+
+        return poolstl::internal::cpp17::reduce(
+            poolstl::internal::get_wrap(futures.begin()),
+            poolstl::internal::get_wrap(futures.end()), init, reduce_op);
+    }
+
+    /**
+     * NOTE: Iterators are expected to be random access.
+     * See std::transform_reduce https://en.cppreference.com/w/cpp/algorithm/transform_reduce
+     */
+    template< class ExecPolicy, class RandIt1, class RandIt2, class T >
+    poolstl::internal::enable_if_poolstl_execution_policy<ExecPolicy, T>
+    transform_reduce(ExecPolicy&& policy, RandIt1 first1, RandIt1 last1, RandIt2 first2, T init ) {
+        return transform_reduce(std::forward<ExecPolicy>(policy),
+            first1, last1, first2, init, std::plus<>(), std::multiplies<>());
+    }
+#endif
+
 }
 
 #endif

tests/poolstl_test.cpp

@@ -178,6 +178,38 @@ TEST_CASE("reduce", "[alg][numeric]") {
     }
 }
 
+#if POOLSTL_HAVE_CXX17_LIB
+TEST_CASE("transform_reduce_1", "[alg][numeric]") {
+    for (auto num_threads : test_thread_counts) {
+        ttp::task_thread_pool pool(num_threads);
+
+        for (auto num_iters : test_arr_sizes) {
+            auto v = iota_vector(num_iters);
+
+            auto doubler = [&](auto x) { return 2*x; };
+            auto seq = std::transform_reduce(v.cbegin(), v.cend(), 0, std::plus<>(), doubler);
+            auto par = std::transform_reduce(poolstl::par_pool(pool), v.cbegin(), v.cend(), 0, std::plus<>(), doubler);
+            REQUIRE(seq == par);
+        }
+    }
+}
+
+TEST_CASE("transform_reduce_2", "[alg][numeric]") {
+    for (auto num_threads : test_thread_counts) {
+        ttp::task_thread_pool pool(num_threads);
+
+        for (auto num_iters : test_arr_sizes) {
+            auto v1 = iota_vector(num_iters);
+            auto v2 = iota_vector(num_iters);
+
+            auto seq = std::transform_reduce(v1.cbegin(), v1.cend(), v2.cbegin(), 0);
+            auto par = std::transform_reduce(poolstl::par_pool(pool), v1.cbegin(), v1.cend(), v2.cbegin(), 0);
+            REQUIRE(seq == par);
+        }
+    }
+}
+#endif
+
 TEST_CASE("default_pool", "[execution]") {
     std::atomic<int> sum{0};
     for (auto num_iters : test_arr_sizes) {