Apply review comments #2

Author: AlexanderKalistratov

dpnp/backend/extensions/statistics/bincount.cpp

@@ -114,8 +114,9 @@ struct BincountF
                 const auto local_mem_size =
                     get_local_mem_size_in_items<T>(exec_q);
                 if (local_mem_size >= needed_bins_count) {
-                    uint32_t local_hist_count = get_local_hist_copies_count(
-                        local_mem_size, local_size, needed_bins_count);
+                    const uint32_t local_hist_count =
+                        get_local_hist_copies_count(local_mem_size, local_size,
+                                                    needed_bins_count);
 
                     auto hist = HistWithLocalCopies<HistType>(
                         out, needed_bins_count, local_hist_count, cgh);
@@ -155,13 +156,13 @@ Bincount::Bincount() : dispatch_table("sample", "histogram")
     dispatch_table.populate_dispatch_table<SupportedTypes, BincountF>();
 }
 
-std::tuple<sycl::event, sycl::event>
-    Bincount::call(const dpctl::tensor::usm_ndarray &sample,
-                   int64_t min,
-                   int64_t max,
-                   std::optional<const dpctl::tensor::usm_ndarray> &weights,
-                   dpctl::tensor::usm_ndarray &histogram,
-                   const std::vector<sycl::event> &depends)
+std::tuple<sycl::event, sycl::event> Bincount::call(
+    const dpctl::tensor::usm_ndarray &sample,
+    const int64_t min,
+    const int64_t max,
+    const std::optional<const dpctl::tensor::usm_ndarray> &weights,
+    dpctl::tensor::usm_ndarray &histogram,
+    const std::vector<sycl::event> &depends)
 {
     validate(sample, std::optional<const dpctl::tensor::usm_ndarray>(), weights,
              histogram);

dpnp/backend/extensions/statistics/bincount.hpp

@@ -40,8 +40,8 @@ struct Bincount
 {
     using FnT = sycl::event (*)(sycl::queue &,
                                 const void *,
-                                int64_t,
-                                int64_t,
+                                const int64_t,
+                                const int64_t,
                                 const void *,
                                 void *,
                                 const size_t,
@@ -54,9 +54,9 @@ struct Bincount
 
     std::tuple<sycl::event, sycl::event>
         call(const dpctl::tensor::usm_ndarray &input,
-             int64_t min,
-             int64_t max,
-             std::optional<const dpctl::tensor::usm_ndarray> &weights,
+             const int64_t min,
+             const int64_t max,
+             const std::optional<const dpctl::tensor::usm_ndarray> &weights,
              dpctl::tensor::usm_ndarray &output,
              const std::vector<sycl::event> &depends);
 };

tests/test_histogram.py

@@ -576,3 +576,37 @@ def test_different_bins_amount(self, bins_count):
         expected_hist = numpy.bincount(v)
         result_hist = dpnp.bincount(iv)
         assert_array_equal(result_hist, expected_hist)
+
+    @pytest.mark.parametrize(
+        "array",
+        [[1, 2, 3], [1, 2, 2, 1, 2, 4], [2, 2, 2, 2]],
+        ids=["[1, 2, 3]", "[1, 2, 2, 1, 2, 4]", "[2, 2, 2, 2]"],
+    )
+    @pytest.mark.parametrize(
+        "minlength", [0, 1, 3, 5], ids=["0", "1", "3", "5"]
+    )
+    def test_bincount_minlength(self, array, minlength):
+        np_a = numpy.array(array)
+        dpnp_a = dpnp.array(array)
+
+        expected = numpy.bincount(np_a, minlength=minlength)
+        result = dpnp.bincount(dpnp_a, minlength=minlength)
+        assert_allclose(expected, result)
+
+    @pytest.mark.parametrize(
+        "array", [[1, 2, 2, 1, 2, 4]], ids=["[1, 2, 2, 1, 2, 4]"]
+    )
+    @pytest.mark.parametrize(
+        "weights",
+        [None, [0.3, 0.5, 0.2, 0.7, 1.0, -0.6], [2, 2, 2, 2, 2, 2]],
+        ids=["None", "[0.3, 0.5, 0.2, 0.7, 1., -0.6]", "[2, 2, 2, 2, 2, 2]"],
+    )
+    def test_bincount_weights(self, array, weights):
+        np_a = numpy.array(array)
+        np_weights = numpy.array(weights) if weights is not None else weights
+        dpnp_a = dpnp.array(array)
+        dpnp_weights = dpnp.array(weights) if weights is not None else weights
+
+        expected = numpy.bincount(np_a, weights=np_weights)
+        result = dpnp.bincount(dpnp_a, weights=dpnp_weights)
+        assert_allclose(expected, result)

tests/test_statistics.py

@@ -573,43 +573,6 @@ def test_std_error(self):
             dpnp.std(ia, ddof="1")
 
 
-@pytest.mark.usefixtures("allow_fall_back_on_numpy")
-class TestBincount:
-    @pytest.mark.parametrize(
-        "array",
-        [[1, 2, 3], [1, 2, 2, 1, 2, 4], [2, 2, 2, 2]],
-        ids=["[1, 2, 3]", "[1, 2, 2, 1, 2, 4]", "[2, 2, 2, 2]"],
-    )
-    @pytest.mark.parametrize(
-        "minlength", [0, 1, 3, 5], ids=["0", "1", "3", "5"]
-    )
-    def test_bincount_minlength(self, array, minlength):
-        np_a = numpy.array(array)
-        dpnp_a = dpnp.array(array)
-
-        expected = numpy.bincount(np_a, minlength=minlength)
-        result = dpnp.bincount(dpnp_a, minlength=minlength)
-        assert_allclose(expected, result)
-
-    @pytest.mark.parametrize(
-        "array", [[1, 2, 2, 1, 2, 4]], ids=["[1, 2, 2, 1, 2, 4]"]
-    )
-    @pytest.mark.parametrize(
-        "weights",
-        [None, [0.3, 0.5, 0.2, 0.7, 1.0, -0.6], [2, 2, 2, 2, 2, 2]],
-        ids=["None", "[0.3, 0.5, 0.2, 0.7, 1., -0.6]", "[2, 2, 2, 2, 2, 2]"],
-    )
-    def test_bincount_weights(self, array, weights):
-        np_a = numpy.array(array)
-        np_weights = numpy.array(weights) if weights is not None else weights
-        dpnp_a = dpnp.array(array)
-        dpnp_weights = dpnp.array(weights) if weights is not None else weights
-
-        expected = numpy.bincount(np_a, weights=np_weights)
-        result = dpnp.bincount(dpnp_a, weights=dpnp_weights)
-        assert_allclose(expected, result)
-
-
 @pytest.mark.parametrize(
     "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
 )