pre-commit

Author: AlexanderKalistratov

dpnp/backend/extensions/statistics/kth_element1d.cpp

@@ -40,8 +40,8 @@
 #include "kth_element1d.hpp"
 #include "partitioning.hpp"
 
-#include <iostream>
 #include <chrono>
+#include <iostream>
 
 namespace sycl_exp = sycl::ext::oneapi::experimental;
 namespace dpctl_td_ns = dpctl::tensor::type_dispatch;
@@ -152,7 +152,8 @@ struct KthElementF
                         auto gh = sycl_exp::group_with_scratchpad(
                             group, sycl::span{&scratch[0], temp_memory_size});
                         if (num_elems > 0)
-                            sycl_exp::joint_sort(gh, &_in[0], &_in[num_elems], Less<T>{});
+                            sycl_exp::joint_sort(gh, &_in[0], &_in[num_elems],
+                                                 Less<T>{});
 
                         if (group.leader()) {
                             uint64_t offset = state.counters.less_count[0];
@@ -188,7 +189,8 @@ struct KthElementF
                     auto gh = sycl_exp::group_with_scratchpad(
                         group, sycl::span{&scratch[0], temp_memory_size});
                     sycl_exp::joint_sort(gh, &loc_items[0],
-                                         &loc_items[0] + items_to_sort, Less<T>{});
+                                         &loc_items[0] + items_to_sort,
+                                         Less<T>{});
 
                     T new_pivot = loc_items[items_to_sort / 2];
 
@@ -256,7 +258,8 @@ struct KthElementF
         uint32_t limit = 4 * (items_to_sort + 1);
         uint32_t iterations =
             std::ceil(-std::log(double(state.n) / limit) / std::log(0.536)) + 1;
-        // Ensure iterations are odd so the final result is always stored in 'partitioned'
+        // Ensure iterations are odd so the final result is always stored in
+        // 'partitioned'
         iterations += 1 - iterations % 2;
 
         auto prev = run_pick_pivot(exec_q, const_cast<T *>(in), partitioned, k,
@@ -267,8 +270,8 @@ struct KthElementF
         T *_in = partitioned;
         T *_out = temp_buff;
         for (uint32_t i = 0; i < iterations - 1; ++i) {
-            prev = run_pick_pivot(exec_q, _in, _out, k, state,
-                                  items_to_sort, limit, {prev});
+            prev = run_pick_pivot(exec_q, _in, _out, k, state, items_to_sort,
+                                  limit, {prev});
             prev = run_partition(exec_q, _in, _out, pstate, {prev});
             std::swap(_in, _out);
         }
@@ -278,13 +281,12 @@ struct KthElementF
         return prev;
     }
 
-    static KthElement1d::RetT
-        impl(sycl::queue &exec_queue,
-             const void *v_ain,
-             void *v_partitioned,
-             const size_t a_size,
-             const size_t k,
-             const std::vector<sycl::event> &depends)
+    static KthElement1d::RetT impl(sycl::queue &exec_queue,
+                                   const void *v_ain,
+                                   void *v_partitioned,
+                                   const size_t a_size,
+                                   const size_t k,
+                                   const std::vector<sycl::event> &depends)
     {
         auto start = std::chrono::high_resolution_clock::now();
         const T *ain = static_cast<const T *>(v_ain);
@@ -298,9 +300,9 @@ struct KthElementF
         init_e = pstate.init(exec_queue, {init_e});
 
         auto temp_buff = dpctl_utils::smart_malloc<T>(state.n, exec_queue,
-            sycl::usm::alloc::device);
-        auto evt = run_kth_element(exec_queue, ain, partitioned, temp_buff.get(), k, state,
-                                   pstate, {init_e});
+                                                      sycl::usm::alloc::device);
+        auto evt = run_kth_element(exec_queue, ain, partitioned,
+                                   temp_buff.get(), k, state, pstate, {init_e});
 
         bool found = false;
         bool left = false;
@@ -315,7 +317,8 @@ struct KthElementF
         copy_evt = exec_queue.copy(state.counters.greater_equal_count,
                                    &greater_equal_count, 1, copy_evt);
         copy_evt = exec_queue.copy(state.num_elems, &num_elems, 1, copy_evt);
-        copy_evt = exec_queue.copy(state.counters.nan_count, &nan_count, 1, copy_evt);
+        copy_evt =
+            exec_queue.copy(state.counters.nan_count, &nan_count, 1, copy_evt);
 
         uint64_t buff_offset = 0;
         uint64_t elems_offset = less_count;
@@ -344,25 +347,30 @@ struct KthElementF
                 .count();
 
         std::cout << "KthElement1d took " << duration << " microseconds"
-                << std::endl;
+                  << std::endl;
         return {found, buff_offset, elems_offset, num_elems, nan_count};
     }
 };
 
