Format in default settings

Author: termoshtt

examples/truncated_svd.rs

@@ -8,7 +8,9 @@ fn main() {
     let a = arr2(&[[3., 2., 2.], [2., 3., -2.]]);
 
     // calculate the truncated singular value decomposition for 2 singular values
-    let result = TruncatedSvd::new(a, TruncatedOrder::Largest).decompose(2).unwrap();
+    let result = TruncatedSvd::new(a, TruncatedOrder::Largest)
+        .decompose(2)
+        .unwrap();
 
     // acquire singular values, left-singular vectors and right-singular vectors
     let (u, sigma, v_t) = result.values_vectors();

src/cholesky.rs

@@ -166,7 +166,10 @@ where
     A: Scalar + Lapack,
     S: Data<Elem = A>,
 {
-    fn solvec_inplace<'a, Sb>(&self, b: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solvec_inplace<'a, Sb>(
+        &self,
+        b: &'a mut ArrayBase<Sb, Ix1>,
+    ) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {
@@ -327,7 +330,10 @@ pub trait SolveC<A: Scalar> {
     /// Solves a system of linear equations `A * x = b` with Hermitian (or real
     /// symmetric) positive definite matrix `A`, where `A` is `self`, `b` is
     /// the argument, and `x` is the successful result.
-    fn solvec_into<S: DataMut<Elem = A>>(&self, mut b: ArrayBase<S, Ix1>) -> Result<ArrayBase<S, Ix1>> {
+    fn solvec_into<S: DataMut<Elem = A>>(
+        &self,
+        mut b: ArrayBase<S, Ix1>,
+    ) -> Result<ArrayBase<S, Ix1>> {
         self.solvec_inplace(&mut b)?;
         Ok(b)
     }
@@ -346,7 +352,10 @@ where
     A: Scalar + Lapack,
     S: Data<Elem = A>,
 {
-    fn solvec_inplace<'a, Sb>(&self, b: &'a mut ArrayBase<Sb, Ix1>) -> Result<&'a mut ArrayBase<Sb, Ix1>>
+    fn solvec_inplace<'a, Sb>(
+        &self,
+        b: &'a mut ArrayBase<Sb, Ix1>,
+    ) -> Result<&'a mut ArrayBase<Sb, Ix1>>
     where
         Sb: DataMut<Elem = A>,
     {

src/convert.rs

@@ -93,7 +93,11 @@ where
     } else {
         ArrayBase::from_shape_vec(a.dim().f(), a.into_raw_vec()).unwrap()
     };
-    assert_eq!(new.strides(), strides.as_slice(), "Custom stride is not supported");
+    assert_eq!(
+        new.strides(),
+        strides.as_slice(),
+        "Custom stride is not supported"
+    );
     new
 }
 

src/eig.rs

@@ -29,7 +29,9 @@ where
         let (n, _) = layout.size();
         Ok((
             ArrayBase::from(s),
-            ArrayBase::from(t).into_shape((n as usize, n as usize)).unwrap(),
+            ArrayBase::from(t)
+                .into_shape((n as usize, n as usize))
+                .unwrap(),
         ))
     }
 }

src/error.rs

@@ -24,9 +24,15 @@ pub enum LinalgError {
 impl fmt::Display for LinalgError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            LinalgError::NotSquare { rows, cols } => write!(f, "Not square: rows({}) != cols({})", rows, cols),
-            LinalgError::Lapack { return_code } => write!(f, "LAPACK: return_code = {}", return_code),
-            LinalgError::InvalidStride { s0, s1 } => write!(f, "invalid stride: s0={}, s1={}", s0, s1),
+            LinalgError::NotSquare { rows, cols } => {
+                write!(f, "Not square: rows({}) != cols({})", rows, cols)
+            }
+            LinalgError::Lapack { return_code } => {
+                write!(f, "LAPACK: return_code = {}", return_code)
+            }
+            LinalgError::InvalidStride { s0, s1 } => {
+                write!(f, "invalid stride: s0={}, s1={}", s0, s1)
+            }
             LinalgError::MemoryNotCont => write!(f, "Memory is not contiguous"),
             LinalgError::Shape(err) => write!(f, "Shape Error: {}", err),
         }

src/inner.rs

@@ -24,7 +24,9 @@ where
         assert_eq!(self.len(), rhs.len());
         Zip::from(self)
             .and(rhs)
-            .fold_while(A::zero(), |acc, s, r| FoldWhile::Continue(acc + s.conj() * *r))
+            .fold_while(A::zero(), |acc, s, r| {
+                FoldWhile::Continue(acc + s.conj() * *r)
+            })
             .into_inner()
     }
 }

