Use std namespace explicitly

antonwolfy · antonwolfy · commit 1e8068c41a4f · 2026-03-17T15:53:30.000+01:00
diff --git a/dpnp/backend/extensions/statistics/histogram_common.hpp b/dpnp/backend/extensions/statistics/histogram_common.hpp
@@ -74,18 +74,18 @@ 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
+    std::size_t size() const
     {
         return local_data.size();
     }
@@ -96,7 +96,7 @@ struct CachedData
     }
 
     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];
     }
@@ -131,7 +131,7 @@ struct UncachedData
     {
     }
 
-    size_t size() const
+    std::size_t size() const
     {
         return _shape.size();
     }
@@ -142,7 +142,7 @@ struct UncachedData
     }
 
     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];
     }
@@ -159,15 +159,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>
@@ -179,8 +179,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);
@@ -190,23 +190,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,
@@ -218,15 +220,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)) {
@@ -237,7 +239,7 @@ struct HistWithLocalCopies
         }
     }
 
-    uint32_t size() const
+    std::uint32_t size() const
     {
         return local_hist.size();
     }
@@ -264,7 +266,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);
@@ -279,10 +281,10 @@ 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
+    constexpr T get(std::size_t) const
     {
         return 1;
     }
@@ -296,7 +298,7 @@ struct Weights
         data = weights;
     }
 
-    T get(size_t id) const
+    T get(std::size_t id) const
     {
         return data[id];
     }
@@ -314,9 +316,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,
@@ -336,8 +338,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
diff --git a/dpnp/backend/extensions/statistics/sliding_window1d.hpp b/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:
@@ -155,7 +155,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;
@@ -351,7 +351,7 @@ struct RegistryData : public _RegistryDataStorage<T, Size>
     }
 };
 
-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;
@@ -364,7 +364,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 =
@@ -387,7 +387,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:
@@ -421,13 +421,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:
@@ -453,14 +453,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,
@@ -482,7 +482,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,
@@ -507,6 +507,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
diff --git a/dpnp/backend/kernels/statistics/histogram.hpp b/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];
diff --git a/dpnp/backend/kernels/statistics/sliding_window1d.hpp b/dpnp/backend/kernels/statistics/sliding_window1d.hpp

Original file line number	Diff line number	Diff line change
`@@ -74,18 +74,18 @@ struct CachedData`
`74`	`74`	`template <int _Dims>`
`75`	`75`	`void init(const sycl::nd_item<_Dims> &item) const`
`76`	`76`	`{`
`77`		`- uint32_t llid = item.get_local_linear_id();`
	`77`	`+ std::uint32_t llid = item.get_local_linear_id();`
`78`	`78`	`auto local_ptr = &local_data[0];`
`79`		`- uint32_t size = local_data.size();`
	`79`	`+ std::uint32_t size = local_data.size();`
`80`	`80`	`auto group = item.get_group();`
`81`		`- uint32_t local_size = group.get_local_linear_range();`
	`81`	`+ std::uint32_t local_size = group.get_local_linear_range();`
`82`	`82`
`83`		`- for (uint32_t i = llid; i < size; i += local_size) {`
	`83`	`+ for (std::uint32_t i = llid; i < size; i += local_size) {`
`84`	`84`	`local_ptr[i] = global_data[i];`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
`88`		`- size_t size() const`
	`88`	`+ std::size_t size() const`
`89`	`89`	`{`
`90`	`90`	`return local_data.size();`
`91`	`91`	`}`
`@@ -96,7 +96,7 @@ struct CachedData`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`template <typename = std::enable_if_t<Dims == 1>>`
`99`		`- T &operator[](const size_t id) const`
	`99`	`+ T &operator[](const std::size_t id) const`
`100`	`100`	`{`
`101`	`101`	`return local_data[id];`
`102`	`102`	`}`
`@@ -131,7 +131,7 @@ struct UncachedData`
`131`	`131`	`{`
`132`	`132`	`}`
`133`	`133`
`134`		`- size_t size() const`
	`134`	`+ std::size_t size() const`
`135`	`135`	`{`
`136`	`136`	`return _shape.size();`
`137`	`137`	`}`
`@@ -142,7 +142,7 @@ struct UncachedData`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`template <typename = std::enable_if_t<Dims == 1>>`
`145`		`- T &operator[](const size_t id) const`
	`145`	`+ T &operator[](const std::size_t id) const`
