CLUEstering 2.2.6__tar.gz → 2.2.7__tar.gz

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/CLUEstering.py

@@ -224,13 +224,14 @@ class clusterer:
 
         Points with a density lower than rhoc can't be seeds, can only be followers
         or outliers.
-    outlier : float
-        Multiplicative increment of dc_ for getting the region over which the followers of a
-        point are searched.
-
-        While dc_ determines the size of the search box in which the neighbors of a point are
-        searched when calculating its local density, when looking for followers while trying
-        to find potential seeds the size of the search box is given by dm = dc_ * outlier.
+    dm: float
+        Similar to dc, it's a spatial parameter that determines the region over
+        which the followers of a point are searched.
+
+        While dc_ determines the size of the search box in which the neighbors
+        of a point are searched when calculating its local density, when
+        looking for followers while trying to find potential seeds the size of
+        the search box is given by dm.
     ppbin : int
         Average number of points to be found in each tile.
     kernel : Algo.kernel
@@ -243,16 +244,17 @@ class clusterer:
         Execution time of the algorithm, expressed in nanoseconds.
     """
 
-    def __init__(self, dc_: float, rhoc_: float, outlier_: float, ppbin: int = 10):
+    def __init__(self, dc_: float, rhoc_: float, dm_: [float, None] = None, ppbin: int = 10):
         self.dc_ = dc_
         self.rhoc = rhoc_
-        self.outlier = outlier_
+        self.dm = dm_
+        if dm_ is None:
+            self.dm = dc_
         self.ppbin = ppbin
 
         # Initialize attributes
         ## Data containers
         self.clust_data = None
-        self.scaler = StandardScaler()
 
         ## Kernel for calculation of local density
         self.kernel = clue_kernels.FlatKernel(0.5)
@@ -262,10 +264,13 @@ class clusterer:
         self.elapsed_time = 0.
 
     def set_params(self, dc: float, rhoc: float,
-                   outlier: float, ppbin: int = 128) -> None:
+                   dm: [float, None], ppbin: int = 128) -> None:
         self.dc_ = dc
         self.rhoc = rhoc
-        self.outlier = outlier
+        if dm is not None:
+            self.dm = dm
+        else:
+            self.dm = dc
         self.ppbin = ppbin
 
     def _read_array(self, input_data: Union[list, np.ndarray]) -> None:
@@ -393,25 +398,6 @@ class clusterer:
                                           n_dim,
                                           n_points)
 
-    def _rescale(self) -> None:
-        """
-        Normalizes the input data using a standard scaler
-
-        Modified attributes
-        -------------------
-        clust_data.coords : np.ndarray
-            Array containing the coordinates and weight values of the data points
-
-        Returns
-        -------
-        None
-        """
-
-        for dim in range(self.clust_data.n_dim):
-            self.clust_data.coords.T[dim] = \
-            self.scaler.fit_transform(
-                    self.clust_data.coords.T[dim].reshape(-1, 1)).reshape(1, -1)[0]
-
     def read_data(self,
                   input_data: Union[pd.DataFrame,str,dict,list,np.ndarray]) -> None:
         """
@@ -467,9 +453,6 @@ class clusterer:
             df = self._read_dict_df(input_data)
             self._handle_dataframe(df)
 
