Merge pull request #520 from jturner314/rename-scalar-ops

jturner314 · web-flow · commit ae13fd2af9c5 · 2018-11-07T12:03:10.000-05:00
Rename scalar_prod and scalar_sum to product and sum
diff --git a/benches/bench1.rs b/benches/bench1.rs
@@ -174,55 +174,55 @@ fn iter_sum_2d_transpose_by_row(bench: &mut test::Bencher)
 }
 
 #[bench]
-fn scalar_sum_2d_regular(bench: &mut test::Bencher)
+fn sum_2d_regular(bench: &mut test::Bencher)
 {
     let a = Array::<i32, _>::zeros((64, 64));
     let a = black_box(a);
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
 #[bench]
-fn scalar_sum_2d_cutout(bench: &mut test::Bencher)
+fn sum_2d_cutout(bench: &mut test::Bencher)
 {
     let a = Array::<i32, _>::zeros((66, 66));
     let av = a.slice(s![1..-1, 1..-1]);
     let a = black_box(av);
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
 #[bench]
-fn scalar_sum_2d_float(bench: &mut test::Bencher)
+fn sum_2d_float(bench: &mut test::Bencher)
 {
     let a = Array::<f32, _>::zeros((64, 64));
     let a = black_box(a.view());
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
 #[bench]
-fn scalar_sum_2d_float_cutout(bench: &mut test::Bencher)
+fn sum_2d_float_cutout(bench: &mut test::Bencher)
 {
     let a = Array::<f32, _>::zeros((66, 66));
     let av = a.slice(s![1..-1, 1..-1]);
     let a = black_box(av);
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
 #[bench]
-fn scalar_sum_2d_float_t_cutout(bench: &mut test::Bencher)
+fn sum_2d_float_t_cutout(bench: &mut test::Bencher)
 {
     let a = Array::<f32, _>::zeros((66, 66));
     let av = a.slice(s![1..-1, 1..-1]).reversed_axes();
     let a = black_box(av);
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
diff --git a/benches/chunks.rs b/benches/chunks.rs
@@ -22,14 +22,14 @@ fn chunk2x2_iter_sum(bench: &mut Bencher)
 }
 
 #[bench]
-fn chunk2x2_scalar_sum(bench: &mut Bencher)
+fn chunk2x2_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());
     bench.iter(|| {
         azip!(ref a (a.exact_chunks(chunksz)), mut sum in {
-            *sum = a.scalar_sum();
+            *sum = a.sum();
         });
     });
 }
diff --git a/benches/iter.rs b/benches/iter.rs
@@ -97,7 +97,7 @@ fn iter_filter_sum_2d_stride_f32(bench: &mut Bencher)
 const ZIPSZ: usize = 10_000;
 
 #[bench]
-fn scalar_sum_3_std_zip1(bench: &mut Bencher)
+fn sum_3_std_zip1(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -110,7 +110,7 @@ fn scalar_sum_3_std_zip1(bench: &mut Bencher)
 }
 
 #[bench]
-fn scalar_sum_3_std_zip2(bench: &mut Bencher)
+fn sum_3_std_zip2(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -123,7 +123,7 @@ fn scalar_sum_3_std_zip2(bench: &mut Bencher)
 }
 
 #[bench]
-fn scalar_sum_3_std_zip3(bench: &mut Bencher)
+fn sum_3_std_zip3(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -151,7 +151,7 @@ fn vector_sum_3_std_zip(bench: &mut Bencher)
 }
 
 #[bench]
-fn scalar_sum_3_azip(bench: &mut Bencher)
+fn sum_3_azip(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -166,7 +166,7 @@ fn scalar_sum_3_azip(bench: &mut Bencher)
 }
 
 #[bench]
-fn scalar_sum_3_azip_fold(bench: &mut Bencher)
+fn sum_3_azip_fold(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
diff --git a/examples/column_standardize.rs b/examples/column_standardize.rs
@@ -7,7 +7,7 @@ use ndarray::prelude::*;
 fn std1d(a: ArrayView1<f64>) -> f64 {
     let n = a.len() as f64;
     if n == 0. { return 0.; }
-    let mean = a.scalar_sum() / n;
+    let mean = a.sum() / n;
     (a.fold(0., |acc, &x| acc + (x - mean).powi(2)) / n).sqrt()
 }
 
diff --git a/examples/zip_many.rs b/examples/zip_many.rs
@@ -28,13 +28,13 @@ fn main() {
     // sum of each row
     let ax = Axis(0);
     let mut sums = Array::zeros(a.len_of(ax));
-    azip!(mut sums, ref a (a.axis_iter(ax)) in { *sums = a.scalar_sum() });
+    azip!(mut sums, ref a (a.axis_iter(ax)) in { *sums = a.sum() });
 
     // sum of each chunk
     let chunk_sz = (2, 2);
     let nchunks = (n / chunk_sz.0, n / chunk_sz.1);
     let mut sums = Array::zeros(nchunks);
-    azip!(mut sums, ref a (a.exact_chunks(chunk_sz)) in { *sums = a.scalar_sum() });
+    azip!(mut sums, ref a (a.exact_chunks(chunk_sz)) in { *sums = a.sum() });
 
 
     // Let's imagine we split to parallelize
diff --git a/parallel/src/lib.rs b/parallel/src/lib.rs
@@ -57,7 +57,7 @@
 //!     let mut sums = Vec::new();
 //!     a.axis_iter(Axis(0))
 //!      .into_par_iter()
-//!      .map(|row| row.scalar_sum())
+//!      .map(|row| row.sum())
 //!      .collect_into_vec(&mut sums);
 //!
 //!     assert_eq!(sums, [120., 376., 632., 888.]);
diff --git a/parallel/tests/rayon.rs b/parallel/tests/rayon.rs
@@ -16,9 +16,9 @@ fn test_axis_iter() {
         v.fill(i as _);
     }
     assert_eq!(a.axis_iter(Axis(0)).len(), M);
-    let s: f64 = a.axis_iter(Axis(0)).into_par_iter().map(|x| x.scalar_sum()).sum();
+    let s: f64 = a.axis_iter(Axis(0)).into_par_iter().map(|x| x.sum()).sum();
     println!("{:?}", a.slice(s![..10, ..5]));
-    assert_eq!(s, a.scalar_sum());
+    assert_eq!(s, a.sum());
 }
 
 #[test]
@@ -38,7 +38,7 @@ fn test_regular_iter() {
     }
     let s: f64 = a.view().into_par_iter().map(|&x| x).sum();
     println!("{:?}", a.slice(s![..10, ..5]));
-    assert_eq!(s, a.scalar_sum());
+    assert_eq!(s, a.sum());
 }
 
 #[test]
diff --git a/src/arraytraits.rs b/src/arraytraits.rs
@@ -277,7 +277,7 @@ impl<'a, A, S, D> From<&'a mut ArrayBase<S, D>> for ArrayViewMut<'a, A, D>
 ///
 /// fn sum<'a, V: AsArray<'a, f64>>(data: V) -> f64 {
 ///     let array_view = data.into();
-///     array_view.scalar_sum()
+///     array_view.sum()
 /// }
 ///
 /// assert_eq!(
diff --git a/src/doc/ndarray_for_numpy_users/mod.rs b/src/doc/ndarray_for_numpy_users/mod.rs
@@ -418,7 +418,7 @@
 //!
 //! </td><td>
 //!
-//! [`a.scalar_sum()`][.scalar_sum()]
+//! [`a.sum()`][.sum()]
 //!
 //! </td><td>
 //!
@@ -446,7 +446,7 @@
 //!
 //! </td><td>
 //!
-//! `a.scalar_sum() / a.len() as f64`
+//! `a.sum() / a.len() as f64`
 //!
 //! </td><td>
 //!
@@ -615,7 +615,7 @@
 //! [.row_mut()]: ../../struct.ArrayBase.html#method.row_mut
 //! [.rows()]: ../../struct.ArrayBase.html#method.rows
 //! [s!]: ../../macro.s.html
-//! [.scalar_sum()]: ../../struct.ArrayBase.html#method.scalar_sum
+//! [.sum()]: ../../struct.ArrayBase.html#method.sum
 //! [.slice()]: ../../struct.ArrayBase.html#method.slice
 //! [.slice_axis()]: ../../struct.ArrayBase.html#method.slice_axis
 //! [.slice_inplace()]: ../../struct.ArrayBase.html#method.slice_inplace
diff --git a/src/doc/ndarray_for_numpy_users/simple_math.rs b/src/doc/ndarray_for_numpy_users/simple_math.rs
@@ -70,8 +70,8 @@
 //! // Change values less than 1.5 to 4.
 //! a.mapv_inplace(|x| if x < 1.5 { 4. } else { x });
 //!
-//! // Compute the scalar sum of the odd-index columns.
-//! let odd_sum = a.slice(s![.., 1..;2]).scalar_sum();
+//! // Compute the sum of the odd-index columns.
+//! let odd_sum = a.slice(s![.., 1..;2]).sum();
 //!
 //! // Create a 1-D array of exp(index).
 //! let b = Array::from_shape_fn(4, |i| (i as f64).exp());
diff --git a/src/free_functions.rs b/src/free_functions.rs
@@ -81,9 +81,7 @@ pub fn aview0<A>(x: &A) -> ArrayView0<A> {
 /// // Create a 2D array view from borrowed data
 /// let a2d = aview1(&data).into_shape((32, 32)).unwrap();
 ///
-/// assert!(
-///     a2d.scalar_sum() == 1024.0
-/// );
+/// assert_eq!(a2d.sum(), 1024.0);
 /// ```
 pub fn aview1<A>(xs: &[A]) -> ArrayView1<A> {
     ArrayView::from(xs)
diff --git a/src/numeric/impl_numeric.rs b/src/numeric/impl_numeric.rs
@@ -27,9 +27,9 @@ impl<A, S, D> ArrayBase<S, D>
     ///
     /// let a = arr2(&[[1., 2.],
     ///                [3., 4.]]);
-    /// assert_eq!(a.scalar_sum(), 10.);
+    /// assert_eq!(a.sum(), 10.);
     /// ```
-    pub fn scalar_sum(&self) -> A
+    pub fn sum(&self) -> A
         where A: Clone + Add<Output=A> + libnum::Zero,
     {
         if let Some(slc) = self.as_slice_memory_order() {
@@ -46,16 +46,24 @@ impl<A, S, D> ArrayBase<S, D>
         sum
     }
 
+    /// Return the sum of all elements in the array.
+    #[deprecated(note="renamed to `sum`", since="0.12.1")]
+    pub fn scalar_sum(&self) -> A
+        where A: Clone + Add<Output=A> + libnum::Zero,
+    {
+        self.sum()
+    }
+
     /// Return the product of all elements in the array.
     ///
     /// ```
     /// use ndarray::arr2;
     ///
     /// let a = arr2(&[[1., 2.],
     ///                [3., 4.]]);
-    /// assert_eq!(a.scalar_prod(), 24.);
+    /// assert_eq!(a.product(), 24.);
     /// ```
-    pub fn scalar_prod(&self) -> A
+    pub fn product(&self) -> A
         where A: Clone + Mul<Output=A> + libnum::One,
     {
         if let Some(slc) = self.as_slice_memory_order() {
@@ -99,7 +107,7 @@ impl<A, S, D> ArrayBase<S, D>
             // contiguous along the axis we are summing
             let ax = axis.index();
             for (i, elt) in enumerate(&mut res) {
-                *elt = self.subview(Axis(1 - ax), i).scalar_sum();
+                *elt = self.subview(Axis(1 - ax), i).sum();
             }
         } else {
             for i in 0..n {
diff --git a/src/zip/mod.rs b/src/zip/mod.rs
@@ -441,9 +441,7 @@ impl<'a, A, D: Dimension> NdProducer for ArrayViewMut<'a, A, D> {
 ///
 /// Zip::from(&mut e)
 ///     .and(a.genrows())
-///     .apply(|e, row| {
-///         *e = row.scalar_sum();
-///     });
+///     .apply(|e, row| *e = row.sum());
 ///
 /// // Check the result against the built in `.sum_axis()` along axis 1.
 /// assert_eq!(e, a.sum_axis(Axis(1)));
diff --git a/tests/array.rs b/tests/array.rs
@@ -694,12 +694,12 @@ fn sum_mean()
     assert_eq!(a.mean_axis(Axis(1)), arr1(&[1.5, 3.5]));
     assert_eq!(a.sum_axis(Axis(1)).sum_axis(Axis(0)), arr0(10.));
     assert_eq!(a.view().mean_axis(Axis(1)), aview1(&[1.5, 3.5]));
-    assert_eq!(a.scalar_sum(), 10.);
+    assert_eq!(a.sum(), 10.);
 }
 
 #[test]
 fn sum_mean_empty() {
-    assert_eq!(Array3::<f32>::ones((2, 0, 3)).scalar_sum(), 0.);
+    assert_eq!(Array3::<f32>::ones((2, 0, 3)).sum(), 0.);
     assert_eq!(Array1::<f32>::ones(0).sum_axis(Axis(0)), arr0(0.));
     assert_eq!(
         Array3::<f32>::ones((2, 0, 3)).sum_axis(Axis(1)),
@@ -1432,7 +1432,7 @@ fn scalar_ops() {
     let one = &zero + 1.;
     assert_eq!(0. * &one, zero);
     assert_eq!(&one * 0., zero);
-    assert_eq!((&one + &one).scalar_sum(), 8.);
+    assert_eq!((&one + &one).sum(), 8.);
     assert_eq!(&one / 2., 0.5 * &one);
     assert_eq!(&one % 1., zero);
 
@@ -1723,10 +1723,10 @@ fn test_map_axis() {
                    [7, 8, 9],
                    [10,11,12]]);
 
-    let b = a.map_axis(Axis(0), |view| view.scalar_sum());
+    let b = a.map_axis(Axis(0), |view| view.sum());
     let answer1 = arr1(&[22, 26, 30]);
     assert_eq!(b, answer1);
-    let c = a.map_axis(Axis(1), |view| view.scalar_sum());
+    let c = a.map_axis(Axis(1), |view| view.sum());
     let answer2 = arr1(&[6, 15, 24, 33]);
     assert_eq!(c, answer2);
 }
diff --git a/tests/azip.rs b/tests/azip.rs
@@ -51,7 +51,7 @@ fn test_azip2_sum() {
     for i in 0..2 {
         let ax = Axis(i);
         let mut b = Array::zeros(c.len_of(ax));
-        azip!(mut b, ref c (c.axis_iter(ax)) in { *b = c.scalar_sum() });
+        azip!(mut b, ref c (c.axis_iter(ax)) in { *b = c.sum() });
         assert!(b.all_close(&c.sum_axis(Axis(1 - i)), 1e-6));
     }
 }
diff --git a/tests/dimension.rs b/tests/dimension.rs
@@ -270,7 +270,7 @@ fn test_generic_operations() {
 #[test]
 fn test_array_view() {
     fn test_dim<D: Dimension>(d: &D) {
-        assert_eq!(d.as_array_view().scalar_sum(), 7);
+        assert_eq!(d.as_array_view().sum(), 7);
         assert_eq!(d.as_array_view().strides(), &[1]);
     }
 
diff --git a/tests/iterators.rs b/tests/iterators.rs
@@ -492,7 +492,7 @@ fn test_fold() {
     a += 1;
     let mut iter = a.iter();
     iter.next();
-    assert_eq!(iter.fold(0, |acc, &x| acc + x), a.scalar_sum() - 1);
+    assert_eq!(iter.fold(0, |acc, &x| acc + x), a.sum() - 1);
 
     let mut a = Array0::<i32>::default(());
     a += 1;
diff --git a/tests/oper.rs b/tests/oper.rs

Original file line number	Diff line number	Diff line change
`@@ -22,14 +22,14 @@ fn chunk2x2_iter_sum(bench: &mut Bencher)`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`#[bench]`
`25`		`-fn chunk2x2_scalar_sum(bench: &mut Bencher)`
	`25`	`+fn chunk2x2_sum(bench: &mut Bencher)`
`26`	`26`	`{`
`27`	`27`	`let a = Array::<f32, _>::zeros((256, 256));`
`28`	`28`	`let chunksz = (2, 2);`
`29`	`29`	`let mut sum = Array::zeros(a.exact_chunks(chunksz).raw_dim());`
`30`	`30`	`bench.iter(\|\| {`
`31`	`31`	`azip!(ref a (a.exact_chunks(chunksz)), mut sum in {`
`32`		`- *sum = a.scalar_sum();`
	`32`	`+ *sum = a.sum();`
`33`	`33`	`});`
`34`	`34`	`});`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ fn iter_filter_sum_2d_stride_f32(bench: &mut Bencher)`
`97`	`97`	`const ZIPSZ: usize = 10_000;`
`98`	`98`
`99`	`99`	`#[bench]`
`100`		`-fn scalar_sum_3_std_zip1(bench: &mut Bencher)`
	`100`	`+fn sum_3_std_zip1(bench: &mut Bencher)`
`101`	`101`	`{`
`102`	`102`	`let a = vec![1; ZIPSZ];`
`103`	`103`	`let b = vec![1; ZIPSZ];`
`@@ -110,7 +110,7 @@ fn scalar_sum_3_std_zip1(bench: &mut Bencher)`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`#[bench]`
`113`		`-fn scalar_sum_3_std_zip2(bench: &mut Bencher)`
	`113`	`+fn sum_3_std_zip2(bench: &mut Bencher)`
`114`	`114`	`{`
`115`	`115`	`let a = vec![1; ZIPSZ];`
`116`	`116`	`let b = vec![1; ZIPSZ];`
`@@ -123,7 +123,7 @@ fn scalar_sum_3_std_zip2(bench: &mut Bencher)`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`#[bench]`
`126`		`-fn scalar_sum_3_std_zip3(bench: &mut Bencher)`
	`126`	`+fn sum_3_std_zip3(bench: &mut Bencher)`
`127`	`127`	`{`
`128`	`128`	`let a = vec![1; ZIPSZ];`
`129`	`129`	`let b = vec![1; ZIPSZ];`
`@@ -151,7 +151,7 @@ fn vector_sum_3_std_zip(bench: &mut Bencher)`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`#[bench]`
`154`		`-fn scalar_sum_3_azip(bench: &mut Bencher)`
	`154`	`+fn sum_3_azip(bench: &mut Bencher)`
`155`	`155`	`{`
`156`	`156`	`let a = vec![1; ZIPSZ];`
`157`	`157`	`let b = vec![1; ZIPSZ];`
`@@ -166,7 +166,7 @@ fn scalar_sum_3_azip(bench: &mut Bencher)`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`#[bench]`
`169`		`-fn scalar_sum_3_azip_fold(bench: &mut Bencher)`
	`169`	`+fn sum_3_azip_fold(bench: &mut Bencher)`
`170`	`170`	`{`
`171`	`171`	`let a = vec![1; ZIPSZ];`
`172`	`172`	`let b = vec![1; ZIPSZ];`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ use ndarray::prelude::*;`
`7`	`7`	`fn std1d(a: ArrayView1<f64>) -> f64 {`
`8`	`8`	`let n = a.len() as f64;`
`9`	`9`	`if n == 0. { return 0.; }`
`10`		`- let mean = a.scalar_sum() / n;`
	`10`	`+ let mean = a.sum() / n;`
`11`	`11`	`(a.fold(0., \|acc, &x\| acc + (x - mean).powi(2)) / n).sqrt()`
`12`	`12`	`}`
`13`	`13`
Original file line number	Diff line number	Diff line change
`@@ -16,9 +16,9 @@ fn test_axis_iter() {`
`16`	`16`	`v.fill(i as _);`
`17`	`17`	`}`
`18`	`18`	`assert_eq!(a.axis_iter(Axis(0)).len(), M);`
`19`		`- let s: f64 = a.axis_iter(Axis(0)).into_par_iter().map(\|x\| x.scalar_sum()).sum();`
	`19`	`+ let s: f64 = a.axis_iter(Axis(0)).into_par_iter().map(\|x\| x.sum()).sum();`
`20`	`20`	`println!("{:?}", a.slice(s![..10, ..5]));`
`21`		`- assert_eq!(s, a.scalar_sum());`
	`21`	`+ assert_eq!(s, a.sum());`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`#[test]`
`@@ -38,7 +38,7 @@ fn test_regular_iter() {`
`38`	`38`	`}`
`39`	`39`	`let s: f64 = a.view().into_par_iter().map(\|&x\| x).sum();`
`40`	`40`	`println!("{:?}", a.slice(s![..10, ..5]));`
`41`		`- assert_eq!(s, a.scalar_sum());`
	`41`	`+ assert_eq!(s, a.sum());`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`#[test]`