Merge pull request #194 from rust-ndarray/format

cargo-fmt --check on CI

Author: termoshtt

.github/workflows/rust.yml

@@ -55,3 +55,12 @@ jobs:
       with:
         command: test
         args: --features=openblas --no-default-features
+
+  check-format:
+    runs-on: ubuntu-18.04
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions-rs/cargo@v1
+      with:
+        command: fmt
+        args: -- --check

examples/eig.rs

@@ -9,4 +9,4 @@ fn main() {
     let a_c: Array2<c64> = a.map(|f| c64::new(*f, 0.0));
     let av = a_c.dot(&vecs);
     println!("AV = \n{:?}", av);
-}
+}

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();

rustfmt.toml

@@ -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/cholesky.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/convert.rs

@@ -1,9 +1,9 @@
 //! Eigenvalue decomposition for non-symmetric square matrices
 
-use ndarray::*;
 use crate::error::*;
 use crate::layout::*;
 use crate::types::*;
+use ndarray::*;
 
 /// Eigenvalue decomposition of general matrix reference
 pub trait Eig {
@@ -27,7 +27,12 @@ where
         let layout = a.square_layout()?;
         let (s, t) = unsafe { A::eig(true, layout, a.as_allocated_mut()?)? };
         let (n, _) = layout.size();
-        Ok((ArrayBase::from(s), ArrayBase::from(t).into_shape((n as usize, n as usize)).unwrap()))
+        Ok((
+            ArrayBase::from(s),
+            ArrayBase::from(t)
+                .into_shape((n as usize, n as usize))
+                .unwrap(),
+        ))
     }
 }
 
@@ -49,4 +54,4 @@ where
         let (s, _) = unsafe { A::eig(true, a.square_layout()?, a.as_allocated_mut()?)? };
         Ok(ArrayBase::from(s))
     }
-}
+}

src/eig.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/error.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/inner.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>,