Run rustfmt

Author: bytesnake

ndarray-linalg/src/lobpcg/eig.rs

@@ -75,7 +75,7 @@ impl<A: Float + Scalar + ScalarOperand + Lapack + PartialOrd + Default> Truncate
 
     /// Set the maximal number of iterations
     ///
-    /// The LOBPCG is an iterative approach to eigenproblems and stops when this maximum 
+    /// The LOBPCG is an iterative approach to eigenproblems and stops when this maximum
     /// number of iterations are reached.
     pub fn maxiter(mut self, maxiter: usize) -> Self {
         self.maxiter = maxiter;
@@ -184,7 +184,7 @@ impl<A: Float + Scalar + ScalarOperand + Lapack + PartialOrd + Default> IntoIter
 /// let teig = TruncatedEig::new(a, TruncatedOrder::Largest)
 ///     .precision(1e-5)
 ///     .maxiter(500);
-/// 
+///
 /// // solve eigenproblem until eigenvalues get smaller than 0.5
 /// let res = teig.into_iter()
 ///     .take_while(|x| x.0[0] > 0.5)

ndarray-linalg/src/lobpcg/mod.rs

@@ -4,4 +4,4 @@ mod svd;
 
 pub use eig::{TruncatedEig, TruncatedEigIterator};
 pub use lobpcg::{lobpcg, LobpcgResult, Order as TruncatedOrder};
-pub use svd::{TruncatedSvd, MagnitudeCorrection};
+pub use svd::{MagnitudeCorrection, TruncatedSvd};

ndarray-linalg/src/lobpcg/svd.rs

@@ -200,10 +200,10 @@ mod tests {
     use super::TruncatedSvd;
     use crate::{close_l2, generate};
 
-    use rand::SeedableRng;
-    use rand_xoshiro::Xoshiro256Plus;
     use ndarray::{arr1, arr2, Array1, Array2};
     use ndarray_rand::{rand_distr::StandardNormal, RandomExt};
+    use rand::SeedableRng;
+    use rand_xoshiro::Xoshiro256Plus;
 
     use approx::assert_abs_diff_eq;
 
@@ -239,12 +239,12 @@ mod tests {
     }
 
     /// Eigenvalue structure in high dimensions
-    /// 
+    ///
     /// This test checks that the eigenvalues are following the Marchensko-Pastur law. The data is
     /// standard uniformly distributed (i.e. E(x) = 0, E^2(x) = 1) and we have twice the amount of
     /// data when compared to features. The probability density of the eigenvalues should then follow
     /// a special densitiy function, described by the Marchenko-Pastur law.
-    /// 
+    ///
     /// See also https://en.wikipedia.org/wiki/Marchenko%E2%80%93Pastur_distribution
     #[test]
     fn test_marchenko_pastur() {
@@ -258,14 +258,14 @@ mod tests {
             .decompose(500)
             .unwrap();
 
-        let sv = res.values().mapv(|x: f64| x*x);
+        let sv = res.values().mapv(|x: f64| x * x);
 
         // we have created a random spectrum and can apply the Marchenko-Pastur law
         // with variance 1 and p/n = 0.5
-        let (a, b) = ( 
+        let (a, b) = (
             1. * (1. - 0.5f64.sqrt()).powf(2.0),
             1. * (1. + 0.5f64.sqrt()).powf(2.0),
-        );  
+        );
 
         // check that the spectrum has correct boundaries
         assert_abs_diff_eq!(b, sv[0], epsilon = 0.1);
@@ -281,14 +281,14 @@ mod tests {
 
                 if i == sv.len() {
                     break 'outer;
-                }   
-            }   
+                }
+            }
 
             let x = th + 0.05;
             let mp_law = ((b - x) * (x - a)).sqrt() / std::f64::consts::PI / x;
             let empirical = count as f64 / 500. / ((2.8 - 0.1) / 28.);
 
             assert_abs_diff_eq!(mp_law, empirical, epsilon = 0.05);
-        }   
-    } 
+        }
+    }
 }