Improve performance of "no-broadcasting-needed" scenario in &array +&array operation

src/impl_methods.rs

@@ -1804,14 +1804,38 @@ where
         E: Dimension,
     {
         let shape = co_broadcast::<D, E, <D as DimMax<E>>::Output>(&self.dim, &other.dim)?;
-        if let Some(view1) = self.broadcast(shape.clone()) {
-            if let Some(view2) = other.broadcast(shape) {
+        let view1 = if shape.slice() == self.dim.slice() {
+            self.to_dimensionality::<<D as DimMax<E>>::Output>()
+        } else {
+            self.broadcast(shape.clone())
+        };
+        let view2 = if shape.slice() == other.dim.slice() {
+            other.to_dimensionality::<<D as DimMax<E>>::Output>()
+        } else {
+            other.broadcast(shape)
+        };
+        if let Some(view1) = view1 {
+            if let Some(view2) = view2 {
                 return Ok((view1, view2));
             }
         }
         Err(from_kind(ErrorKind::IncompatibleShape))
     }
 
+    /// Creat an array view from an array with the same shape, but different dimensionality
+    /// type. Return None if the numbers of axes mismatch.
+    #[inline]
+    pub(crate) fn to_dimensionality<D2>(&self) -> Option<ArrayView<'_, A, D2>>
+    where
+        D2: Dimension,
+        S: Data,
+    {
+        let dim = <D2>::from_dimension(&self.dim)?;
+        let strides = <D2>::from_dimension(&self.strides)?;
+
+        unsafe { Some(ArrayView::new(self.ptr, dim, strides)) }
+    }
+
     /// Swap axes `ax` and `bx`.
     ///
     /// This does not move any data, it just adjusts the array’s dimensions

src/impl_ops.rs

@@ -179,7 +179,13 @@ where
 {
     type Output = Array<A, <D as DimMax<E>>::Output>;
     fn $mth(self, rhs: &'a ArrayBase<S2, E>) -> Self::Output {
-        let (lhs, rhs) = self.broadcast_with(rhs).unwrap();
+        let (lhs, rhs) = if self.ndim() == rhs.ndim() && self.shape() == rhs.shape() {
+            let lhs = self.to_dimensionality::<<D as DimMax<E>>::Output>().unwrap();
+            let rhs = rhs.to_dimensionality::<<D as DimMax<E>>::Output>().unwrap();
+            (lhs, rhs)
+        } else {
+            self.broadcast_with(rhs).unwrap()
+        };
         Zip::from(&lhs).and(&rhs).map_collect(clone_opf(A::$mth))
     }
 }

tests/array.rs

@@ -1627,6 +1627,12 @@ fn arithmetic_broadcast() {
         sa2 + &sb2 + sc2.into_owned(),
         arr3(&[[[15, 19], [32, 36]], [[14, 18], [31, 35]]])
     );
+
+    // Same shape
+    let a = s.slice(s![..;-1, ..;2, ..]);
+    let b = s.slice(s![.., ..;2, ..]);
+    assert_eq!(a.shape(), b.shape());
+    assert_eq!(&a + &b, arr3(&[[[3, 7], [19, 23]], [[3, 7], [19, 23]]]));
 }
 
 #[test]