Use std namespace explicitly

Author: antonwolfy

dpnp/backend/extensions/statistics/histogram_common.hpp

@@ -71,23 +71,26 @@ struct CachedData
     template <int _Dims>
     void init(const sycl::nd_item<_Dims> &item) const
     {
-        uint32_t llid = item.get_local_linear_id();
+        std::uint32_t llid = item.get_local_linear_id();
         auto local_ptr = &local_data[0];
-        uint32_t size = local_data.size();
+        std::uint32_t size = local_data.size();
         auto group = item.get_group();
-        uint32_t local_size = group.get_local_linear_range();
+        std::uint32_t local_size = group.get_local_linear_range();
 
-        for (uint32_t i = llid; i < size; i += local_size) {
+        for (std::uint32_t i = llid; i < size; i += local_size) {
             local_ptr[i] = global_data[i];
         }
     }
 
-    size_t size() const { return local_data.size(); }
+    std::size_t size() const
+    {
+        return local_data.size();
+    }
 
     T &operator[](const sycl::id<Dims> &id) const { return local_data[id]; }
 
     template <typename = std::enable_if_t<Dims == 1>>
-    T &operator[](const size_t id) const
+    T &operator[](const std::size_t id) const
     {
         return local_data[id];
     }
@@ -119,12 +122,15 @@ struct UncachedData
     {
     }
 
-    size_t size() const { return _shape.size(); }
+    std::size_t size() const
+    {
+        return _shape.size();
+    }
 
     T &operator[](const sycl::id<Dims> &id) const { return global_data[id]; }
 
     template <typename = std::enable_if_t<Dims == 1>>
-    T &operator[](const size_t id) const
+    T &operator[](const std::size_t id) const
     {
         return global_data[id];
     }
@@ -141,15 +147,15 @@ struct HistLocalType
 };
 
 template <>
-struct HistLocalType<uint64_t>
+struct HistLocalType<std::uint64_t>
 {
-    using type = uint32_t;
+    using type = std::uint32_t;
 };
 
 template <>
-struct HistLocalType<int64_t>
+struct HistLocalType<std::int64_t>
 {
-    using type = int32_t;
+    using type = std::int32_t;
 };
 
 template <typename T, typename localT = typename HistLocalType<T>::type>