-        # Rescale the coordinates with a standard scaler
-        self._rescale()
-
     def change_coordinates(self, **kwargs: types.FunctionType) -> None:
         """
         Change the coordinate system
@@ -494,12 +477,6 @@ class clusterer:
         for coord, func in kwargs.items():
             self.clust_data.coords[int(coord[1])] = func(self.clust_data.original_coords)
 
-            # Normalize the coordinate with a standard scaler
-            self.clust_data.coords[int(coord[1])] = \
-                self.scaler.fit_transform(
-                    self.clust_data.coords[int(coord[1])].reshape(-1, 1)
-                ).reshape(1, -1)[0]
-
     def choose_kernel(self,
                       choice: str,
                       parameters: Union[list,None] = None,
@@ -702,12 +679,12 @@ class clusterer:
             data = self._partial_dimension_dataset(dimensions)
         start = time.time_ns()
         if backend == "cpu serial":
-            cluster_id_is_seed = cpu_serial.mainRun(self.dc_, self.rhoc, self.outlier, self.ppbin,
+            cluster_id_is_seed = cpu_serial.mainRun(self.dc_, self.rhoc, self.dm, self.ppbin,
                                                     data, self.clust_data.weight, self.kernel,
                                                     self.clust_data.n_dim, block_size, device_id)
         elif backend == "cpu tbb":
             if tbb_found:
-                cluster_id_is_seed = cpu_tbb.mainRun(self.dc_, self.rhoc, self.outlier,
+                cluster_id_is_seed = cpu_tbb.mainRun(self.dc_, self.rhoc, self.dm,
                                                      self.ppbin, data, self.clust_data.weight,
                                                      self.kernel, self.clust_data.n_dim, block_size,
                                                      device_id)
@@ -716,7 +693,7 @@ class clusterer:
 
         elif backend == "gpu cuda":
             if cuda_found:
-                cluster_id_is_seed = gpu_cuda.mainRun(self.dc_, self.rhoc, self.outlier,
+                cluster_id_is_seed = gpu_cuda.mainRun(self.dc_, self.rhoc, self.dm,
                                                       self.ppbin, data, self.clust_data.weight,
                                                       self.kernel, self.clust_data.n_dim, block_size,
                                                       device_id)
@@ -725,7 +702,7 @@ class clusterer:
 
         elif backend == "gpu hip":
             if hip_found:
-                cluster_id_is_seed = gpu_hip.mainRun(self.dc_, self.rhoc, self.outlier,
+                cluster_id_is_seed = gpu_hip.mainRun(self.dc_, self.rhoc, self.dm,
                                                      self.ppbin, data, self.clust_data.weight,
                                                      self.kernel, self.clust_data.n_dim, block_size,
                                                      device_id)

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/__init__.py

@@ -1,2 +1,3 @@
 from CLUEstering.CLUEstering import clusterer
 from CLUEstering.CLUEstering import test_blobs
+from CLUEstering.CLUEstering import backends

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/alpaka/AlpakaCore/HostOnlyTask.h

@@ -34,8 +34,8 @@ namespace alpaka {
         (*pTask)();
       }
 
-      ALPAKA_FN_HOST static auto enqueue(QueueCudaRtNonBlocking& queue, HostOnlyTask task)
-          -> void {
+      ALPAKA_FN_HOST static auto enqueue(QueueCudaRtNonBlocking& queue,
+                                         HostOnlyTask task) -> void {
         auto pTask = std::make_unique<HostOnlyTask>(std::move(task));
         ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(
             cudaStreamAddCallback(alpaka::getNativeHandle(queue),
@@ -58,8 +58,8 @@ namespace alpaka {
         (*pTask)();
       }
 
-      ALPAKA_FN_HOST static auto enqueue(QueueHipRtNonBlocking& queue, HostOnlyTask task)
-          -> void {
+      ALPAKA_FN_HOST static auto enqueue(QueueHipRtNonBlocking& queue,
+                                         HostOnlyTask task) -> void {
         auto pTask = std::make_unique<HostOnlyTask>(std::move(task));
         ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(
             hipStreamAddCallback(alpaka::getNativeHandle(queue),

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/alpaka/BindingModules/binding_cpu.cc

@@ -26,7 +26,7 @@ namespace alpaka_serial_sync {
   template <typename Kernel>
   std::vector<std::vector<int>> mainRun(float dc,
                                         float rhoc,
-                                        float outlier,
+                                        float dm,
                                         int pPBin,
                                         const std::vector<std::vector<float>>& coords,
                                         const std::vector<float>& weights,
@@ -43,34 +43,34 @@ namespace alpaka_serial_sync {
     switch (Ndim) {
       [[unlikely]] case (1):
         return run<1, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[likely]] case (2):
         return run<2, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[likely]] case (3):
         return run<3, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (4):
         return run<4, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (5):
         return run<5, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (6):
         return run<6, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (7):
         return run<7, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (8):
         return run<8, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (9):
         return run<9, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (10):
         return run<10, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] default:
         std::cout << "This library only works up to 10 dimensions\n";
         return {};

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/alpaka/BindingModules/binding_cpu_tbb.cc

@@ -26,7 +26,7 @@ namespace alpaka_tbb_async {
   template <typename Kernel>
   std::vector<std::vector<int>> mainRun(float dc,
                                         float rhoc,
-                                        float outlier,
+                                        float dm,
                                         int pPBin,
                                         const std::vector<std::vector<float>>& coords,
                                         const std::vector<float>& weights,
@@ -43,34 +43,34 @@ namespace alpaka_tbb_async {
     switch (Ndim) {
       [[unlikely]] case (1):
         return run<1, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[likely]] case (2):
         return run<2, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[likely]] case (3):
         return run<3, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (4):
         return run<4, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (5):
         return run<5, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (6):
         return run<6, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (7):
         return run<7, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (8):
         return run<8, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (9):
         return run<9, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (10):
         return run<10, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] default:
         std::cout << "This library only works up to 10 dimensions\n";
         return {};

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/alpaka/BindingModules/binding_gpu_cuda.cc

@@ -27,7 +27,7 @@ namespace alpaka_cuda_async {
   template <typename Kernel>
   std::vector<std::vector<int>> mainRun(float dc,
                                         float rhoc,
-                                        float outlier,
+                                        float dm,
                                         int pPBin,
                                         const std::vector<std::vector<float>>& coords,
                                         const std::vector<float>& weights,
@@ -44,34 +44,34 @@ namespace alpaka_cuda_async {
     switch (Ndim) {
       [[unlikely]] case (1):
         return run<1, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[likely]] case (2):
         return run<2, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[likely]] case (3):
         return run<3, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (4):
         return run<4, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (5):
         return run<5, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (6):
         return run<6, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (7):
         return run<7, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (8):
         return run<8, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (9):
         return run<9, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (10):
         return run<10, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] default:
         std::cout << "This library only works up to 10 dimensions\n";
         return {};

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/alpaka/BindingModules/binding_gpu_hip.cc

@@ -25,7 +25,7 @@ namespace alpaka_rocm_async {
   template <typename Kernel>
   std::vector<std::vector<int>> mainRun(float dc,
                                         float rhoc,
-                                        float outlier,
+                                        float dm,
                                         int pPBin,
                                         const std::vector<std::vector<float>>& coords,
                                         const std::vector<float>& weights,
@@ -42,34 +42,34 @@ namespace alpaka_rocm_async {
     switch (Ndim) {
       [[unlikely]] case (1):
         return run<1, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[likely]] case (2):
         return run<2, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[likely]] case (3):
         return run<3, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (4):
         return run<4, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (5):
         return run<5, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (6):
         return run<6, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (7):
         return run<7, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (8):
         return run<8, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (9):
         return run<9, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] case (10):
         return run<10, Kernel>(
-            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+            dc, rhoc, dm, pPBin, coords, weights, kernel, queue_, block_size);
       [[unlikely]] default:
         std::cout << "This library only works up to 10 dimensions\n";
         return {};

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/alpaka/CLUE/CLUEAlgoAlpaka.h

@@ -28,12 +28,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
   class CLUEAlgoAlpaka {
   public:
     CLUEAlgoAlpaka() = delete;
-    explicit CLUEAlgoAlpaka(
-        float dc, float rhoc, float outlierDeltaFactor, int pPBin, Queue queue_)
-        : dc_{dc},
-          rhoc_{rhoc},
-          outlierDeltaFactor_{outlierDeltaFactor},
-          pointsPerTile_{pPBin} {
+    explicit CLUEAlgoAlpaka(float dc, float rhoc, float dm, int pPBin, Queue queue_)
+        : dc_{dc}, rhoc_{rhoc}, dm_{dm}, pointsPerTile_{pPBin} {
       init_device(queue_);
     }
 
@@ -51,7 +47,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
   private:
     float dc_;
     float rhoc_;
-    float outlierDeltaFactor_;
+    float dm_;
     // average number of points found in a tile
     int pointsPerTile_;
 
@@ -146,6 +142,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
         queue_,
         cms::alpakatools::make_device_view(device, (*d_tiles)->tileSize(), Ndim),
         cms::alpakatools::make_host_view(tile_size, Ndim));
+    alpaka::wait(queue_);
 
     const Idx tiles_grid_size = cms::alpakatools::divide_up_by(nTiles, block_size);
     const auto tiles_working_div =
@@ -206,7 +203,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
                                                     m_tiles,
                                                     d_points.view(),
                                                     /* m_domains.data(), */
-                                                    outlierDeltaFactor_,
+                                                    dm_,
                                                     dc_,
                                                     h_points.n));
 
@@ -216,7 +213,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
                                                     m_seeds,
                                                     m_followers,
                                                     d_points.view(),
-                                                    outlierDeltaFactor_,
+                                                    dm_,
                                                     dc_,
                                                     rhoc_,
                                                     h_points.n));

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/alpaka/CLUE/CLUEAlpakaKernels.h

@@ -231,10 +231,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
                                   TilesAlpaka<Ndim>* dev_tiles,
                                   PointsView<Ndim>* dev_points,
                                   /* const VecArray<VecArray<float, 2>, Ndim>& domains, */
-                                  float outlier_delta_factor,
+                                  float dm,
                                   float dc,
                                   uint32_t n_points) const {
-      float dm{outlier_delta_factor * dc};
       float dm_squared{dm * dm};
       cms::alpakatools::for_each_element_in_grid(acc, n_points, [&](uint32_t i) {
         float delta_i{std::numeric_limits<float>::max()};
@@ -282,7 +281,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
                                   VecArray<int32_t, max_seeds>* seeds,
                                   VecArray<int32_t, max_followers>* followers,
                                   PointsView<Ndim>* dev_points,
-                                  float outlier_delta_factor,
+                                  float dm,
                                   float d_c,
                                   float rho_c,
                                   uint32_t n_points) const {
@@ -295,7 +294,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
 
         // Determine whether the point is a seed or an outlier
         bool is_seed{(delta_i > d_c) && (rho_i >= rho_c)};
-        bool is_outlier{(delta_i > outlier_delta_factor * d_c) && (rho_i < rho_c)};
+        bool is_outlier{(delta_i > dm) && (rho_i < rho_c)};
 
         if (is_seed) {
           dev_points->is_seed[i] = 1;

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering/alpaka/CLUE/Run.h

@@ -10,14 +10,14 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
   template <uint8_t Ndim, typename Kernel>
   std::vector<std::vector<int>> run(float dc,
                                     float rhoc,
-                                    float outlier,
+                                    float dm,
                                     int pPBin,
                                     const std::vector<std::vector<float>>& coordinates,
                                     const std::vector<float>& weight,
                                     const Kernel& kernel,
                                     Queue queue_,
                                     size_t block_size) {
-    CLUEAlgoAlpaka<Acc1D, Ndim> algo(dc, rhoc, outlier, pPBin, queue_);
+    CLUEAlgoAlpaka<Acc1D, Ndim> algo(dc, rhoc, dm, pPBin, queue_);
 
     // Create the host and device points
     Points<Ndim> h_points(coordinates, weight);

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CLUEstering
-Version: 2.2.6
+Version: 2.2.7
 Summary: A library that generalizes the original 2-dimensional CLUE
 Author: Simone Balducci
 Author-email: simone.balducci00@gmail.com
@@ -13,6 +13,10 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: scikit-learn
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
 
 # CLUEstering 
 The CLUE algorithm is a clustering algorithm written at CERN (https://www.frontiersin.org/articles/10.3389/fdata.2020.591315/full).
@@ -21,9 +25,9 @@ The original algorithm was designed to work in 2 dimensions, with the data distr
 Unlike other clustering algorithms, CLUE takes the coordinates of the points and also their weight, which represents their energy, and calculates the energy density of each point.
 This energy density is used to find the seeds for each cluster, their followers and the outliers, which are dismissed as noise.
 CLUE takes 4 parameters in input: 
-* `dc_`, which is the side of the box inside of which the density of a point is calculated;
+* `dc`, which is the side of the box inside of which the density of a point is calculated;
 * `rhoc`, which is the minimum energy density that a point must have to not be considered an outlier,
-* `outlierDeltaFactor`, that multiplied by dc_ gives dm_, the side of the box inside of which the followers of a point are searched;
+* `dm`, which is the side of the box inside of which the followers of a point are searched;
 * `pointsPerBin`, which is the average number of points that are to be found inside a bin. This value allows to control the size of the bins.
 
 This library generalizes the original algorithm, making it N-dimensional, and turns it into a general purpose algorithm, usable by any user and applicaple to a wider range of applications, in particular outside particle physics.
@@ -78,8 +82,8 @@ c.list_devices('gpu hip')
 
 ## The `clusterer` class
 The `clusterer` class represents a wrapper class around the method `mainRun`, which is binded from `C++` and that is the method that runs the CLUE algorithm.  
-When an instance of this class is created, it requires at least three parameters: `dc`, `rhoc` and `outlierDeltaFactor`. There is a fourth parameter, `pPBin`, which represents the desired average number of points found in each of the bins that the clustering space is divided into. This parameter has a default value of `10`.  
-The parameters `dc`, `rhoc` and `outlierDeltaFactor` must be `floats` or a type convertible to a `float`. `ppBin`, on the other hand, is an `integer`.
+When an instance of this class is created, it requires at least three parameters: `dc`, `rhoc` and `dm`. There is a fourth parameter, `pPBin`, which represents the desired average number of points found in each of the bins that the clustering space is divided into. This parameter has a default value of `10`.  
+The parameters `dc`, `rhoc` and `dm` must be `floats` or a type convertible to a `float`. `ppBin`, on the other hand, is an `integer`.
 
 The class has several methods:
 * `read_data`, which takes the data in input and inizializes the class members. The data can be in the form of list, numpy array, dictionary, string containing the path to a csv file or pandas DataFrame;

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CLUEstering.egg-info/SOURCES.txt

@@ -38,7 +38,6 @@ CLUEstering/alpaka/CLUE/CLUEAlgoAlpaka.h
 CLUEstering/alpaka/CLUE/CLUEAlpakaKernels.h
 CLUEstering/alpaka/CLUE/ConvolutionalKernel.h
 CLUEstering/alpaka/CLUE/Run.h
-CLUEstering/alpaka/CLUE/binding.cc
 CLUEstering/alpaka/DataFormats/Points.h
 CLUEstering/alpaka/DataFormats/alpaka/AlpakaVecArray.h
 CLUEstering/alpaka/DataFormats/alpaka/PointsAlpaka.h
@@ -1404,7 +1403,6 @@ extern/pybind11/tests/test_virtual_functions.cpp
 extern/pybind11/tests/test_virtual_functions.py
 extern/pybind11/tests/valgrind-numpy-scipy.supp
 extern/pybind11/tests/valgrind-python.supp
-extern/pybind11/tests/__pycache__/conftest.cpython-312-pytest-8.1.1.pyc
 extern/pybind11/tests/extra_python_package/pytest.ini
 extern/pybind11/tests/extra_python_package/test_files.py
 extern/pybind11/tests/extra_setuptools/pytest.ini

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/CMakeLists.txt

@@ -149,8 +149,8 @@ if((NOT ${CPU_ONLY}) AND (NOT ${SERIAL_ONLY}))
     pybind11_add_module(CLUE_GPU_CUDA SHARED
                         ./CLUEstering/alpaka/BindingModules/binding_gpu_cuda.cc)
     # link boost
-    target_link_libraries(CLUE_Convolutional_Kernels PRIVATE ${Boost_LIBRARIES})
-    target_include_directories(CLUE_Convolutional_Kernels PRIVATE ${Boost_PATH})
+    target_link_libraries(CLUE_GPU_CUDA PRIVATE ${Boost_LIBRARIES})
+    target_include_directories(CLUE_GPU_CUDA PRIVATE ${Boost_PATH})
     # set the cuda architectures
     set_target_properties(CLUE_GPU_CUDA PROPERTIES CUDA_ARCHITECTURES
                                                    "50;60;61;62;70")
@@ -191,8 +191,8 @@ if((NOT ${CPU_ONLY}) AND (NOT ${SERIAL_ONLY}))
     pybind11_add_module(CLUE_GPU_HIP SHARED
                         ./CLUEstering/alpaka/BindingModules/binding_gpu_hip.cc)
     # link boost
-    target_link_libraries(CLUE_Convolutional_Kernels PRIVATE ${Boost_LIBRARIES})
-    target_include_directories(CLUE_Convolutional_Kernels PRIVATE ${Boost_PATH})
+    target_link_libraries(CLUE_GPU_HIP PRIVATE ${Boost_LIBRARIES})
+    target_include_directories(CLUE_GPU_HIP PRIVATE ${Boost_PATH})
     # alpaka build flags
     target_compile_options(
       CLUE_GPU_HIP

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CLUEstering
-Version: 2.2.6
+Version: 2.2.7
 Summary: A library that generalizes the original 2-dimensional CLUE
 Author: Simone Balducci
 Author-email: simone.balducci00@gmail.com
@@ -13,6 +13,10 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: scikit-learn
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
 
 # CLUEstering 
 The CLUE algorithm is a clustering algorithm written at CERN (https://www.frontiersin.org/articles/10.3389/fdata.2020.591315/full).
@@ -21,9 +25,9 @@ The original algorithm was designed to work in 2 dimensions, with the data distr
 Unlike other clustering algorithms, CLUE takes the coordinates of the points and also their weight, which represents their energy, and calculates the energy density of each point.
 This energy density is used to find the seeds for each cluster, their followers and the outliers, which are dismissed as noise.
 CLUE takes 4 parameters in input: 
-* `dc_`, which is the side of the box inside of which the density of a point is calculated;
+* `dc`, which is the side of the box inside of which the density of a point is calculated;
 * `rhoc`, which is the minimum energy density that a point must have to not be considered an outlier,
-* `outlierDeltaFactor`, that multiplied by dc_ gives dm_, the side of the box inside of which the followers of a point are searched;
+* `dm`, which is the side of the box inside of which the followers of a point are searched;
 * `pointsPerBin`, which is the average number of points that are to be found inside a bin. This value allows to control the size of the bins.
 
 This library generalizes the original algorithm, making it N-dimensional, and turns it into a general purpose algorithm, usable by any user and applicaple to a wider range of applications, in particular outside particle physics.
@@ -78,8 +82,8 @@ c.list_devices('gpu hip')
 
 ## The `clusterer` class
 The `clusterer` class represents a wrapper class around the method `mainRun`, which is binded from `C++` and that is the method that runs the CLUE algorithm.  
-When an instance of this class is created, it requires at least three parameters: `dc`, `rhoc` and `outlierDeltaFactor`. There is a fourth parameter, `pPBin`, which represents the desired average number of points found in each of the bins that the clustering space is divided into. This parameter has a default value of `10`.  
-The parameters `dc`, `rhoc` and `outlierDeltaFactor` must be `floats` or a type convertible to a `float`. `ppBin`, on the other hand, is an `integer`.
+When an instance of this class is created, it requires at least three parameters: `dc`, `rhoc` and `dm`. There is a fourth parameter, `pPBin`, which represents the desired average number of points found in each of the bins that the clustering space is divided into. This parameter has a default value of `10`.  
+The parameters `dc`, `rhoc` and `dm` must be `floats` or a type convertible to a `float`. `ppBin`, on the other hand, is an `integer`.
 
 The class has several methods:
 * `read_data`, which takes the data in input and inizializes the class members. The data can be in the form of list, numpy array, dictionary, string containing the path to a csv file or pandas DataFrame;

{CLUEstering-2.2.6 → CLUEstering-2.2.7}/README.md

@@ -5,9 +5,9 @@ The original algorithm was designed to work in 2 dimensions, with the data distr
 Unlike other clustering algorithms, CLUE takes the coordinates of the points and also their weight, which represents their energy, and calculates the energy density of each point.
 This energy density is used to find the seeds for each cluster, their followers and the outliers, which are dismissed as noise.
 CLUE takes 4 parameters in input: 
-* `dc_`, which is the side of the box inside of which the density of a point is calculated;
+* `dc`, which is the side of the box inside of which the density of a point is calculated;
 * `rhoc`, which is the minimum energy density that a point must have to not be considered an outlier,
-* `outlierDeltaFactor`, that multiplied by dc_ gives dm_, the side of the box inside of which the followers of a point are searched;
+* `dm`, which is the side of the box inside of which the followers of a point are searched;
 * `pointsPerBin`, which is the average number of points that are to be found inside a bin. This value allows to control the size of the bins.
 
 This library generalizes the original algorithm, making it N-dimensional, and turns it into a general purpose algorithm, usable by any user and applicaple to a wider range of applications, in particular outside particle physics.
@@ -62,8 +62,8 @@ c.list_devices('gpu hip')
 
 ## The `clusterer` class
 The `clusterer` class represents a wrapper class around the method `mainRun`, which is binded from `C++` and that is the method that runs the CLUE algorithm.  
-When an instance of this class is created, it requires at least three parameters: `dc`, `rhoc` and `outlierDeltaFactor`. There is a fourth parameter, `pPBin`, which represents the desired average number of points found in each of the bins that the clustering space is divided into. This parameter has a default value of `10`.  
-The parameters `dc`, `rhoc` and `outlierDeltaFactor` must be `floats` or a type convertible to a `float`. `ppBin`, on the other hand, is an `integer`.
+When an instance of this class is created, it requires at least three parameters: `dc`, `rhoc` and `dm`. There is a fourth parameter, `pPBin`, which represents the desired average number of points found in each of the bins that the clustering space is divided into. This parameter has a default value of `10`.  
+The parameters `dc`, `rhoc` and `dm` must be `floats` or a type convertible to a `float`. `ppBin`, on the other hand, is an `integer`.
 
 The class has several methods:
 * `read_data`, which takes the data in input and inizializes the class members. The data can be in the form of list, numpy array, dictionary, string containing the path to a csv file or pandas DataFrame;