`146`	`146`	`{`
`147`	`147`	`return global_data[id];`
`148`	`148`	`}`
`@@ -159,15 +159,15 @@ struct HistLocalType`
`159`	`159`	`};`
`160`	`160`
`161`	`161`	`template <>`
`162`		`-struct HistLocalType<uint64_t>`
	`162`	`+struct HistLocalType<std::uint64_t>`
`163`	`163`	`{`
`164`		`- using type = uint32_t;`
	`164`	`+ using type = std::uint32_t;`
`165`	`165`	`};`
`166`	`166`
`167`	`167`	`template <>`
`168`		`-struct HistLocalType<int64_t>`
	`168`	`+struct HistLocalType<std::int64_t>`
`169`	`169`	`{`
`170`		`- using type = int32_t;`
	`170`	`+ using type = std::int32_t;`
`171`	`171`	`};`
`172`	`172`
`173`	`173`	`template <typename T, typename localT = typename HistLocalType<T>::type>`
`@@ -179,8 +179,8 @@ struct HistWithLocalCopies`
`179`	`179`	`using LocalHist = sycl::local_accessor<localT, 2>;`
`180`	`180`
`181`	`181`	`HistWithLocalCopies(T *global_data,`
`182`		`- size_t bins_count,`
`183`		`- int32_t copies_count,`
	`182`	`+ std::size_t bins_count,`
	`183`	`+ std::int32_t copies_count,`
`184`	`184`	`sycl::handler &cgh)`
`185`	`185`	`{`
`186`	`186`	`local_hist = LocalHist(sycl::range<2>(copies_count, bins_count), cgh);`
`@@ -190,23 +190,25 @@ struct HistWithLocalCopies`
`190`	`190`	`template <int _Dims>`
`191`	`191`	`void init(const sycl::nd_item<_Dims> &item, localT val = 0) const`
`192`	`192`	`{`
`193`		`- uint32_t llid = item.get_local_linear_id();`
	`193`	`+ std::uint32_t llid = item.get_local_linear_id();`
`194`	`194`	`auto *local_ptr = &local_hist[0][0];`
`195`		`- uint32_t size = local_hist.size();`
	`195`	`+ std::uint32_t size = local_hist.size();`
`196`	`196`	`auto group = item.get_group();`
`197`		`- uint32_t local_size = group.get_local_linear_range();`
	`197`	`+ std::uint32_t local_size = group.get_local_linear_range();`
`198`	`198`
`199`		`- for (uint32_t i = llid; i < size; i += local_size) {`
	`199`	`+ for (std::uint32_t i = llid; i < size; i += local_size) {`
`200`	`200`	`local_ptr[i] = val;`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`template <int _Dims>`
`205`		`- void add(const sycl::nd_item<_Dims> &item, int32_t bin, localT value) const`
	`205`	`+ void add(const sycl::nd_item<_Dims> &item,`
	`206`	`+ std::int32_t bin,`
	`207`	`+ localT value) const`
`206`	`208`	`{`
`207`		`- int32_t llid = item.get_local_linear_id();`
`208`		`- int32_t local_hist_count = local_hist.get_range().get(0);`
`209`		`- int32_t local_copy_id =`
	`209`	`+ std::int32_t llid = item.get_local_linear_id();`
	`210`	`+ std::int32_t local_hist_count = local_hist.get_range().get(0);`
	`211`	`+ std::int32_t local_copy_id =`
`210`	`212`	`local_hist_count == 1 ? 0 : llid % local_hist_count;`
`211`	`213`
`212`	`214`	`AtomicOp<localT, sycl::memory_order::relaxed,`
`@@ -218,15 +220,15 @@ struct HistWithLocalCopies`
`218`	`220`	`template <int _Dims>`
`219`	`221`	`void finalize(const sycl::nd_item<_Dims> &item) const`
`220`	`222`	`{`
`221`		`- uint32_t llid = item.get_local_linear_id();`
`222`		`- uint32_t bins_count = local_hist.get_range().get(1);`
`223`		`- uint32_t local_hist_count = local_hist.get_range().get(0);`
	`223`	`+ std::uint32_t llid = item.get_local_linear_id();`
	`224`	`+ std::uint32_t bins_count = local_hist.get_range().get(1);`
	`225`	`+ std::uint32_t local_hist_count = local_hist.get_range().get(0);`