@@ -161,8 +167,8 @@ struct HistWithLocalCopies
     using LocalHist = sycl::local_accessor<localT, 2>;
 
     HistWithLocalCopies(T *global_data,
-                        size_t bins_count,
-                        int32_t copies_count,
+                        std::size_t bins_count,
+                        std::int32_t copies_count,
                         sycl::handler &cgh)
     {
         local_hist = LocalHist(sycl::range<2>(copies_count, bins_count), cgh);
@@ -172,23 +178,25 @@ struct HistWithLocalCopies
     template <int _Dims>
     void init(const sycl::nd_item<_Dims> &item, localT val = 0) const
     {
-        uint32_t llid = item.get_local_linear_id();
+        std::uint32_t llid = item.get_local_linear_id();
         auto *local_ptr = &local_hist[0][0];
-        uint32_t size = local_hist.size();
+        std::uint32_t size = local_hist.size();
         auto group = item.get_group();
-        uint32_t local_size = group.get_local_linear_range();
+        std::uint32_t local_size = group.get_local_linear_range();
 
-        for (uint32_t i = llid; i < size; i += local_size) {
+        for (std::uint32_t i = llid; i < size; i += local_size) {
             local_ptr[i] = val;
         }
     }
 
     template <int _Dims>
-    void add(const sycl::nd_item<_Dims> &item, int32_t bin, localT value) const
+    void add(const sycl::nd_item<_Dims> &item,
+             std::int32_t bin,
+             localT value) const
     {
-        int32_t llid = item.get_local_linear_id();
-        int32_t local_hist_count = local_hist.get_range().get(0);
-        int32_t local_copy_id =
+        std::int32_t llid = item.get_local_linear_id();
+        std::int32_t local_hist_count = local_hist.get_range().get(0);
+        std::int32_t local_copy_id =
             local_hist_count == 1 ? 0 : llid % local_hist_count;
 
         AtomicOp<localT, sycl::memory_order::relaxed,
@@ -200,15 +208,15 @@ struct HistWithLocalCopies
     template <int _Dims>
     void finalize(const sycl::nd_item<_Dims> &item) const
     {
-        uint32_t llid = item.get_local_linear_id();
-        uint32_t bins_count = local_hist.get_range().get(1);
-        uint32_t local_hist_count = local_hist.get_range().get(0);
+        std::uint32_t llid = item.get_local_linear_id();
+        std::uint32_t bins_count = local_hist.get_range().get(1);
+        std::uint32_t local_hist_count = local_hist.get_range().get(0);
         auto group = item.get_group();
-        uint32_t local_size = group.get_local_linear_range();
+        std::uint32_t local_size = group.get_local_linear_range();
 
-        for (uint32_t i = llid; i < bins_count; i += local_size) {
+        for (std::uint32_t i = llid; i < bins_count; i += local_size) {
             auto value = local_hist[0][i];
-            for (uint32_t lhc = 1; lhc < local_hist_count; ++lhc) {
+            for (std::uint32_t lhc = 1; lhc < local_hist_count; ++lhc) {
                 value += local_hist[lhc][i];
             }
             if (value != T(0)) {
@@ -219,7 +227,10 @@ struct HistWithLocalCopies
         }
     }
 
-    uint32_t size() const { return local_hist.size(); }
+    std::uint32_t size() const
+    {
+        return local_hist.size();
+    }
 
 private:
     LocalHist local_hist;
@@ -240,7 +251,7 @@ struct HistGlobalMemory
     }
 
     template <int _Dims>
-    void add(const sycl::nd_item<_Dims> &, int32_t bin, T value) const
+    void add(const sycl::nd_item<_Dims> &, std::int32_t bin, T value) const
     {
         AtomicOp<T, sycl::memory_order::relaxed,
                  sycl::memory_scope::device>::add(global_hist[bin], value);
@@ -255,18 +266,24 @@ struct HistGlobalMemory
     T *global_hist = nullptr;
 };
 
-template <typename T = uint32_t>
+template <typename T = std::uint32_t>
 struct NoWeights
 {
-    constexpr T get(size_t) const { return 1; }
+    constexpr T get(std::size_t) const
+    {
+        return 1;
+    }
 };
 
 template <typename T>
 struct Weights
 {
     Weights(T *weights) { data = weights; }
 
-    T get(size_t id) const { return data[id]; }
+    T get(std::size_t id) const
+    {
+        return data[id];
+    }
 
 private:
     T *data = nullptr;
@@ -281,9 +298,9 @@ bool check_in_bounds(const dT &val, const dT &min, const dT &max)
 
 template <typename T, typename HistImpl, typename Edges, typename Weights>
 void submit_histogram(const T *in,
-                      const size_t size,
-                      const size_t dims,
-                      const uint32_t WorkPI,
+                      const std::size_t size,
+                      const std::size_t dims,
+                      const std::uint32_t WorkPI,
                       const HistImpl &hist,
                       const Edges &edges,
                       const Weights &weights,
@@ -303,8 +320,8 @@ void validate(const usm_ndarray &sample,
               const std::optional<const dpctl::tensor::usm_ndarray> &weights,
               const usm_ndarray &histogram);
 
-uint32_t get_local_hist_copies_count(uint32_t loc_mem_size_in_items,
-                                     uint32_t local_size,
-                                     uint32_t hist_size_in_items);
+std::uint32_t get_local_hist_copies_count(std::uint32_t loc_mem_size_in_items,
+                                          std::uint32_t local_size,
+                                          std::uint32_t hist_size_in_items);
 
 } // namespace statistics::histogram

dpnp/backend/extensions/statistics/sliding_window1d.hpp

@@ -42,7 +42,7 @@ namespace statistics::sliding_window1d
 {
 using dpctl::tensor::usm_ndarray;
 
-template <typename T, uint32_t Size>
+template <typename T, std::uint32_t Size>
 class _RegistryDataStorage
 {
 public:
@@ -140,7 +140,7 @@ class _RegistryDataStorage
     ncT data[Size];
 };
 
-template <typename T, uint32_t Size = 1>
+template <typename T, std::uint32_t Size = 1>
 struct RegistryData : public _RegistryDataStorage<T, Size>
 {
     using SizeT = typename _RegistryDataStorage<T, Size>::SizeT;
@@ -332,7 +332,7 @@ struct RegistryData : public _RegistryDataStorage<T, Size>
     T *store(T *const data) { return store(data, true); }
 };
 
-template <typename T, uint32_t Size>
+template <typename T, std::uint32_t Size>
 struct RegistryWindow : public RegistryData<T, Size>
 {
     using SizeT = typename RegistryData<T, Size>::SizeT;
@@ -345,7 +345,7 @@ struct RegistryWindow : public RegistryData<T, Size>
         static_assert(std::is_integral_v<shT>,
                       "shift must be of an integral type");
 
-        uint32_t shift_r = this->size_x() - shift;
+        std::uint32_t shift_r = this->size_x() - shift;
         for (SizeT i = 0; i < Size; ++i) {
             this->data[i] = this->shift_left(i, shift);
             auto border =
@@ -365,7 +365,7 @@ struct RegistryWindow : public RegistryData<T, Size>
     }
 };
 
-template <typename T, typename SizeT = size_t>
+template <typename T, typename SizeT = std::size_t>
 class Span
 {
 public:
@@ -387,13 +387,13 @@ class Span
     const SizeT size_;
 };
 
-template <typename T, typename SizeT = size_t>
+template <typename T, typename SizeT = std::size_t>
 Span<T, SizeT> make_span(T *const data, const SizeT size)
 {
     return Span<T, SizeT>(data, size);
 }
 
-template <typename T, typename SizeT = size_t>
+template <typename T, typename SizeT = std::size_t>
 class PaddedSpan : public Span<T, SizeT>
 {
 public:
@@ -413,14 +413,14 @@ class PaddedSpan : public Span<T, SizeT>
     const SizeT pad_;
 };
 
-template <typename T, typename SizeT = size_t>
+template <typename T, typename SizeT = std::size_t>
 PaddedSpan<T, SizeT>
     make_padded_span(T *const data, const SizeT size, const SizeT offset)
 {
     return PaddedSpan<T, SizeT>(data, size, offset);
 }
 
-template <uint32_t WorkPI,
+template <std::uint32_t WorkPI,
           typename T,
           typename SizeT,
           typename Op,
@@ -442,7 +442,7 @@ void submit_sliding_window1d(const PaddedSpan<const T, SizeT> &a,
         nd_range, SlidingWindow1dKernel(a, v, op, red, out));
 }
 
-template <uint32_t WorkPI,
+template <std::uint32_t WorkPI,
           typename T,
           typename SizeT,
           typename Op,
@@ -467,6 +467,6 @@ void submit_sliding_window1d_small_kernel(const PaddedSpan<const T, SizeT> &a,
 void validate(const usm_ndarray &a,
               const usm_ndarray &v,
               const usm_ndarray &out,
-              const size_t l_pad,
-              const size_t r_pad);
+              const std::size_t l_pad,
+              const std::size_t r_pad);
 } // namespace statistics::sliding_window1d

dpnp/backend/kernels/statistics/histogram.hpp

@@ -76,7 +76,7 @@ class HistogramFunctor
 
         auto bounds = edges.get_bounds();
 
-        for (uint32_t i = 0; i < WorkPI; ++i) {
+        for (std::uint32_t i = 0; i < WorkPI; ++i) {
             auto data_idx = id * WorkPI * local_size + i * local_size + lid;
             if (data_idx < size) {
                 auto *d = &in[data_idx * dims];