The great dimension migration to Dim<[Ix; N]>

benches/bench1.rs

@@ -9,6 +9,8 @@ use ndarray::{
     Array,
     Axis,
     Ix,
+    Array1,
+    Array2,
 };
 use ndarray::{arr0, arr1, arr2};
 
@@ -291,8 +293,8 @@ fn add_2d_cutout(bench: &mut test::Bencher)
 #[bench]
 fn add_2d_broadcast_1_to_2(bench: &mut test::Bencher)
 {
-    let mut a = Array::<i32, _>::zeros((64, 64));
-    let b = Array::<i32, _>::zeros(64);
+    let mut a = Array2::<i32>::zeros((64, 64));
+    let b = Array1::<i32>::zeros(64);
     let bv = b.view();
     bench.iter(|| {
         a += &bv;
@@ -717,7 +719,7 @@ fn dot_extended(bench: &mut test::Bencher) {
 
 const MEAN_SUM_N: usize = 127;
 
-fn range_mat(m: Ix, n: Ix) -> Array<f32, (Ix, Ix)> {
+fn range_mat(m: Ix, n: Ix) -> Array2<f32> {
     assert!(m * n != 0);
     Array::linspace(0., (m * n - 1) as f32, m * n).into_shape((m, n)).unwrap()
 }

benches/higher-order.rs

@@ -7,6 +7,7 @@ use test::Bencher;
 #[macro_use(s)]
 extern crate ndarray;
 use ndarray::prelude::*;
+use ndarray::ArrayViewMut2;
 
 const N: usize = 1024;
 const X: usize = 64;
@@ -22,12 +23,38 @@ fn map_regular(bench: &mut Bencher)
 }
 
 
+pub fn double_array(mut a: ArrayViewMut2<f64>) {
+    a *= 2.0;
+}
+
 #[bench]
-fn map_stride(bench: &mut Bencher)
+fn map_stride_double_f64(bench: &mut Bencher)
 {
-    let a = Array::linspace(0., 127., N * 2).into_shape((X, Y * 2)).unwrap();
+    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]
+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]
+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)
+    });
+}

benches/iter.rs

@@ -6,6 +6,7 @@ use test::Bencher;
 #[macro_use(s)]
 extern crate ndarray;
 use ndarray::prelude::*;
+use ndarray::Array2;
 
 #[bench]
 fn iter_sum_2d_regular(bench: &mut Bencher)
@@ -47,3 +48,45 @@ fn iter_sum_2d_transpose(bench: &mut Bencher)
         a.iter().fold(0, |acc, &x| acc + x)
     });
 }
+
+#[bench]
+fn iter_filter_sum_2d_u32(bench: &mut Bencher)
+{
+    let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap();
+    let b = a.mapv(|x| (x * 100.) as u32);
+    bench.iter(|| {
+        b.iter().filter(|&&x| x < 75).fold(0, |acc, &x| acc + x)
+    });
+}
+
+#[bench]
+fn iter_filter_sum_2d_f32(bench: &mut Bencher)
+{
+    let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap();
+    let b = a * 100.;
+    bench.iter(|| {
+        b.iter().filter(|&&x| x < 75.).fold(0., |acc, &x| acc + x)
+    });
+}
+
+#[bench]
+fn iter_filter_sum_2d_stride_u32(bench: &mut Bencher)
+{
+    let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap();
+    let b = a.mapv(|x| (x * 100.) as u32);
+    let b = b.slice(s![.., ..;2]);
+    bench.iter(|| {
+        b.iter().filter(|&&x| x < 75).fold(0, |acc, &x| acc + x)
+    });
+}
+
+#[bench]
+fn iter_filter_sum_2d_stride_f32(bench: &mut Bencher)
+{
+    let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap();
+    let b = a * 100.;
+    let b = b.slice(s![.., ..;2]);
+    bench.iter(|| {
+        b.iter().filter(|&&x| x < 75.).fold(0., |acc, &x| acc + x)
+    });
+}