Rename scalar_prod and scalar_sum to product and sum

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

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

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];

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

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

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.]);

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]

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!(

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

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

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)

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 {

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

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

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

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]);
     }
 

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;