Add std::count, std::count_if

Author: alugowski

README.md

@@ -28,6 +28,7 @@ Algorithms are added on an as-needed basis. If you need one [open an issue](http
 ### `<algorithm>`
 * [all_of](https://en.cppreference.com/w/cpp/algorithm/all_of), [any_of](https://en.cppreference.com/w/cpp/algorithm/any_of), [none_of](https://en.cppreference.com/w/cpp/algorithm/none_of)
 * [copy](https://en.cppreference.com/w/cpp/algorithm/copy), [copy_n](https://en.cppreference.com/w/cpp/algorithm/copy_n)
+* [count](https://en.cppreference.com/w/cpp/algorithm/count), [count_if](https://en.cppreference.com/w/cpp/algorithm/count_if)
 * [fill](https://en.cppreference.com/w/cpp/algorithm/fill), [fill_n](https://en.cppreference.com/w/cpp/algorithm/fill_n)
 * [find](https://en.cppreference.com/w/cpp/algorithm/find), [find_if](https://en.cppreference.com/w/cpp/algorithm/find_if), [find_if_not](https://en.cppreference.com/w/cpp/algorithm/find_if_not)
 * [for_each](https://en.cppreference.com/w/cpp/algorithm/for_each), [for_each_n](https://en.cppreference.com/w/cpp/algorithm/for_each_n)

include/poolstl/algorithm

@@ -43,6 +43,36 @@ namespace std {
         return poolstl::internal::advanced(dest, n);
     }
 
+    /**
+     * NOTE: Iterators are expected to be random access.
+     * See std::count_if https://en.cppreference.com/w/cpp/algorithm/count_if
+     */
+    template <class ExecPolicy, class RandIt, class UnaryPredicate>
+    poolstl::internal::enable_if_par<ExecPolicy, typename iterator_traits<RandIt>::difference_type>
+    count_if(ExecPolicy&& policy, RandIt first, RandIt last, UnaryPredicate p) {
+        using T = typename iterator_traits<RandIt>::difference_type;
+
+        auto futures = poolstl::internal::parallel_chunk_for(std::forward<ExecPolicy>(policy), first, last,
+                                                             [&p](RandIt chunk_first, RandIt chunk_last) {
+                                                                 return std::count_if(chunk_first, chunk_last, p);
+                                                             });
+
+        return poolstl::internal::cpp17::reduce(
+            poolstl::internal::get_wrap(futures.begin()),
+            poolstl::internal::get_wrap(futures.end()), 0, std::plus<T>());
+    }
+
+    /**
+     * NOTE: Iterators are expected to be random access.
+     * See std::count https://en.cppreference.com/w/cpp/algorithm/count
+     */
+    template <class ExecPolicy, class RandIt, class T>
+    poolstl::internal::enable_if_par<ExecPolicy, typename iterator_traits<RandIt>::difference_type>
+    count(ExecPolicy&& policy, RandIt first, RandIt last, const T& value) {
+        return std::count_if(std::forward<ExecPolicy>(policy), first, last,
+                             [&value](const T& test) { return test == value; });
+    }
+
     /**
      * NOTE: Iterators are expected to be random access.
      * See std::fill https://en.cppreference.com/w/cpp/algorithm/fill

include/poolstl/seq_fwd.hpp

@@ -66,6 +66,9 @@ namespace std {
     POOLSTL_DEFINE_BOTH_SEQ_FWD_AND_PAR_IF(any_of)
     POOLSTL_DEFINE_BOTH_SEQ_FWD_AND_PAR_IF(none_of)
 
+    POOLSTL_DEFINE_BOTH_SEQ_FWD_AND_PAR_IF(count)
+    POOLSTL_DEFINE_BOTH_SEQ_FWD_AND_PAR_IF(count_if)
+
     POOLSTL_DEFINE_BOTH_SEQ_FWD_AND_PAR_IF(copy)
     POOLSTL_DEFINE_BOTH_SEQ_FWD_AND_PAR_IF(copy_n)
 

tests/poolstl_test.cpp

@@ -90,6 +90,28 @@ TEST_CASE("copy_n", "[alg][algorithm]") {
     }
 }
 
+TEST_CASE("count", "[alg][algorithm]") {
+    for (auto num_threads : test_thread_counts) {
+        ttp::task_thread_pool pool(num_threads);
+
+        for (auto vec_size : test_arr_sizes) {
+            auto haystack = iota_vector(vec_size);
+
+            {
+                int needle = 5;
+                auto seq = std::count(poolstl::par_if<>(false), haystack.cbegin(), haystack.cend(), needle);
+                auto par = std::count(poolstl::par_pool(pool),  haystack.cbegin(), haystack.cend(), needle);
+                REQUIRE(seq == par);
+            }
+            {
+                auto pred = [&](auto x) { return x % 2 == 0; };
+                auto seq = std::count_if(poolstl::par_if<>(false), haystack.cbegin(), haystack.cend(), pred);
+                auto par = std::count_if(poolstl::par_pool(pool),  haystack.cbegin(), haystack.cend(), pred);
+                REQUIRE(seq == par);
+            }
+        }
+    }
+}
 
 TEST_CASE("fill", "[alg][algorithm]") {
     for (auto num_threads : test_thread_counts) {
@@ -367,15 +389,13 @@ TEST_CASE("execution_policies", "[execution]") {
     ttp::task_thread_pool pool;
     std::vector<int> v = {0, 1, 2, 3, 4, 5};
 
-    REQUIRE(15 == std::reduce(poolstl::par, v.cbegin(), v.cend()));
-    REQUIRE(15 == std::reduce(poolstl::par_pool(pool), v.cbegin(), v.cend()));
-#if POOLSTL_HAVE_CXX17_LIB
-    REQUIRE(15 == std::reduce(poolstl::seq, v.cbegin(), v.cend()));
-    REQUIRE(15 == std::reduce(poolstl::par_if<>(false), v.cbegin(), v.cend()));
-    REQUIRE(15 == std::reduce(poolstl::par_if<>(true), v.cbegin(), v.cend()));
-    REQUIRE(15 == std::reduce(poolstl::par_if_pool<>(false, pool), v.cbegin(), v.cend()));
-    REQUIRE(15 == std::reduce(poolstl::par_if_pool<>(true, pool), v.cbegin(), v.cend()));
-#endif
+    REQUIRE(1 == std::count(poolstl::par, v.cbegin(), v.cend(), 5));
+    REQUIRE(1 == std::count(poolstl::par_pool(pool), v.cbegin(), v.cend(), 5));
+    REQUIRE(1 == std::count(poolstl::seq, v.cbegin(), v.cend(), 5));
+    REQUIRE(1 == std::count(poolstl::par_if<>(false), v.cbegin(), v.cend(), 5));
+    REQUIRE(1 == std::count(poolstl::par_if<>(true), v.cbegin(), v.cend(), 5));
+    REQUIRE(1 == std::count(poolstl::par_if_pool<>(false, pool), v.cbegin(), v.cend(), 5));
+    REQUIRE(1 == std::count(poolstl::par_if_pool<>(true, pool), v.cbegin(), v.cend(), 5));
 }
 
 std::mt19937 rng{1};