Update documentation and function names

Author: SparrowLii

src/dimension/broadcast.rs

@@ -1,26 +1,24 @@
 use crate::error::*;
 use crate::{Dimension, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn};
 
-/// Calculate the co_broadcast shape of two dimensions. Return error if shapes are
-/// not compatible.
-fn broadcast_shape<D1, D2, Output>(shape1: &D1, shape2: &D2) -> Result<Output, ShapeError>
-where
-    D1: Dimension,
-    D2: Dimension,
-    Output: Dimension,
+/// Calculate the common shape for a pair of array shapes, which can be broadcasted
+/// to each other. Return an error if shapes are not compatible.
+///
+/// Uses the [NumPy broadcasting rules]
+//  (https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html#general-broadcasting-rules).
+fn co_broadcasting<D1, D2, Output>(shape1: &D1, shape2: &D2) -> Result<Output, ShapeError>
+    where
+        D1: Dimension,
+        D2: Dimension,
+        Output: Dimension,
 {
     let (k, overflow) = shape1.ndim().overflowing_sub(shape2.ndim());
     // Swap the order if d2 is longer.
     if overflow {
-        return broadcast_shape::<D2, D1, Output>(shape2, shape1);
+        return co_broadcasting::<D2, D1, Output>(shape2, shape1);
     }
     // The output should be the same length as shape1.
     let mut out = Output::zeros(shape1.ndim());
-    // Uses the [NumPy broadcasting rules]
-    // (https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html#general-broadcasting-rules).
-    //
-    // Zero dimension element is not in the original rules of broadcasting.
-    // We currently treat it like any other number greater than 1. As numpy does.
     for (out, s) in izip!(out.slice_mut(), shape1.slice()) {
         *out = *s;
     }
@@ -42,10 +40,7 @@ pub trait BroadcastShape<Other: Dimension> {
 
     /// Determines the shape after broadcasting the dimensions together.
     ///
-    /// If the dimensions are not compatible, returns `Err`.
-    ///
-    /// Uses the [NumPy broadcasting rules]
-    /// (https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html#general-broadcasting-rules).
+    /// If the shapes are not compatible, returns `Err`.
     fn broadcast_shape(&self, other: &Other) -> Result<Self::Output, ShapeError>;
 }
 
@@ -56,7 +51,7 @@ impl<D: Dimension> BroadcastShape<D> for D {
     type Output = D;
 
     fn broadcast_shape(&self, other: &D) -> Result<Self::Output, ShapeError> {
-        broadcast_shape::<D, D, Self::Output>(self, other)
+        co_broadcasting::<D, D, Self::Output>(self, other)
     }
 }
 
@@ -66,15 +61,15 @@ macro_rules! impl_broadcast_distinct_fixed {
             type Output = $larger;
 
             fn broadcast_shape(&self, other: &$larger) -> Result<Self::Output, ShapeError> {
-                broadcast_shape::<Self, $larger, Self::Output>(self, other)
+                co_broadcasting::<Self, $larger, Self::Output>(self, other)
             }
         }
 
         impl BroadcastShape<$smaller> for $larger {
             type Output = $larger;
 
             fn broadcast_shape(&self, other: &$smaller) -> Result<Self::Output, ShapeError> {
-                broadcast_shape::<Self, $smaller, Self::Output>(self, other)
+                co_broadcasting::<Self, $smaller, Self::Output>(self, other)
             }
         }
     };

src/impl_ops.rs

@@ -68,7 +68,6 @@ where
     A: Clone + $trt<B, Output=A>,
     B: Clone,
     S: DataOwned<Elem=A> + DataMut,
-    S::MaybeUninit: DataMut,
     S2: Data<Elem=B>,
     D: Dimension + BroadcastShape<E>,
     E: Dimension,
@@ -96,7 +95,6 @@ where
     A: Clone + $trt<B, Output=A>,
     B: Clone,
     S: DataOwned<Elem=A> + DataMut,
-    S::MaybeUninit: DataMut,
     S2: Data<Elem=B>,
     D: Dimension + BroadcastShape<E>,
     E: Dimension,
@@ -134,7 +132,6 @@ where
     B: Clone,
     S: Data<Elem=A>,
     S2: DataOwned<Elem=B> + DataMut,
