Fix unused variables warnings and formatting

- Prefix unused subset_indices with underscore
- Add #[allow(dead_code)] for KMeansResult and serial functions
- Run cargo fmt for consistent formatting

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: raphaelsty

src/algorithm.rs

@@ -10,6 +10,7 @@ use rand_chacha::ChaCha8Rng;
 use std::time::Instant;
 
 /// Result of the k-means algorithm
+#[allow(dead_code)]
 pub struct KMeansResult {
     pub centroids: Array2<f32>,
     pub labels: Array1<i64>,
@@ -30,7 +31,9 @@ pub fn kmeans_double_chunked(
 
     // Validate inputs
     if k == 0 {
-        return Err(KMeansError::InvalidK("k must be greater than 0".to_string()));
+        return Err(KMeansError::InvalidK(
+            "k must be greater than 0".to_string(),
+        ));
     }
 
     if n_samples < k {
@@ -44,7 +47,7 @@ pub fn kmeans_double_chunked(
     let mut rng = ChaCha8Rng::seed_from_u64(config.seed);
 
     // Subsample if needed
-    let (data_subset, subset_indices) = subsample_data(data, config, &mut rng)?;
+    let (data_subset, _subset_indices) = subsample_data(data, config, &mut rng)?;
     let n_samples_used = data_subset.nrows();
 
     if config.verbose {
@@ -146,10 +149,7 @@ pub fn kmeans_double_chunked(
             }
 
             if config.verbose {
-                eprintln!(
-                    "  Reinitialized {} empty clusters",
-                    empty_clusters.len()
-                );
+                eprintln!("  Reinitialized {} empty clusters", empty_clusters.len());
             }
         }
 

src/distance.rs

@@ -24,6 +24,7 @@ pub fn compute_squared_norms(data: &ArrayView2<f32>) -> Array1<f32> {
 
 /// Compute squared L2 norms for each row of a 2D array (non-parallel version for small arrays)
 #[inline]
+#[allow(dead_code)]
 pub fn compute_squared_norms_serial(data: &ArrayView2<f32>) -> Array1<f32> {
     let n_samples = data.nrows();
     let mut norms = Array1::zeros(n_samples);
@@ -109,6 +110,7 @@ pub fn find_nearest_centroids_chunked(
 }
 
 /// Find the nearest centroid for each data point (serial version for small arrays)
+#[allow(dead_code)]
 pub fn find_nearest_centroids_serial(
     data_chunk: &ArrayView2<f32>,
     data_norms: &ArrayView1<f32>,
@@ -145,7 +147,10 @@ pub fn find_nearest_centroids_serial(
 }
 
 /// Compute centroid shift (sum of L2 norms of centroid movements)
-pub fn compute_centroid_shift(old_centroids: &ArrayView2<f32>, new_centroids: &ArrayView2<f32>) -> f64 {
+pub fn compute_centroid_shift(
+    old_centroids: &ArrayView2<f32>,
+    new_centroids: &ArrayView2<f32>,
+) -> f64 {
     let k = old_centroids.nrows();
 
     let shifts: f64 = (0..k)
@@ -199,7 +204,7 @@ mod tests {
 
         assert_eq!(labels[0], 0); // (0,0) closest to centroid 0
         assert_eq!(labels[1], 1); // (10,10) closest to centroid 1
-        // (5,5) is equidistant, but we take the first one found (0)
+                                  // (5,5) is equidistant, but we take the first one found (0)
     }
 
     #[test]

tests/integration_tests.rs

@@ -15,7 +15,11 @@ fn generate_clustered_data(
     let mut rng = ChaCha8Rng::seed_from_u64(seed);
 
     // Generate random cluster centers
-    let centers = Array2::random_using((n_clusters, n_features), Uniform::new(-10.0, 10.0), &mut rng);
+    let centers = Array2::random_using(
+        (n_clusters, n_features),
+        Uniform::new(-10.0, 10.0),
+        &mut rng,
+    );
 
     // Generate points around each center
     let samples_per_cluster = n_samples / n_clusters;
@@ -32,7 +36,8 @@ fn generate_clustered_data(
         for i in start_idx..end_idx {
             for j in 0..n_features {
                 // Add Gaussian noise around the center
-                let noise: f32 = Array2::random_using((1, 1), Uniform::new(-0.5, 0.5), &mut rng)[[0, 0]];
+                let noise: f32 =
+                    Array2::random_using((1, 1), Uniform::new(-0.5, 0.5), &mut rng)[[0, 0]];
                 data[[i, j]] = center[j] + noise;
             }
         }
@@ -43,11 +48,7 @@ fn generate_clustered_data(
 
 /// Calculate Normalized Mutual Information (NMI) between true and predicted labels
 /// This is a simplified implementation for testing purposes
-fn calculate_cluster_purity(
-    data: &ArrayView2<f32>,
-    labels: &[i64],
-    n_clusters: usize,
-) -> f32 {
+fn calculate_cluster_purity(data: &ArrayView2<f32>, labels: &[i64], n_clusters: usize) -> f32 {
     // Calculate cluster sizes and verify non-empty clusters
     let mut cluster_counts = vec![0usize; n_clusters];
     for &label in labels {
@@ -115,11 +116,18 @@ fn test_basic_train() {
 
     let result = kmeans.train(&data.view());
     assert!(result.is_ok(), "Training should succeed");
-    assert!(kmeans.centroids().is_some(), "Centroids should be set after training");
+    assert!(
+        kmeans.centroids().is_some(),
+        "Centroids should be set after training"
+    );
 
     let centroids = kmeans.centroids().unwrap();
     assert_eq!(centroids.nrows(), 10, "Should have k centroids");
-    assert_eq!(centroids.ncols(), 128, "Centroids should have correct dimensions");
+    assert_eq!(
+        centroids.ncols(),
+        128,
+        "Centroids should have correct dimensions"
+    );
 }
 
 #[test]
@@ -129,7 +137,10 @@ fn test_basic_fit() {
 
     let result = kmeans.fit(&data.view());
     assert!(result.is_ok(), "Fit should succeed");
-    assert!(kmeans.centroids().is_some(), "Centroids should be set after fit");
+    assert!(
+        kmeans.centroids().is_some(),
+        "Centroids should be set after fit"
+    );
 }
 
 #[test]
@@ -183,7 +194,11 @@ fn test_clustering_quality_synthetic() {
 
     // Check clustering quality
     let purity = calculate_cluster_purity(&data.view(), labels.as_slice().unwrap(), 5);
-    assert!(purity > 0.0, "Clustering should produce non-zero purity: {}", purity);
+    assert!(
+        purity > 0.0,
+        "Clustering should produce non-zero purity: {}",
+        purity
+    );
 }
 
 #[test]
@@ -302,7 +317,10 @@ fn test_different_seeds_produce_different_results() {
             break;
         }
     }
-    assert!(!all_equal, "Different seeds should produce different results");
+    assert!(
+        !all_equal,
+        "Different seeds should produce different results"
+    );
 }
 
 // ============================================================================
@@ -455,8 +473,8 @@ fn test_small_chunk_sizes() {
         tol: 1e-8,
         seed: 42,
         max_points_per_centroid: None,
-        chunk_size_data: 50,        // Very small
-        chunk_size_centroids: 3,    // Very small
+        chunk_size_data: 50,     // Very small
+        chunk_size_centroids: 3, // Very small
         verbose: false,
     };
 
@@ -476,8 +494,8 @@ fn test_large_chunk_sizes() {
         tol: 1e-8,
         seed: 42,
         max_points_per_centroid: None,
-        chunk_size_data: 100_000,       // Larger than data
-        chunk_size_centroids: 100_000,  // Larger than k
+        chunk_size_data: 100_000,      // Larger than data
+        chunk_size_centroids: 100_000, // Larger than k
         verbose: false,
     };
 
@@ -497,12 +515,18 @@ fn test_centroids_getter() {
     let mut kmeans = FastKMeans::new(8, 5);
 
     // Before training
-    assert!(kmeans.centroids().is_none(), "Centroids should be None before training");
+    assert!(
+        kmeans.centroids().is_none(),
+        "Centroids should be None before training"
+    );
 
     // After training
     kmeans.train(&data.view()).unwrap();
     let centroids = kmeans.centroids();
-    assert!(centroids.is_some(), "Centroids should be Some after training");
+    assert!(
+        centroids.is_some(),
+        "Centroids should be Some after training"
+    );
 
     let c = centroids.unwrap();
     assert_eq!(c.nrows(), 5);