STYLE: Apply cargo fmt to files added after PR #96 (JOSS ariostas)

Author: Axect

examples/clippy_verify.rs

@@ -61,10 +61,7 @@ fn check_integral() {
     let f = |x: f64| x.cos() + 0.25 * x * x;
     for &n in &[15_usize, 21, 31, 41, 51, 61] {
         let r: f64 = kronrod_quadrature(f, n, (0.0, 1.7));
-        print_kv(
-            &format!("kronrod_quadrature n={}", n),
-            format!("{r:.17e}"),
-        );
+        print_kv(&format!("kronrod_quadrature n={}", n), format!("{r:.17e}"));
         // also exercise with a different smooth integrand to widen coverage
         let r2: f64 = kronrod_quadrature(|x: f64| (-x * x).exp(), n, (-2.5, 1.5));
         print_kv(
@@ -78,17 +75,17 @@ fn check_chebyshev_lagrange() {
     // chebyshev_nodes carries one of the affected loops directly.
     for &n in &[4_usize, 8, 16, 32] {
         let nodes = chebyshev_nodes(n, -2.0, 3.5);
-        print_kv(
-            &format!("chebyshev_nodes(n={n}) hash"),
-            hash_f64s(&nodes),
-        );
+        print_kv(&format!("chebyshev_nodes(n={n}) hash"), hash_f64s(&nodes));
     }
     // lagrange_polynomial uses divided-difference loops touched by clippy.
     let xs = vec![0.0_f64, 0.5, 1.1, 1.7, 2.4, 3.0];
     let ys: Vec<f64> = xs.iter().map(|x| x.sin() + 0.5 * x).collect();
     let p = lagrange_polynomial(xs.clone(), ys.clone());
     for &q in &[0.1_f64, 0.7, 1.3, 1.9, 2.5] {
-        print_kv(&format!("lagrange.eval({q})"), format!("{:.17e}", p.eval(q)));
+        print_kv(
+            &format!("lagrange.eval({q})"),
+            format!("{:.17e}", p.eval(q)),
+        );
     }
     print_kv(
         "lagrange.derivative coeffs",
@@ -212,10 +209,7 @@ fn check_polynomial() {
     print_kv("poly.derivative", hash_f64s(&p.derivative().coef));
     print_kv("poly.integral", hash_f64s(&p.integral().coef));
     for &x in &[-1.0_f64, -0.25, 0.0, 0.5, 1.5, 2.7] {
-        print_kv(
-            &format!("poly.eval({x})"),
-            format!("{:.17e}", p.eval(x)),
-        );
+        print_kv(&format!("poly.eval({x})"), format!("{:.17e}", p.eval(x)));
     }
 }
 

src/numerical/eigen.rs

@@ -101,7 +101,7 @@ impl JacobiTemp {
             }
             if sm == 0f64 {
                 eigsrt(d, v);
-                return ;
+                return;
             }
             let tresh = if i < 4 {
                 0.2 * sm / (n.pow(2) as f64)

src/numerical/optimize.rs

@@ -308,8 +308,6 @@ where
                         break;
                     }
 
-                    
-
                     let b_lu = (jtj.clone() + lambda * jtj.to_diag()).lu();
                     if b_lu.det() == 0f64 {
                         break;

src/structure/matrix.rs

@@ -3569,7 +3569,7 @@ impl LinearAlgebra<Matrix> for Matrix {
                     Some(obj) => obj,
                 };
                 let x = &wazd.w.t() * &b.to_vec();
-                
+
                 &wazd.z * &x
             }
         }
@@ -3616,7 +3616,7 @@ impl LinearAlgebra<Matrix> for Matrix {
                     Some(obj) => obj,
                 };
                 let x = &wazd.w.t() * m;
-                
+
                 &wazd.z * &x
             }
         }

src/structure/vector.rs

@@ -981,16 +981,13 @@ impl ParallelVectorProduct for Vec<f64> {
                 v[0] = self[0] * other[1] - self[1] * other[0];
                 v
             }
-            3 => {
-                
-                (0..3)
-                    .into_par_iter()
-                    .map(|index| {
-                        self[(index + 1) % 3] * other[(index + 2) % 3]
-                            - self[(index + 2) % 3] * other[(index + 1) % 3]
-                    })
-                    .collect::<Vec<f64>>()
-            }
+            3 => (0..3)
+                .into_par_iter()
+                .map(|index| {
+                    self[(index + 1) % 3] * other[(index + 2) % 3]
+                        - self[(index + 2) % 3] * other[(index + 1) % 3]
+                })
+                .collect::<Vec<f64>>(),
             _ => {
                 panic!("Cross product can be defined only in 2 or 3 dimension")
             }

tests/blas_test.rs

@@ -1,8 +1,8 @@
 extern crate peroxide;
-#[allow(unused_imports)]
-use peroxide::fuga::*;
 #[cfg(feature = "O3")]
 use peroxide::c;
+#[allow(unused_imports)]
+use peroxide::fuga::*;
 
 #[test]
 #[cfg(feature = "O3")]

tests/integral.rs

@@ -8,7 +8,9 @@ fn assert_close(actual: f64, expected: f64) {
     assert!(
         (actual - expected).abs() < TOL,
         "actual = {:.17e}, expected = {:.17e}, diff = {:.3e}",
-        actual, expected, (actual - expected).abs()
+        actual,
+        expected,
+        (actual - expected).abs()
     );
 }
 

tests/optimize.rs

@@ -6,13 +6,23 @@ const P_TRUE: [f64; 3] = [1.0, 2.0, 3.0];
 // y = p[0] * t^2 + p[1] * t + p[2]
 #[allow(clippy::ptr_arg)]
 fn quadratic(x: &Vec<f64>, p: Vec<AD>) -> Option<Vec<AD>> {
-    Some(x.iter().map(|t| AD1(*t, 0f64)).map(|t| p[0] * t.powi(2) + p[1] * t + p[2]).collect())
+    Some(
+        x.iter()
+            .map(|t| AD1(*t, 0f64))
+            .map(|t| p[0] * t.powi(2) + p[1] * t + p[2])
+            .collect(),
+    )
 }
 
 // y = p[0] * exp(p[1] * t)
 #[allow(clippy::ptr_arg)]
 fn exp_decay(x: &Vec<f64>, p: Vec<AD>) -> Option<Vec<AD>> {
-    Some(x.iter().map(|t| AD1(*t, 0f64)).map(|t| p[0] * (p[1] * t).exp()).collect())
+    Some(
+        x.iter()
+            .map(|t| AD1(*t, 0f64))
+            .map(|t| p[0] * (p[1] * t).exp())
+            .collect(),
+    )
 }
 
 #[test]
@@ -23,7 +33,8 @@ fn test_LM_quadratic_recovers_parameters() {
     let data = hstack!(x, y);
 
     let mut opt = Optimizer::new(data, quadratic);
-    let p = opt.set_init_param(vec![1f64, 1f64, 1f64])
+    let p = opt
+        .set_init_param(vec![1f64, 1f64, 1f64])
         .set_max_iter(50)
         .set_method(LevenbergMarquardt)
         .set_lambda_init(1e-3)
@@ -44,7 +55,8 @@ fn test_GD_quadratic_makes_progress() {
     let p_init = [1f64, 1f64, 1f64];
 
     let mut opt = Optimizer::new(data, quadratic);
-    let p = opt.set_init_param(p_init.to_vec())
+    let p = opt
+        .set_init_param(p_init.to_vec())
         .set_max_iter(1000)
         .set_method(GradientDescent)
         .set_lr(1e-6)
@@ -68,7 +80,8 @@ fn test_LM_exponential_recovers_parameters() {
     let data = hstack!(x, y);
 
     let mut opt = Optimizer::new(data, exp_decay);
-    let p = opt.set_init_param(vec![1.0_f64, -0.1_f64])
+    let p = opt
+        .set_init_param(vec![1.0_f64, -0.1_f64])
         .set_max_iter(100)
         .set_method(LevenbergMarquardt)
         .set_lambda_init(1e-3)