fix: Replace .unwrap() with .expect() in examples and benches (Refs #41)

Replaced all .unwrap() calls with descriptive .expect() messages:
- examples/*.rs: "Example data should be valid"
- benches/*.rs: "Benchmark data should be valid"

This satisfies GH-41 requirements and unblocks Dependabot PRs #46-50
that were failing CI due to clippy::disallowed_methods warnings.

Changes:
- 26 example files updated
- 3 benchmark files updated
- Auto-fixed format string warnings
- All 742 tests still passing
- Examples and benches now clippy-clean

Note: Tests still use .unwrap() which is acceptable for test code.

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

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

Author: noahgift

benches/dataframe.rs

@@ -21,7 +21,7 @@ fn bench_dataframe_to_matrix(c: &mut Criterion) {
                 Vector::from_vec((0..n_rows).map(|i| i as f32 * 3.0).collect()),
             ),
         ];
-        let df = DataFrame::new(columns).unwrap();
+        let df = DataFrame::new(columns).expect("Benchmark data should be valid");
 
         group.bench_with_input(BenchmarkId::from_parameter(n_rows), &n_rows, |b, _| {
             b.iter(|| black_box(&df).to_matrix());
@@ -57,10 +57,14 @@ fn bench_dataframe_select(c: &mut Criterion) {
                 Vector::from_vec((0..n_rows).map(|i| i as f32 * 5.0).collect()),
             ),
         ];
-        let df = DataFrame::new(columns).unwrap();
+        let df = DataFrame::new(columns).expect("Benchmark data should be valid");
 
         group.bench_with_input(BenchmarkId::from_parameter(n_rows), &n_rows, |b, _| {
-            b.iter(|| black_box(&df).select(&["a", "c", "e"]).unwrap());
+            b.iter(|| {
+                black_box(&df)
+                    .select(&["a", "c", "e"])
+                    .expect("Benchmark data should be valid")
+            });
         });
     }
 

benches/kmeans.rs

@@ -19,15 +19,17 @@ fn bench_kmeans_fit(c: &mut Criterion) {
             }
         }
 
-        let matrix = Matrix::from_vec(n_samples, 2, data).unwrap();
+        let matrix = Matrix::from_vec(n_samples, 2, data).expect("Benchmark data should be valid");
 
         group.bench_with_input(
             BenchmarkId::from_parameter(n_samples),
             &n_samples,
             |b, _| {
                 b.iter(|| {
                     let mut kmeans = KMeans::new(2).with_random_state(42).with_max_iter(100);
-                    kmeans.fit(black_box(&matrix)).unwrap();
+                    kmeans
+                        .fit(black_box(&matrix))
+                        .expect("Benchmark data should be valid");
                 });
             },
         );
@@ -51,9 +53,9 @@ fn bench_kmeans_predict(c: &mut Criterion) {
             }
         }
 
-        let matrix = Matrix::from_vec(n_samples, 2, data).unwrap();
+        let matrix = Matrix::from_vec(n_samples, 2, data).expect("Benchmark data should be valid");
         let mut kmeans = KMeans::new(2).with_random_state(42);
-        kmeans.fit(&matrix).unwrap();
+        kmeans.fit(&matrix).expect("Benchmark data should be valid");
 
         group.bench_with_input(
             BenchmarkId::from_parameter(n_samples),

benches/linear_regression.rs

@@ -11,13 +11,15 @@ fn bench_linear_regression_fit(c: &mut Criterion) {
         let x_data: Vec<f32> = (0..*size).map(|i| i as f32).collect();
         let y_data: Vec<f32> = x_data.iter().map(|&x| 2.0 * x + 1.0).collect();
 
-        let x = Matrix::from_vec(*size, 1, x_data).unwrap();
+        let x = Matrix::from_vec(*size, 1, x_data).expect("Benchmark data should be valid");
         let y = Vector::from_vec(y_data);
 
         group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, _| {
             b.iter(|| {
                 let mut model = LinearRegression::new();
-                model.fit(black_box(&x), black_box(&y)).unwrap();
+                model
+                    .fit(black_box(&x), black_box(&y))
+                    .expect("Benchmark data should be valid");
             });
         });
     }
@@ -32,11 +34,11 @@ fn bench_linear_regression_predict(c: &mut Criterion) {
         let x_data: Vec<f32> = (0..*size).map(|i| i as f32).collect();
         let y_data: Vec<f32> = x_data.iter().map(|&x| 2.0 * x + 1.0).collect();
 
-        let x = Matrix::from_vec(*size, 1, x_data).unwrap();
+        let x = Matrix::from_vec(*size, 1, x_data).expect("Benchmark data should be valid");
         let y = Vector::from_vec(y_data);
 
         let mut model = LinearRegression::new();
-        model.fit(&x, &y).unwrap();
+        model.fit(&x, &y).expect("Benchmark data should be valid");
 
         group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, _| {
             b.iter(|| model.predict(black_box(&x)));

examples/bayesian_blocks_histogram.rs

@@ -46,8 +46,12 @@ fn uniform_distribution_example() {
     let v = Vector::from_slice(&data);
     let stats = DescriptiveStats::new(&v);
 
-    let hist_bayesian = stats.histogram_method(BinMethod::Bayesian).unwrap();
-    let hist_sturges = stats.histogram_method(BinMethod::Sturges).unwrap();
+    let hist_bayesian = stats
+        .histogram_method(BinMethod::Bayesian)
+        .expect("Example data should be valid");
+    let hist_sturges = stats
+        .histogram_method(BinMethod::Sturges)
+        .expect("Example data should be valid");
 
     println!("  Data: 1, 2, 3, ..., 20 (uniform)");
     println!("\n  Bayesian Blocks:");
@@ -77,7 +81,9 @@ fn two_clusters_example() {
     let v = Vector::from_slice(&data);
     let stats = DescriptiveStats::new(&v);
 
-    let hist = stats.histogram_method(BinMethod::Bayesian).unwrap();
+    let hist = stats
+        .histogram_method(BinMethod::Bayesian)
+        .expect("Example data should be valid");
 
     println!("  Data: Two clusters (1.0-2.0 and 9.0-10.0)");
     println!("  Gap: 2.0 to 9.0 (no data)");
@@ -121,7 +127,9 @@ fn multiple_density_example() {
     let v = Vector::from_slice(&data);
     let stats = DescriptiveStats::new(&v);
 
-    let hist = stats.histogram_method(BinMethod::Bayesian).unwrap();
+    let hist = stats
+        .histogram_method(BinMethod::Bayesian)
+        .expect("Example data should be valid");
 
     println!("  Data: Dense (1.0-2.0), Sparse (5, 7, 9), Dense (15.0-16.0)");
     println!("\n  Bayesian Blocks Result:");
@@ -177,7 +185,9 @@ fn comparison_example() {
     println!("  {}", "-".repeat(52));
 
     for (method, name) in methods {
-        let hist = stats.histogram_method(method).unwrap();
+        let hist = stats
+            .histogram_method(method)
+            .expect("Example data should be valid");
         let n_bins = hist.counts.len();
 
         // Check if method detected the gap (should have low counts in middle bins)

examples/boston_housing.rs

@@ -20,7 +20,7 @@ fn main() {
             1600.0, 3.0, 2.0, 20.0, 3000.0, 5.0, 4.0, 1.0, 1400.0, 3.0, 1.5, 25.0,
         ],
     )
-    .unwrap();
+    .expect("Example data should be valid");
 
     // Prices (simulated based on features)
     let y = Vector::from_slice(&[
@@ -53,7 +53,7 @@ fn main() {
         let actual = y.as_slice()[i];
         let predicted = predictions.as_slice()[i];
         let error = actual - predicted;
-        println!("{:>10.1} {:>10.1} {:>10.1}", actual, predicted, error);
+        println!("{actual:>10.1} {predicted:>10.1} {error:>10.1}");
     }
 
     // Calculate metrics
@@ -62,12 +62,13 @@ fn main() {
     let mae_val = mae(&predictions, &y);
 
     println!("\nModel Performance:");
-    println!("  R² Score: {:.4}", r2);
-    println!("  MSE:      {:.4}", mse_val);
-    println!("  MAE:      {:.4}", mae_val);
+    println!("  R² Score: {r2:.4}");
+    println!("  MSE:      {mse_val:.4}");
+    println!("  MAE:      {mae_val:.4}");
 
     // Predict on new house
-    let new_house = Matrix::from_vec(1, 4, vec![1900.0, 4.0, 2.0, 12.0]).unwrap();
+    let new_house =
+        Matrix::from_vec(1, 4, vec![1900.0, 4.0, 2.0, 12.0]).expect("Example data should be valid");
     let predicted_price = model.predict(&new_house);
     println!("\nNew House Prediction:");
     println!("  Features: 1900 sqft, 4 bed, 2 bath, 12 years old");

examples/community_detection.rs

@@ -38,7 +38,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     for (i, community) in communities.iter().enumerate() {
         println!("  Community {}: {:?}", i + 1, community);
     }
-    println!("Modularity: {:.3}\n", modularity);
+    println!("Modularity: {modularity:.3}\n");
 
     // Example 2: Social Network (Karate Club Style)
     println!("\nExample 2: Social Network Clustering");
@@ -64,7 +64,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     for (i, community) in communities2.iter().enumerate() {
         println!("  Community {}: {:?}", i + 1, community);
     }
-    println!("Modularity: {:.3}", modularity2);
+    println!("Modularity: {modularity2:.3}");
     println!(
         "Bridge node (3) connects communities: {}",
         if communities2.len() >= 2 {
@@ -97,7 +97,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     for (i, community) in communities3.iter().enumerate() {
         println!("  Community {}: {:?}", i + 1, community);
     }
-    println!("Modularity: {:.3}", modularity3);
+    println!("Modularity: {modularity3:.3}");
     println!("Disconnected components are correctly separated\n");
 
     // Example 4: Modularity Comparison
@@ -113,15 +113,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let bad_mod = g3.modularity(&bad_partition);
 
     println!("Good partition (by components):");
-    println!("  {:?}", good_partition);
-    println!("  Modularity: {:.3}", good_mod);
+    println!("  {good_partition:?}");
+    println!("  Modularity: {good_mod:.3}");
     println!("\nBad partition (all separate):");
-    println!("  {:?}", bad_partition);
-    println!("  Modularity: {:.3}", bad_mod);
-    println!(
-        "\nLouvain found modularity: {:.3} (should match good partition)",
-        modularity3
-    );
+    println!("  {bad_partition:?}");
+    println!("  Modularity: {bad_mod:.3}");
+    println!("\nLouvain found modularity: {modularity3:.3} (should match good partition)");
 
     // Example 5: Complete Graph (Single Community)
     println!("\n\nExample 5: Complete Graph");
@@ -137,7 +134,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         communities4.len()
     );
     println!("Community: {:?}", communities4[0]);
-    println!("Modularity: {:.3}", modularity4);
+    println!("Modularity: {modularity4:.3}");
     println!("Complete graphs have Q ≈ 0 (no community structure)\n");
 
     println!("=== Analysis Complete ===");

examples/cross_validation.rs

@@ -40,7 +40,7 @@ fn train_test_split_example() {
     let x_data: Vec<f32> = (0..100).map(|i| i as f32).collect();
     let y_data: Vec<f32> = x_data.iter().map(|&x| 3.0 * x + 2.0).collect();
 
-    let x = Matrix::from_vec(100, 1, x_data).unwrap();
+    let x = Matrix::from_vec(100, 1, x_data).expect("Example data should be valid");
     let y = Vector::from_vec(y_data);
 
     // Split 80/20
@@ -66,11 +66,11 @@ fn train_test_split_example() {
     let train_score = model.score(&x_train, &y_train);
     let test_score = model.score(&x_test, &y_test);
 
-    println!("\n  Training R²: {:.4}", train_score);
-    println!("  Test R²:     {:.4}", test_score);
+    println!("\n  Training R²: {train_score:.4}");
+    println!("  Test R²:     {test_score:.4}");
 
     let generalization_gap = (train_score - test_score).abs();
-    println!("  Generalization gap: {:.4}", generalization_gap);
+    println!("  Generalization gap: {generalization_gap:.4}");
 
     if generalization_gap < 0.05 {
         println!("  ✓ Model generalizes well!");
@@ -84,7 +84,7 @@ fn kfold_example() {
     let x_data: Vec<f32> = (0..50).map(|i| i as f32).collect();
     let y_data: Vec<f32> = x_data.iter().map(|&x| 2.0 * x + 1.0).collect();
 
-    let x = Matrix::from_vec(50, 1, x_data).unwrap();
+    let x = Matrix::from_vec(50, 1, x_data).expect("Example data should be valid");
     let y = Vector::from_vec(y_data);
 
     // 5-Fold cross-validation
@@ -132,16 +132,16 @@ fn kfold_example() {
 
     println!("\n  Cross-Validation Results:");
     println!("  -------------------------");
-    println!("  Mean R²: {:.4} ± {:.4}", mean_score, std_dev);
+    println!("  Mean R²: {mean_score:.4} ± {std_dev:.4}");
     println!(
         "  Min R²:  {:.4}",
-        fold_scores.iter().cloned().fold(f32::INFINITY, f32::min)
+        fold_scores.iter().copied().fold(f32::INFINITY, f32::min)
     );
     println!(
         "  Max R²:  {:.4}",
         fold_scores
             .iter()
-            .cloned()
+            .copied()
             .fold(f32::NEG_INFINITY, f32::max)
     );
 
@@ -155,7 +155,7 @@ fn cross_validate_example() {
     let x_data: Vec<f32> = (0..100).map(|i| i as f32).collect();
     let y_data: Vec<f32> = x_data.iter().map(|&x| 4.0 * x - 3.0).collect();
 
-    let x = Matrix::from_vec(100, 1, x_data).unwrap();
+    let x = Matrix::from_vec(100, 1, x_data).expect("Example data should be valid");
     let y = Vector::from_vec(y_data);
 
     // Create model and cross-validation splitter