Adds missing aliases to ArrayBase from RawRef and LayoutRef

Author: akern40

src/alias_asref.rs

@@ -5,13 +5,86 @@ use crate::{
     AxisDescription,
     Dimension,
     LayoutRef,
+    NdIndex,
     RawArrayView,
     RawData,
+    RawDataMut,
     RawRef,
     Slice,
     SliceArg,
 };
 
+/// Functions coming from RawRef
+impl<A, S: RawData<Elem = A>, D: Dimension> ArrayBase<S, D>
+{
+    /// Return a raw pointer to the element at `index`, or return `None`
+    /// if the index is out of bounds.
+    ///
+    /// ```
+    /// use ndarray::arr2;
+    ///
+    /// let a = arr2(&[[1., 2.], [3., 4.]]);
+    ///
+    /// let v = a.raw_view();
+    /// let p = a.get_ptr((0, 1)).unwrap();
+    ///
+    /// assert_eq!(unsafe { *p }, 2.);
+    /// ```
+    pub fn get_ptr<I>(&self, index: I) -> Option<*const A>
+    where I: NdIndex<D>
+    {
+        <Self as AsRef<RawRef<_, _>>>::as_ref(self).get_ptr(index)
+    }
+
+    /// Return a raw pointer to the element at `index`, or return `None`
+    /// if the index is out of bounds.
+    ///
+    /// ```
+    /// use ndarray::arr2;
+    ///
+    /// let mut a = arr2(&[[1., 2.], [3., 4.]]);
+    ///
+    /// let v = a.raw_view_mut();
+    /// let p = a.get_mut_ptr((0, 1)).unwrap();
+    ///
+    /// unsafe {
+    ///     *p = 5.;
+    /// }
+    ///
+    /// assert_eq!(a.get((0, 1)), Some(&5.));
+    /// ```
+    pub fn get_mut_ptr<I>(&mut self, index: I) -> Option<*mut A>
+    where
+        S: RawDataMut<Elem = A>,
+        I: NdIndex<D>,
+    {
+        <Self as AsMut<RawRef<_, _>>>::as_mut(self).get_mut_ptr(index)
+    }
+
+    /// Return a pointer to the first element in the array.
+    ///
+    /// Raw access to array elements needs to follow the strided indexing
+    /// scheme: an element at multi-index *I* in an array with strides *S* is
+    /// located at offset
+    ///
+    /// *Σ<sub>0 ≤ k < d</sub> I<sub>k</sub> × S<sub>k</sub>*
+    ///
+    /// where *d* is `self.ndim()`.
+    #[inline(always)]
+    pub fn as_ptr(&self) -> *const A
+    {
+        <Self as AsRef<RawRef<_, _>>>::as_ref(self).as_ptr()
+    }
+
+    /// Return a raw view of the array.
+    #[inline]
+    pub fn raw_view(&self) -> RawArrayView<S::Elem, D>
+    {
+        <Self as AsRef<RawRef<_, _>>>::as_ref(self).raw_view()
+    }
+}
+
+/// Functions coming from LayoutRef
 impl<S: RawData, D: Dimension> ArrayBase<S, D>
 {
     /// Slice the array in place without changing the number of dimensions.
@@ -182,28 +255,6 @@ impl<S: RawData, D: Dimension> ArrayBase<S, D>
         self.as_mut().merge_axes(take, into)
     }
 
-    /// Return a raw view of the array.
-    #[inline]
-    pub fn raw_view(&self) -> RawArrayView<S::Elem, D>
-    {
-        <Self as AsRef<RawRef<_, _>>>::as_ref(self).raw_view()
-    }
-
-    /// Return a pointer to the first element in the array.
-    ///
-    /// Raw access to array elements needs to follow the strided indexing
-    /// scheme: an element at multi-index *I* in an array with strides *S* is
-    /// located at offset
-    ///
-    /// *Σ<sub>0 ≤ k < d</sub> I<sub>k</sub> × S<sub>k</sub>*
-    ///
-    /// where *d* is `self.ndim()`.
-    #[inline(always)]
-    pub fn as_ptr(&self) -> *const S::Elem
-    {
-        <Self as AsRef<RawRef<_, _>>>::as_ref(self).as_ptr()
-    }
-
     /// Return the total number of elements in the array.
     pub fn len(&self) -> usize
     {

src/impl_2d.rs

@@ -148,3 +148,70 @@ impl<A> LayoutRef<A, Ix2>
         m == n
     }
 }