-using SupportedTypes =
-    std::tuple<uint32_t, int32_t, uint64_t, int64_t, float, double, std::complex<float>, std::complex<double>>;
+using SupportedTypes = std::tuple<uint32_t,
+                                  int32_t,
+                                  uint64_t,
+                                  int64_t,
+                                  float,
+                                  double,
+                                  std::complex<float>,
+                                  std::complex<double>>;
 } // namespace
 
 KthElement1d::KthElement1d() : dispatch_table("a")
 {
     dispatch_table.populate_dispatch_table<SupportedTypes, KthElementF>();
 }
 
-KthElement1d::RetT
-    KthElement1d::call(const dpctl::tensor::usm_ndarray &a,
-                       dpctl::tensor::usm_ndarray &partitioned,
-                       const size_t k,
-                       const std::vector<sycl::event> &depends)
+KthElement1d::RetT KthElement1d::call(const dpctl::tensor::usm_ndarray &a,
+                                      dpctl::tensor::usm_ndarray &partitioned,
+                                      const size_t k,
+                                      const std::vector<sycl::event> &depends)
 {
     // validate(a, partitioned, k);
 

dpnp/backend/extensions/statistics/kth_element1d.hpp

@@ -34,23 +34,21 @@ namespace statistics::partitioning
 struct KthElement1d
 {
     using RetT = std::tuple<bool, uint64_t, uint64_t, uint64_t, uint64_t>;
-    using FnT = RetT (*)(
-        sycl::queue &,
-        const void *,
-        void *,
-        const size_t,
-        const size_t,
-        const std::vector<sycl::event> &);
+    using FnT = RetT (*)(sycl::queue &,
+                         const void *,
+                         void *,
+                         const size_t,
+                         const size_t,
+                         const std::vector<sycl::event> &);
 
     ext::common::DispatchTable<FnT> dispatch_table;
 
     KthElement1d();
 
-    RetT
-        call(const dpctl::tensor::usm_ndarray &a,
-             dpctl::tensor::usm_ndarray &partitioned,
-             uint64_t k,
-             const std::vector<sycl::event> &depends);
+    RetT call(const dpctl::tensor::usm_ndarray &a,
+              dpctl::tensor::usm_ndarray &partitioned,
+              uint64_t k,
+              const std::vector<sycl::event> &depends);
 };
 
 void populate_kth_element1d(py::module_ m);

dpnp/backend/extensions/statistics/partitioning.hpp

@@ -347,7 +347,7 @@ void submit_partition_one_pivot(sycl::handler &cgh,
                         out[sbg_less_offset + le_item_offset + le_pos] =
                             values[_i];
                     }
-                    else if (!is_nan){
+                    else if (!is_nan) {
                         out[sbg_gr_offset + gr_item_offset + ge_pos] =
                             values[_i];
                     }

dpnp/dpnp_utils/dpnp_utils_statistics.py

@@ -27,13 +27,12 @@
 
 import dpctl
 import dpctl.tensor as dpt
+import dpctl.utils as dpu
 from dpctl.tensor._numpy_helper import normalize_axis_tuple
 from dpctl.utils import ExecutionPlacementError
-import dpnp.backend.extensions.statistics._statistics_impl as statistics_ext
-
-import dpctl.utils as dpu
 
 import dpnp
+import dpnp.backend.extensions.statistics._statistics_impl as statistics_ext
 from dpnp.dpnp_array import dpnp_array
 
 __all__ = ["dpnp_cov", "dpnp_median"]
@@ -193,6 +192,7 @@ def dpnp_cov(
     c = dpnp.dot(x, x_t.conj()) / fact
     return c.squeeze()
 
+
 def native_median(a):
 
     partitioned = dpnp.empty_like(a)
@@ -201,14 +201,16 @@ def native_median(a):
 
     _manager = dpu.SequentialOrderManager[a.sycl_queue]
 
-    result = dpnp.empty_like(a, shape = 1)
+    result = dpnp.empty_like(a, shape=1)
     k = a.shape[0] // 2
 
-    found, buff_offset, elems_offset, num_elems, nan_count = statistics_ext.kth_element(
-        a_usm,
-        partitioned_usm,
-        k,
-        depends=_manager.submitted_events,
+    found, buff_offset, elems_offset, num_elems, nan_count = (
+        statistics_ext.kth_element(
+            a_usm,
+            partitioned_usm,
+            k,
+            depends=_manager.submitted_events,
+        )
     )
 
     if found:
@@ -218,7 +220,7 @@ def native_median(a):
         else:
             result[0] = partitioned[0]
     else:
-        partitioned[buff_offset:buff_offset + num_elems].sort()
+        partitioned[buff_offset : buff_offset + num_elems].sort()
         kth_idx = buff_offset + k - elems_offset
         if a.shape[0] % 2 == 0:
             # even number of elements