src/krylov/arnoldi.rs

@@ -97,7 +97,11 @@ where
 }
 
 /// Utility to execute Arnoldi iteration with Householder reflection
-pub fn arnoldi_householder<A, S>(a: impl LinearOperator<Elem = A>, v: ArrayBase<S, Ix1>, tol: A::Real) -> (Q<A>, H<A>)
+pub fn arnoldi_householder<A, S>(
+    a: impl LinearOperator<Elem = A>,
+    v: ArrayBase<S, Ix1>,
+    tol: A::Real,
+) -> (Q<A>, H<A>)
 where
     A: Scalar + Lapack,
     S: DataMut<Elem = A>,
@@ -107,7 +111,11 @@ where
 }
 
 /// Utility to execute Arnoldi iteration with modified Gram-Schmit orthogonalizer
-pub fn arnoldi_mgs<A, S>(a: impl LinearOperator<Elem = A>, v: ArrayBase<S, Ix1>, tol: A::Real) -> (Q<A>, H<A>)
+pub fn arnoldi_mgs<A, S>(
+    a: impl LinearOperator<Elem = A>,
+    v: ArrayBase<S, Ix1>,
+    tol: A::Real,
+) -> (Q<A>, H<A>)
 where
     A: Scalar + Lapack,
     S: DataMut<Elem = A>,

src/krylov/householder.rs

@@ -71,7 +71,11 @@ impl<A: Scalar + Lapack> Householder<A> {
         S: DataMut<Elem = A>,
     {
         assert!(k < self.v.len());
-        assert_eq!(a.len(), self.dim, "Input array size mismaches to the dimension");
+        assert_eq!(
+            a.len(),
+            self.dim,
+            "Input array size mismaches to the dimension"
+        );
         reflect(&self.v[k].slice(s![k..]), &mut a.slice_mut(s![k..]));
     }
 

src/lapack/cholesky.rs

@@ -18,7 +18,8 @@ pub trait Cholesky_: Sized {
     /// **Warning: Only the portion of `a` corresponding to `UPLO` is written.**
     unsafe fn inv_cholesky(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<()>;
     /// Wrapper of `*potrs`
-    unsafe fn solve_cholesky(l: MatrixLayout, uplo: UPLO, a: &[Self], b: &mut [Self]) -> Result<()>;
+    unsafe fn solve_cholesky(l: MatrixLayout, uplo: UPLO, a: &[Self], b: &mut [Self])
+        -> Result<()>;
 }
 
 macro_rules! impl_cholesky {
@@ -36,7 +37,12 @@ macro_rules! impl_cholesky {
                 into_result(info, ())
             }
 
-            unsafe fn solve_cholesky(l: MatrixLayout, uplo: UPLO, a: &[Self], b: &mut [Self]) -> Result<()> {
+            unsafe fn solve_cholesky(
+                l: MatrixLayout,
+                uplo: UPLO,
+                a: &[Self],
+                b: &mut [Self],
+            ) -> Result<()> {
                 let (n, _) = l.size();
                 let nrhs = 1;
                 let ldb = 1;

src/lapack/eig.rs

@@ -11,7 +11,11 @@ use super::into_result;
 
 /// Wraps `*geev` for real/complex
 pub trait Eig_: Scalar {
-    unsafe fn eig(calc_v: bool, l: MatrixLayout, a: &mut [Self]) -> Result<(Vec<Self::Complex>, Vec<Self::Complex>)>;
+    unsafe fn eig(
+        calc_v: bool,
+        l: MatrixLayout,
+        a: &mut [Self],
+    ) -> Result<(Vec<Self::Complex>, Vec<Self::Complex>)>;
 }
 
 macro_rules! impl_eig_complex {