-    S2::MaybeUninit: DataMut,
     D: Dimension,
     E: Dimension + BroadcastShape<D>,
 {

tests/array.rs

@@ -11,7 +11,7 @@ use defmac::defmac;
 use itertools::{enumerate, zip, Itertools};
 use ndarray::prelude::*;
 use ndarray::{arr3, rcarr2};
-use ndarray::{indices, BroadcastShape, ErrorKind, IxDynImpl, ShapeError};
+use ndarray::indices;
 use ndarray::{Slice, SliceInfo, SliceOrIndex};
 
 macro_rules! assert_panics {
@@ -1557,53 +1557,6 @@ fn insert_axis_view() {
     );
 }
 
-#[test]
-fn test_broadcast_shape() {
-    fn test_co<D1, D2>(
-        d1: &D1,
-        d2: &D2,
-        r: Result<<D1 as BroadcastShape<D2>>::Output, ShapeError>,
-    ) where
-        D1: Dimension + BroadcastShape<D2>,
-        D2: Dimension,
-    {
-        let d = d1.broadcast_shape(d2);
-        assert_eq!(d, r);
-    }
-    test_co(&Dim([2, 3]), &Dim([4, 1, 3]), Ok(Dim([4, 2, 3])));
-    test_co(
-        &Dim([1, 2, 2]),
-        &Dim([1, 3, 4]),
-        Err(ShapeError::from_kind(ErrorKind::IncompatibleShape)),
-    );
-    test_co(&Dim([3, 4, 5]), &Ix0(), Ok(Dim([3, 4, 5])));
-    let v = vec![1, 2, 3, 4, 5, 6, 7];
-    test_co(
-        &Dim(vec![1, 1, 3, 1, 5, 1, 7]),
-        &Dim([2, 1, 4, 1, 6, 1]),
-        Ok(Dim(IxDynImpl::from(v.as_slice()))),
-    );
-    let d = Dim([1, 2, 1, 3]);
-    test_co(&d, &d, Ok(d));
-    test_co(
-        &Dim([2, 1, 2]).into_dyn(),
-        &Dim(0),
-        Err(ShapeError::from_kind(ErrorKind::IncompatibleShape)),
-    );
-    test_co(
-        &Dim([2, 1, 1]),
-        &Dim([0, 0, 1, 3, 4]),
-        Ok(Dim([0, 0, 2, 3, 4])),
-    );
-    test_co(&Dim([0]), &Dim([0, 0, 0]), Ok(Dim([0, 0, 0])));
-    test_co(&Dim(1), &Dim([1, 0, 0]), Ok(Dim([1, 0, 0])));
-    test_co(
-        &Dim([1, 3, 0, 1, 1]),
-        &Dim([1, 2, 3, 1]),
-        Err(ShapeError::from_kind(ErrorKind::IncompatibleShape)),
-    );
-}
-
 #[test]
 fn arithmetic_broadcast() {
     let mut a = arr2(&[[1., 2.], [3., 4.]]);

tests/dimension.rs

@@ -2,7 +2,8 @@
 
 use defmac::defmac;
 
-use ndarray::{arr2, ArcArray, Array, Axis, Dim, Dimension, IxDyn, RemoveAxis};
+use ndarray::{arr2, ArcArray, Array, Axis, Dim, Dimension, Ix0, IxDyn, IxDynImpl, RemoveAxis,
+              ErrorKind, ShapeError, BroadcastShape};
 
 use std::hash::{Hash, Hasher};
 
@@ -340,3 +341,50 @@ fn test_all_ndindex() {
     ndindex!(10, 4, 3, 2, 2);
     ndindex!(10, 4, 3, 2, 2, 2);
 }
+
+#[test]
+fn test_broadcast_shape() {
+    fn test_co<D1, D2>(
+        d1: &D1,
+        d2: &D2,
+        r: Result<<D1 as BroadcastShape<D2>>::Output, ShapeError>,
+    ) where
+        D1: Dimension + BroadcastShape<D2>,
+        D2: Dimension,
+    {
+        let d = d1.broadcast_shape(d2);
+        assert_eq!(d, r);
+    }
+    test_co(&Dim([2, 3]), &Dim([4, 1, 3]), Ok(Dim([4, 2, 3])));
+    test_co(
+        &Dim([1, 2, 2]),
+        &Dim([1, 3, 4]),
+        Err(ShapeError::from_kind(ErrorKind::IncompatibleShape)),
+    );
+    test_co(&Dim([3, 4, 5]), &Ix0(), Ok(Dim([3, 4, 5])));
+    let v = vec![1, 2, 3, 4, 5, 6, 7];
+    test_co(
+        &Dim(vec![1, 1, 3, 1, 5, 1, 7]),
+        &Dim([2, 1, 4, 1, 6, 1]),
+        Ok(Dim(IxDynImpl::from(v.as_slice()))),
+    );
+    let d = Dim([1, 2, 1, 3]);
+    test_co(&d, &d, Ok(d));
+    test_co(
+        &Dim([2, 1, 2]).into_dyn(),
+        &Dim(0),
+        Err(ShapeError::from_kind(ErrorKind::IncompatibleShape)),
+    );
+    test_co(
+        &Dim([2, 1, 1]),
+        &Dim([0, 0, 1, 3, 4]),
+        Ok(Dim([0, 0, 2, 3, 4])),
+    );
+    test_co(&Dim([0]), &Dim([0, 0, 0]), Ok(Dim([0, 0, 0])));
+    test_co(&Dim(1), &Dim([1, 0, 0]), Ok(Dim([1, 0, 0])));
+    test_co(
+        &Dim([1, 3, 0, 1, 1]),
+        &Dim([1, 2, 3, 1]),
+        Err(ShapeError::from_kind(ErrorKind::IncompatibleShape)),
+    );
+}