+
+impl<S: RawData> ArrayBase<S, Ix2>
+{
+    /// Return the number of rows (length of `Axis(0)`) in the two-dimensional array.
+    ///
+    /// ```
+    /// use ndarray::{array, Axis};
+    ///
+    /// let array = array![[1., 2.],
+    ///                    [3., 4.],
+    ///                    [5., 6.]];
+    /// assert_eq!(array.nrows(), 3);
+    ///
+    /// // equivalent ways of getting the dimensions
+    /// // get nrows, ncols by using dim:
+    /// let (m, n) = array.dim();
+    /// assert_eq!(m, array.nrows());
+    /// // get length of any particular axis with .len_of()
+    /// assert_eq!(m, array.len_of(Axis(0)));
+    /// ```
+    pub fn nrows(&self) -> usize
+    {
+        <Self as AsRef<LayoutRef<_, _>>>::as_ref(self).nrows()
+    }
+
+    /// Return the number of columns (length of `Axis(1)`) in the two-dimensional array.
+    ///
+    /// ```
+    /// use ndarray::{array, Axis};
+    ///
+    /// let array = array![[1., 2.],
+    ///                    [3., 4.],
+    ///                    [5., 6.]];
+    /// assert_eq!(array.ncols(), 2);
+    ///
+    /// // equivalent ways of getting the dimensions
+    /// // get nrows, ncols by using dim:
+    /// let (m, n) = array.dim();
+    /// assert_eq!(n, array.ncols());
+    /// // get length of any particular axis with .len_of()
+    /// assert_eq!(n, array.len_of(Axis(1)));
+    /// ```
+    pub fn ncols(&self) -> usize
+    {
+        <Self as AsRef<LayoutRef<_, _>>>::as_ref(self).ncols()
+    }
+
+    /// Return true if the array is square, false otherwise.
+    ///
+    /// # Examples
+    /// Square:
+    /// ```
+    /// use ndarray::array;
+    /// let array = array![[1., 2.], [3., 4.]];
+    /// assert!(array.is_square());
+    /// ```
+    /// Not square:
+    /// ```
+    /// use ndarray::array;
+    /// let array = array![[1., 2., 5.], [3., 4., 6.]];
+    /// assert!(!array.is_square());
+    /// ```
+    pub fn is_square(&self) -> bool
+    {
+        <Self as AsRef<LayoutRef<_, _>>>::as_ref(self).is_square()
+    }
+}

src/impl_dyn.rs

@@ -59,6 +59,51 @@ impl<A> LayoutRef<A, IxDyn>
     }
 }
 
+impl<S: RawData> ArrayBase<S, IxDyn>
+{
+    /// Insert new array axis of length 1 at `axis`, modifying the shape and
+    /// strides in-place.
+    ///
+    /// **Panics** if the axis is out of bounds.
+    ///
+    /// ```
+    /// use ndarray::{Axis, arr2, arr3};
+    ///
+    /// let mut a = arr2(&[[1, 2, 3], [4, 5, 6]]).into_dyn();
+    /// assert_eq!(a.shape(), &[2, 3]);
+    ///
+    /// a.insert_axis_inplace(Axis(1));
+    /// assert_eq!(a, arr3(&[[[1, 2, 3]], [[4, 5, 6]]]).into_dyn());
+    /// assert_eq!(a.shape(), &[2, 1, 3]);
+    /// ```
+    #[track_caller]
+    pub fn insert_axis_inplace(&mut self, axis: Axis)
+    {
+        self.as_mut().insert_axis_inplace(axis)
+    }
+
+    /// Collapses the array to `index` along the axis and removes the axis,
+    /// modifying the shape and strides in-place.
+    ///
+    /// **Panics** if `axis` or `index` is out of bounds.
+    ///
+    /// ```
+    /// use ndarray::{Axis, arr1, arr2};
+    ///
+    /// let mut a = arr2(&[[1, 2, 3], [4, 5, 6]]).into_dyn();
+    /// assert_eq!(a.shape(), &[2, 3]);
+    ///
+    /// a.index_axis_inplace(Axis(1), 1);
+    /// assert_eq!(a, arr1(&[2, 5]).into_dyn());
+    /// assert_eq!(a.shape(), &[2]);
+    /// ```
+    #[track_caller]
+    pub fn index_axis_inplace(&mut self, axis: Axis, index: usize)
+    {
+        self.as_mut().index_axis_inplace(axis, index)
+    }
+}
+
 impl<A, S> ArrayBase<S, IxDyn>
 where S: Data<Elem = A>
 {