remove outdated options from rustfmt.toml and run cargo fmt

Author: toastronics

benches/sparse_dense_products.rs

@@ -1,11 +1,11 @@
 #[macro_use]
 extern crate bencher;
-extern crate sprs;
 extern crate ndarray;
+extern crate sprs;
 
 use bencher::Bencher;
-use sprs::{CsVec, CsMat};
 use ndarray::{Array, Array2, ShapeBuilder};
+use sprs::{CsMat, CsVec};
 
 fn sparse_dense_dotprod_default(bench: &mut Bencher) {
     let w = Array::range(0., 10., 0.00001);
@@ -25,37 +25,44 @@ fn sparse_dense_dotprod_specialized(bench: &mut Bencher) {
 
 fn sparse_dense_vec_matprod_default(bench: &mut Bencher) {
     let w = Array::range(0., 10., 0.00001);
-    let a = CsMat::new((3, 1000000),
-                       vec![0, 2, 4, 5],
-                       vec![0, 1, 0, 2, 2],
-                       vec![1., 2., 3., 4., 5.]);
+    let a = CsMat::new(
+        (3, 1000000),
+        vec![0, 2, 4, 5],
+        vec![0, 1, 0, 2, 2],
+        vec![1., 2., 3., 4., 5.],
+    );
     bench.iter(|| {
         &a * &w;
     });
 }
 
 fn sparse_dense_vec_matprod_specialized(bench: &mut Bencher) {
     let w = Array::range(0., 10., 0.00001);
-    let a = CsMat::new((3, 1000000),
-                       vec![0, 2, 4, 5],
-                       vec![0, 1, 0, 2, 2],
-                       vec![1., 2., 3., 4., 5.]);
+    let a = CsMat::new(
+        (3, 1000000),
+        vec![0, 2, 4, 5],
+        vec![0, 1, 0, 2, 2],
+        vec![1., 2., 3., 4., 5.],
+    );
     let rows = a.rows();
     let cols = w.shape()[0];
     let w_reshape = w.view().into_shape((1, cols)).unwrap();
     let w_t = w_reshape.t();
     let mut res = Array2::zeros((rows, 1).f());
     bench.iter(|| {
-        sprs::prod::csr_mulacc_dense_colmaj(a.view(),
-                                            w_t.view(),
-                                            res.view_mut());
+        sprs::prod::csr_mulacc_dense_colmaj(
+            a.view(),
+            w_t.view(),
+            res.view_mut(),
+        );
     });
 }
 
-benchmark_group!(benches,
-                 sparse_dense_dotprod_default,
-                 sparse_dense_dotprod_specialized,
-                 sparse_dense_vec_matprod_specialized,
-                 sparse_dense_vec_matprod_default);
+benchmark_group!(
+    benches,
+    sparse_dense_dotprod_default,
+    sparse_dense_dotprod_specialized,
+    sparse_dense_vec_matprod_specialized,
+    sparse_dense_vec_matprod_default
+);
 benchmark_main!(benches);
-

benches/suite.rs

@@ -1,24 +1,22 @@
 #[macro_use]
 extern crate bencher;
-extern crate sprs;
 extern crate alga;
+extern crate sprs;
 
+use alga::general::{Additive, Inverse};
 use bencher::Bencher;
 use sprs::CsVec;
-use alga::general::{Inverse, Additive};
 
 fn csvec_neg(bench: &mut Bencher) {
-    let vector = CsVec::new(10000, (10..9000).collect::<Vec<_>>(), vec![-1.3; 8990]);
-    bench.iter(|| {
-        -vector.clone()
-    });
+    let vector =
+        CsVec::new(10000, (10..9000).collect::<Vec<_>>(), vec![-1.3; 8990]);
+    bench.iter(|| -vector.clone());
 }
 
 fn csvec_additive_inverse(bench: &mut Bencher) {
-    let vector = CsVec::new(10000, (10..9000).collect::<Vec<_>>(), vec![-1.3; 8990]);
-    bench.iter(|| {
-        Inverse::<Additive>::inverse(&vector)
-    });
+    let vector =
+        CsVec::new(10000, (10..9000).collect::<Vec<_>>(), vec![-1.3; 8990]);
+    bench.iter(|| Inverse::<Additive>::inverse(&vector));
 }
 
 benchmark_group!(benches, csvec_neg, csvec_additive_inverse);

examples/heat.rs

@@ -1,3 +1,4 @@
+extern crate ndarray;
 ///! This file demonstrates basic usage of the sprs library,
 ///! where a heat diffusion problem with Dirichlet boundary condition
 ///! is solved for equilibrium. For simplicity we omit any relevant
@@ -14,9 +15,7 @@
 ///! This shows how a laplacian matrix can be constructed by directly
 ///! constructing the compressed structure, and how the resulting linear
 ///! system can be solved using an iterative method.
-
 extern crate sprs;
-extern crate ndarray;
 
 type VecView<'a, T> = ndarray::ArrayView<'a, T, ndarray::Ix1>;
 type VecViewMut<'a, T> = ndarray::ArrayViewMut<'a, T, ndarray::Ix1>;
@@ -49,7 +48,7 @@ fn grid_laplacian(shape: (usize, usize)) -> sprs::CsMat<f64> {
     let (rows, cols) = shape;
     let nb_vert = rows * cols;
     let mut indptr = Vec::with_capacity(nb_vert + 1);
-    let nnz = 5*nb_vert + 5;
+    let nnz = 5 * nb_vert + 5;
     let mut indices = Vec::with_capacity(nnz);
     let mut data = Vec::with_capacity(nnz);
     let mut cumsum = 0;
@@ -67,8 +66,7 @@ fn grid_laplacian(shape: (usize, usize)) -> sprs::CsMat<f64> {
             if is_border(i, j, shape) {
                 // establish Dirichlet boundary conditions
                 add_elt(i, j, 1.);
-            }
-            else {
+            } else {
                 add_elt(i - 1, j, 1.);
                 add_elt(i, j - 1, 1.);
                 add_elt(i, j, -4.);
@@ -84,17 +82,18 @@ fn grid_laplacian(shape: (usize, usize)) -> sprs::CsMat<f64> {
 }
 
 /// Set a dirichlet boundary condition
-fn set_boundary_condition<F>(mut rhs: VecViewMut<f64>,
-                             grid_shape: (usize, usize),
-                             f: F
-                            )
-where F: Fn(usize, usize) -> f64
+fn set_boundary_condition<F>(
+    mut rhs: VecViewMut<f64>,
+    grid_shape: (usize, usize),
+    f: F,
+) where
+    F: Fn(usize, usize) -> f64,
 {
     let (rows, cols) = grid_shape;
     for i in 0..rows {
         for j in 0..cols {
             if is_border(i, j, grid_shape) {
-                let index = i*rows + j;
+                let index = i * rows + j;
                 rhs[[index]] = f(i, j);
             }
         }
@@ -103,12 +102,13 @@ where F: Fn(usize, usize) -> f64
 
 /// Gauss-Seidel method to solve the system
 /// see https://en.wikipedia.org/wiki/Gauss%E2%80%93Seidel_method#Algorithm
-fn gauss_seidel(mat: sprs::CsMatView<f64>,
-                mut x: VecViewMut<f64>,
-                rhs: VecView<f64>,
-                max_iter: usize,
-                eps: f64
-                ) -> Result<(usize, f64), f64> {
+fn gauss_seidel(
+    mat: sprs::CsMatView<f64>,
+    mut x: VecViewMut<f64>,
+    rhs: VecView<f64>,
+    max_iter: usize,
+    eps: f64,
+) -> Result<(usize, f64), f64> {
     assert!(mat.rows() == mat.cols());
     assert!(mat.rows() == x.shape()[0]);
     let mut error = (&mat * &x - rhs).scalar_sum().sqrt();
@@ -119,16 +119,15 @@ fn gauss_seidel(mat: sprs::CsMatView<f64>,
             for (col_ind, &val) in vec.iter() {
                 if row_ind != col_ind {
                     sigma += val * x[[col_ind]];
-                }
-                else {
+                } else {
                     diag = Some(val);
                 }
             }
             // Gauss-Seidel requires a non-zero diagonal, which
             // is satisfied for a laplacian matrix
             let diag = diag.unwrap();
             let cur_rhs = rhs[[row_ind]];
-            x[[row_ind]] = ( cur_rhs - sigma) / diag;
+            x[[row_ind]] = (cur_rhs - sigma) / diag;
         }
 
         error = (&mat * &x - rhs).scalar_sum().sqrt();
@@ -153,9 +152,10 @@ fn main() {
 
     match gauss_seidel(lap.view(), x.view_mut(), rhs.view(), 300, 1e-8) {
         Ok((iters, error)) => {
-            println!("Solved system in {} iterations with residual error {}",
-                     iters,
-                     error);
+            println!(
+                "Solved system in {} iterations with residual error {}",
+                iters, error
+            );
             let grid = x.view().into_shape((rows, cols)).unwrap();
             for i in 0..rows {
                 for j in 0..cols {

rustfmt.toml

@@ -1,3 +1 @@
 max_width = 80
-ideal_width = 76
-where_indent = "Inherit"