Format (please remove)

Author: termoshtt

benches/bench1.rs

@@ -9,8 +9,7 @@ use ndarray::prelude::*;
 use ndarray::NdProducer;
 
 #[bench]
-fn chunk2x2_iter_sum(bench: &mut Bencher)
-{
+fn chunk2x2_iter_sum(bench: &mut Bencher) {
     let a = Array::<f32, _>::zeros((256, 256));
     let chunksz = (2, 2);
     let mut sum = Array::zeros(a.exact_chunks(chunksz).raw_dim());
@@ -22,8 +21,7 @@ fn chunk2x2_iter_sum(bench: &mut Bencher)
 }
 
 #[bench]
-fn chunk2x2_scalar_sum(bench: &mut Bencher)
-{
+fn chunk2x2_scalar_sum(bench: &mut Bencher) {
     let a = Array::<f32, _>::zeros((256, 256));
     let chunksz = (2, 2);
     let mut sum = Array::zeros(a.exact_chunks(chunksz).raw_dim());
@@ -35,24 +33,22 @@ fn chunk2x2_scalar_sum(bench: &mut Bencher)
 }
 
 #[bench]
-fn chunk2x2_sum_get1(bench: &mut Bencher)
-{
+fn chunk2x2_sum_get1(bench: &mut Bencher) {
     let a = Array::<f32, _>::zeros((256, 256));
     let chunksz = (2, 2);
     let mut sum = Array::<f32, _>::zeros(a.exact_chunks(chunksz).raw_dim());
     bench.iter(|| {
         let (m, n) = a.dim();
         for i in 0..m {
             for j in 0..n {
-                sum[[i/2, j/2]] += a[[i, j]];
+                sum[[i / 2, j / 2]] += a[[i, j]];
             }
         }
     });
 }
 
 #[bench]
-fn chunk2x2_sum_uget1(bench: &mut Bencher)
-{
+fn chunk2x2_sum_uget1(bench: &mut Bencher) {
     let a = Array::<f32, _>::zeros((256, 256));
     let chunksz = (2, 2);
     let mut sum = Array::<f32, _>::zeros(a.exact_chunks(chunksz).raw_dim());
@@ -61,27 +57,26 @@ fn chunk2x2_sum_uget1(bench: &mut Bencher)
         for i in 0..m {
             for j in 0..n {
                 unsafe {
-                    *sum.uget_mut([i/2, j/2]) += *a.uget([i, j]);
+                    *sum.uget_mut([i / 2, j / 2]) += *a.uget([i, j]);
                 }
             }
         }
     });
 }
 
 #[bench]
-fn chunk2x2_sum_get2(bench: &mut Bencher)
-{
+fn chunk2x2_sum_get2(bench: &mut Bencher) {
     let a = Array::<f32, _>::zeros((256, 256));
     let chunksz = (2, 2);
     let mut sum = Array::<f32, _>::zeros(a.exact_chunks(chunksz).raw_dim());
     bench.iter(|| {
         let (m, n) = sum.dim();
         for i in 0..m {
             for j in 0..n {
-                sum[[i, j]] += a[[i*2 + 0, j*2 + 0]];
-                sum[[i, j]] += a[[i*2 + 0, j*2 + 1]];
-                sum[[i, j]] += a[[i*2 + 1, j*2 + 1]];
-                sum[[i, j]] += a[[i*2 + 1, j*2 + 0]];
+                sum[[i, j]] += a[[i * 2 + 0, j * 2 + 0]];
+                sum[[i, j]] += a[[i * 2 + 0, j * 2 + 1]];
+                sum[[i, j]] += a[[i * 2 + 1, j * 2 + 1]];
+                sum[[i, j]] += a[[i * 2 + 1, j * 2 + 0]];
             }
         }
     });

benches/chunks.rs

@@ -9,34 +9,24 @@ use ndarray::prelude::*;
 
 #[bench]
 fn default_f64(bench: &mut Bencher) {
-    bench.iter(|| {
-        Array::<f64, _>::default((128, 128))
-    })
+    bench.iter(|| Array::<f64, _>::default((128, 128)))
 }
 
 #[bench]
 fn zeros_f64(bench: &mut Bencher) {
-    bench.iter(|| {
-        Array::<f64, _>::zeros((128, 128))
-    })
+    bench.iter(|| Array::<f64, _>::zeros((128, 128)))
 }
 
 #[bench]
-fn map_regular(bench: &mut test::Bencher)
-{
+fn map_regular(bench: &mut test::Bencher) {
     let a = Array::linspace(0., 127., 128).into_shape((8, 16)).unwrap();
-    bench.iter(|| {
-        a.map(|&x| 2. * x)
-    });
+    bench.iter(|| a.map(|&x| 2. * x));
 }
 
 
 #[bench]
-fn map_stride(bench: &mut test::Bencher)
-{
+fn map_stride(bench: &mut test::Bencher) {
     let a = Array::linspace(0., 127., 256).into_shape((8, 32)).unwrap();
     let av = a.slice(s![.., ..;2]);
-    bench.iter(|| {
-        av.map(|&x| 2. * x)
-    });
+    bench.iter(|| av.map(|&x| 2. * x));
 }

benches/construct.rs

@@ -14,9 +14,7 @@ fn gemv_64_64c(bench: &mut Bencher) {
     let (m, n) = a.dim();
     let x = Array::zeros(n);
     let mut y = Array::zeros(m);
-    bench.iter(|| {
-        general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y);
-    });
+    bench.iter(|| { general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y); });
 }
 
 #[bench]
@@ -25,9 +23,7 @@ fn gemv_64_64f(bench: &mut Bencher) {
     let (m, n) = a.dim();
     let x = Array::zeros(n);
     let mut y = Array::zeros(m);
-    bench.iter(|| {
-        general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y);
-    });
+    bench.iter(|| { general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y); });
 }
 
 #[bench]
@@ -36,7 +32,5 @@ fn gemv_64_32(bench: &mut Bencher) {
     let (m, n) = a.dim();
     let x = Array::zeros(n);
     let mut y = Array::zeros(m);
-    bench.iter(|| {
-        general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y);
-    });
+    bench.iter(|| { general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y); });
 }

