fix-clippy (#319)

* Fix clippy

Signed-off-by: Cedric Chevalier <cedric.chevalier@cea.fr>

* Remove unused `hilbert` field for `k_means`

Signed-off-by: Cedric Chevalier <cedric.chevalier@cea.fr>

* Fix warnings

Signed-off-by: Cedric Chevalier <cedric.chevalier@cea.fr>

* Remaining clippy suggestions

Signed-off-by: Cedric Chevalier <cedric.chevalier@cea.fr>

* Update src/algorithms/k_means.rs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Applying @imrn99 suggestion

Signed-off-by: Cedric Chevalier <cedric.chevalier@cea.fr>

---------

Signed-off-by: Cedric Chevalier <cedric.chevalier@cea.fr>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: cedricchevalier19

benches/rcb_cartesian.rs

@@ -1,7 +1,7 @@
 use criterion::Criterion;
-use criterion::black_box;
 use criterion::criterion_group;
 use criterion::criterion_main;
+use std::hint::black_box;
 use std::num::NonZeroUsize;
 
 pub fn bench(c: &mut Criterion) {
@@ -37,7 +37,7 @@ pub fn bench(c: &mut Criterion) {
             })
             .build()
             .unwrap();
-        group.bench_function(&thread_count.to_string(), |b| {
+        group.bench_function(thread_count.to_string(), |b| {
             pool.install(|| {
                 b.iter(|| grid.rcb(black_box(&mut partition), black_box(&weights), 12))
             });

ffi/src/data.rs

@@ -51,7 +51,7 @@ impl Constant {
         T: 'a + Copy + Send + Sync,
     {
         let value = *(self.value as *const T);
-        coupe::rayon::iter::repeatn(value, self.len)
+        coupe::rayon::iter::repeat_n(value, self.len)
     }
 }
 

src/algorithms.rs

@@ -105,7 +105,7 @@ where
 
     fn partition(&mut self, part_ids: &mut [usize], _: ()) -> Result<Self::Metadata, Self::Error> {
         for part_id in part_ids {
-            *part_id = self.rng.gen_range(0..self.part_count);
+            *part_id = self.rng.random_range(0..self.part_count);
         }
         Ok(())
     }

src/algorithms/hilbert_curve.rs

@@ -331,7 +331,7 @@ fn encode_2d(x: u64, y: u64, order: usize) -> u64 {
         order,
     );
 
-    const LUT: [u16; 16_384] = {
+    static LUT: [u16; 16_384] = {
         let mut lut = [0; 16_384];
         let mut i: usize = 0;
         while i < 16_384 {

src/algorithms/k_means.rs

@@ -46,9 +46,8 @@ fn imbalance(weights: &[f64]) -> f64 {
 ///   - `delta_threshold`: the distance threshold for the cluster movements under which the algorithm stops.
 ///   - `max_iter`: the maximum number of times each cluster will move before stopping the algorithm
 ///   - `max_balance_iter`: the maximum number of iterations of the load balancing loop. It will limit how much each cluster
-///      influence can grow between each cluster movement.
+///     influence can grow between each cluster movement.
 ///   - `erode`: sets whether or not cluster influence is modified according to errosion's rules between each cluster movement
-///   - `hilbert`: sets wheter or not an Hilbert curve is used to create the initial partition. If false, a Z curve is used instead.
 ///   - `mbr_early_break`: sets whether or not bounding box optimization is enabled.
 #[derive(Debug, Clone, Copy)]
 pub struct BalancedKmeansSettings {
@@ -58,7 +57,6 @@ pub struct BalancedKmeansSettings {
     pub max_iter: usize,
     pub max_balance_iter: usize,
     pub erode: bool,
-    pub hilbert: bool,
     pub mbr_early_break: bool,
 }
 
@@ -71,7 +69,6 @@ impl Default for BalancedKmeansSettings {
             max_iter: 50,
             max_balance_iter: 1, // for now, `max_balance_iter > 1` yields poor convergence time
             erode: false,        // for now, `erode` yields` enabled yields wrong results
-            hilbert: true,
             mbr_early_break: false, // for now, `mbr_early_break` enabled yields wrong results
         }
     }
@@ -129,7 +126,7 @@ fn balanced_k_means_with_initial_partition<const D: usize>(
     // Generate initial lower and upper bounds. These two variables represent bounds on
     // the effective distance between an point and the cluster it is assigned to.
     let mut lbs: Vec<_> = points.par_iter().map(|_| 0.).collect();
-    let mut ubs: Vec<_> = points.par_iter().map(|_| std::f64::MAX).collect(); // we use f64::MAX to represent infinity
+    let mut ubs: Vec<_> = points.par_iter().map(|_| f64::MAX).collect(); // we use f64::MAX to represent infinity
 
     balanced_k_means_iter(
         Inputs { points, weights },
@@ -480,8 +477,8 @@ fn best_values<const D: usize>(
     f64,               // new ub
     Option<ClusterId>, // new cluster assignment for the current point (None if the same assignment is kept)
 ) {
-    let mut best_value = std::f64::MAX;
-    let mut snd_best_value = std::f64::MAX;
+    let mut best_value = f64::MAX;
+    let mut snd_best_value = f64::MAX;
     let mut assignment = None;
 
     for (((center, id), distance_to_mbr), influence) in centers
@@ -621,7 +618,6 @@ where
             max_iter: self.max_iter,
             max_balance_iter: self.max_balance_iter,
             erode: self.erode,
-            hilbert: self.hilbert,
             mbr_early_break: self.mbr_early_break,
         };
         balanced_k_means_with_initial_partition(points, weights, settings, part_ids);

src/algorithms/kernighan_lin.rs

@@ -59,10 +59,8 @@ fn kernighan_lin_2_impl<T>(
     let mut new_cut_size = cut_size;
 
     for iter in 0.. {
-        if let Some(max_passes) = max_passes {
-            if iter >= max_passes {
-                break;
-            }
+        if max_passes.is_some_and(|max| iter >= max) {
+            break;
         }
 
         cut_size = new_cut_size;
@@ -78,8 +76,7 @@ fn kernighan_lin_2_impl<T>(
         let mut locks = vec![false; initial_partition.len()];
 
         // pass loop
-        for _ in 0..(initial_partition.len() / 2).min(max_flips_per_pass.unwrap_or(std::usize::MAX))
-        {
+        for _ in 0..(initial_partition.len() / 2).min(max_flips_per_pass.unwrap_or(usize::MAX)) {
             // construct gains
             for (idx, gain) in gains.iter_mut().enumerate() {
                 for (j, w) in adjacency.neighbors(idx) {

src/algorithms/multi_jagged.rs

@@ -25,7 +25,7 @@ fn is_prime(n: u32) -> bool {
     let p: u32 = (f64::from(n)).sqrt() as u32;
 
     for i in 2..=p {
-        if n % i == 0 {
+        if n.is_multiple_of(i) {
             return false;
         }
     }
@@ -43,7 +43,7 @@ fn prime_factors(mut n: u32) -> Vec<u32> {
     let mut primes = (2..).filter(|n| is_prime(*n));
     let mut current = primes.next().unwrap();
     while n > 1 {
-        while n % current == 0 {
+        while n.is_multiple_of(current) {
             ret.push(current);
             n /= current;
         }
@@ -239,7 +239,7 @@ pub(crate) fn compute_split_positions(
     let mut scan = permutation
         .par_iter()
         .enumerate()
-        .fold_with((std::usize::MAX, 0.), |(low, acc), (idx, val)| {
+        .fold_with((usize::MAX, 0.), |(low, acc), (idx, val)| {
             (usize::min(idx, low), acc + weights[*val])
         })
         .collect::<Vec<_>>()

src/algorithms/recursive_bisection.rs

@@ -35,7 +35,7 @@ unsafe fn array_assume_init<T, const N: usize>(array: [MaybeUninit<T>; N]) -> [T
     // * `MaybeUninit` does not drop, so there are no double-frees
     // And thus the conversion is safe
     //std::intrinsics::assert_inhabited::<[T; N]>();
-    (&array as *const _ as *const [T; N]).read()
+    unsafe { (&array as *const _ as *const [T; N]).read() }
 }
 
 fn array_init<F, T, const N: usize>(mut f: F) -> [T; N]

src/algorithms/z_curve.rs

@@ -36,7 +36,7 @@ use std::sync::atomic::{self, AtomicPtr};
 // in 2D, an order greater than 64 will overflow u128.
 // maybe it would be more appropriate to use a BigInt
 type HashType = u128;
-const HASH_TYPE_MAX: HashType = std::u128::MAX;
+const HASH_TYPE_MAX: HashType = u128::MAX;
 
 fn z_curve_partition<const D: usize>(
     partition: &mut [usize],

src/cartesian/mod.rs

@@ -78,7 +78,7 @@ impl<const D: usize> Grid<D> {
             _ => {
                 for (s, p) in self.size.into_iter().zip(&mut pos) {
                     *p = i % s;
-                    i = i / s;
+                    i /= s;
                 }
             }
         }
@@ -244,7 +244,7 @@ where
 
             let mut neighbor = self.vertex;
             let axis = i / 2;
-            let new_coord = if (i % 2) == 0 {
+            let new_coord = if i.is_multiple_of(2) {
                 usize::checked_sub(neighbor[axis], 1)
             } else {
                 Some(neighbor[axis] + 1)