`224`	`226`	`auto group = item.get_group();`
`225`		`- uint32_t local_size = group.get_local_linear_range();`
	`227`	`+ std::uint32_t local_size = group.get_local_linear_range();`
`226`	`228`
`227`		`- for (uint32_t i = llid; i < bins_count; i += local_size) {`
	`229`	`+ for (std::uint32_t i = llid; i < bins_count; i += local_size) {`
`228`	`230`	`auto value = local_hist[0][i];`
`229`		`- for (uint32_t lhc = 1; lhc < local_hist_count; ++lhc) {`
	`231`	`+ for (std::uint32_t lhc = 1; lhc < local_hist_count; ++lhc) {`
`230`	`232`	`value += local_hist[lhc][i];`
`231`	`233`	`}`
`232`	`234`	`if (value != T(0)) {`
`@@ -237,7 +239,7 @@ struct HistWithLocalCopies`
`237`	`239`	`}`
`238`	`240`	`}`
`239`	`241`
`240`		`- uint32_t size() const`
	`242`	`+ std::uint32_t size() const`
`241`	`243`	`{`
`242`	`244`	`return local_hist.size();`
`243`	`245`	`}`
`@@ -264,7 +266,7 @@ struct HistGlobalMemory`
`264`	`266`	`}`
`265`	`267`
`266`	`268`	`template <int _Dims>`
`267`		`- void add(const sycl::nd_item<_Dims> &, int32_t bin, T value) const`
	`269`	`+ void add(const sycl::nd_item<_Dims> &, std::int32_t bin, T value) const`
`268`	`270`	`{`
`269`	`271`	`AtomicOp<T, sycl::memory_order::relaxed,`
`270`	`272`	`sycl::memory_scope::device>::add(global_hist[bin], value);`
`@@ -279,10 +281,10 @@ struct HistGlobalMemory`
`279`	`281`	`T *global_hist = nullptr;`
`280`	`282`	`};`
`281`	`283`
`282`		`-template <typename T = uint32_t>`
	`284`	`+template <typename T = std::uint32_t>`
`283`	`285`	`struct NoWeights`
`284`	`286`	`{`
`285`		`- constexpr T get(size_t) const`
	`287`	`+ constexpr T get(std::size_t) const`
`286`	`288`	`{`
`287`	`289`	`return 1;`
`288`	`290`	`}`
`@@ -296,7 +298,7 @@ struct Weights`
`296`	`298`	`data = weights;`
`297`	`299`	`}`
`298`	`300`
`299`		`- T get(size_t id) const`
	`301`	`+ T get(std::size_t id) const`
`300`	`302`	`{`
`301`	`303`	`return data[id];`
`302`	`304`	`}`
`@@ -314,9 +316,9 @@ bool check_in_bounds(const dT &val, const dT &min, const dT &max)`
`314`	`316`
`315`	`317`	`template <typename T, typename HistImpl, typename Edges, typename Weights>`
`316`	`318`	`void submit_histogram(const T *in,`
`317`		`- const size_t size,`
`318`		`- const size_t dims,`
`319`		`- const uint32_t WorkPI,`
	`319`	`+ const std::size_t size,`
	`320`	`+ const std::size_t dims,`
	`321`	`+ const std::uint32_t WorkPI,`
`320`	`322`	`const HistImpl &hist,`
`321`	`323`	`const Edges &edges,`
`322`	`324`	`const Weights &weights,`
`@@ -336,8 +338,8 @@ void validate(const usm_ndarray &sample,`
`336`	`338`	`const std::optional<const dpctl::tensor::usm_ndarray> &weights,`
`337`	`339`	`const usm_ndarray &histogram);`
`338`	`340`
`339`		`-uint32_t get_local_hist_copies_count(uint32_t loc_mem_size_in_items,`
`340`		`- uint32_t local_size,`
`341`		`- uint32_t hist_size_in_items);`
	`341`	`+std::uint32_t get_local_hist_copies_count(std::uint32_t loc_mem_size_in_items,`
	`342`	`+ std::uint32_t local_size,`
	`343`	`+ std::uint32_t hist_size_in_items);`
`342`	`344`
`343`	`345`	`} // namespace statistics::histogram`