benches/gemv.rs

@@ -14,12 +14,9 @@ const X: usize = 64;
 const Y: usize = 16;
 
 #[bench]
-fn map_regular(bench: &mut Bencher)
-{
+fn map_regular(bench: &mut Bencher) {
     let a = Array::linspace(0., 127., N).into_shape((X, Y)).unwrap();
-    bench.iter(|| {
-        a.map(|&x| 2. * x)
-    });
+    bench.iter(|| a.map(|&x| 2. * x));
 }
 
 
@@ -28,63 +25,56 @@ pub fn double_array(mut a: ArrayViewMut2<f64>) {
 }
 
 #[bench]
-fn map_stride_double_f64(bench: &mut Bencher)
-{
-    let mut a = Array::linspace(0., 127., N * 2).into_shape([X, Y * 2]).unwrap();
+fn map_stride_double_f64(bench: &mut Bencher) {
+    let mut a = Array::linspace(0., 127., N * 2)
+        .into_shape([X, Y * 2])
+        .unwrap();
     let mut av = a.slice_mut(s![.., ..;2]);
-    bench.iter(|| {
-        double_array(av.view_mut());
-
-    });
+    bench.iter(|| { double_array(av.view_mut()); });
 }
 
 #[bench]
-fn map_stride_f64(bench: &mut Bencher)
-{
-    let a = Array::linspace(0., 127., N * 2).into_shape([X, Y * 2]).unwrap();
+fn map_stride_f64(bench: &mut Bencher) {
+    let a = Array::linspace(0., 127., N * 2)
+        .into_shape([X, Y * 2])
+        .unwrap();
     let av = a.slice(s![.., ..;2]);
-    bench.iter(|| {
-        av.map(|&x| 2. * x)
-    });
+    bench.iter(|| av.map(|&x| 2. * x));
 }
 
 #[bench]
-fn map_stride_u32(bench: &mut Bencher)
-{
-    let a = Array::linspace(0., 127., N * 2).into_shape([X, Y * 2]).unwrap();
+fn map_stride_u32(bench: &mut Bencher) {
+    let a = Array::linspace(0., 127., N * 2)
+        .into_shape([X, Y * 2])
+        .unwrap();
     let b = a.mapv(|x| x as u32);
     let av = b.slice(s![.., ..;2]);
-    bench.iter(|| {
-        av.map(|&x| 2 * x)
-    });
+    bench.iter(|| av.map(|&x| 2 * x));
 }
 
 #[bench]
-fn fold_axis(bench: &mut Bencher)
-{
-    let a = Array::linspace(0., 127., N * 2).into_shape([X, Y * 2]).unwrap();
-    bench.iter(|| {
-        a.fold_axis(Axis(0), 0., |&acc, &elt| acc + elt)
-    });
+fn fold_axis(bench: &mut Bencher) {
+    let a = Array::linspace(0., 127., N * 2)
+        .into_shape([X, Y * 2])
+        .unwrap();
+    bench.iter(|| a.fold_axis(Axis(0), 0., |&acc, &elt| acc + elt));
 }
 
 const MA: usize = 64;
 const MASZ: usize = MA * MA;
 
 #[bench]
-fn map_axis_0(bench: &mut Bencher)
-{
-    let a = Array::from_iter(0..MASZ as i32).into_shape([MA, MA]).unwrap();
-    bench.iter(|| {
-        a.map_axis(Axis(0), |lane| black_box(lane))
-    });
+fn map_axis_0(bench: &mut Bencher) {
+    let a = Array::from_iter(0..MASZ as i32)
+        .into_shape([MA, MA])
+        .unwrap();
+    bench.iter(|| a.map_axis(Axis(0), |lane| black_box(lane)));
 }
 
 #[bench]
-fn map_axis_1(bench: &mut Bencher)
-{
-    let a = Array::from_iter(0..MASZ as i32).into_shape([MA, MA]).unwrap();
-    bench.iter(|| {
-        a.map_axis(Axis(1), |lane| black_box(lane))
-    });
+fn map_axis_1(bench: &mut Bencher) {
+    let a = Array::from_iter(0..MASZ as i32)
+        .into_shape([MA, MA])
+        .unwrap();
+    bench.iter(|| a.map_axis(Axis(1), |lane| black_box(lane)));
 }