Merge branch 'master' of https://github.com/bluss/ndarray

Author: sebasv

src/dimension/dimension_trait.rs

@@ -71,7 +71,8 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
     type Smaller: Dimension;
     /// Next larger dimension
     type Larger: Dimension;
-    #[doc(hidden)]
+
+    /// Returns the number of dimensions (number of axes).
     fn ndim(&self) -> usize;
 
     /// Convert the dimension into a pattern matching friendly value.
@@ -150,20 +151,13 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
         strides
     }
 
-    #[doc(hidden)]
-    // Return an index of same dimensionality
-    fn zero_index(&self) -> Self {
-        Self::default()
-    }
-
-    #[doc(hidden)]
-    /// Return an index of same type and with the specified dimensionality.
+    /// Creates a dimension of all zeros with the specified ndim.
     ///
     /// This method is useful for generalizing over fixed-size and
     /// variable-size dimension representations.
     ///
     /// **Panics** if `Self` has a fixed size that is not `ndim`.
-    fn zero_index_with_ndim(ndim: usize) -> Self;
+    fn zeros(ndim: usize) -> Self;
 
     #[doc(hidden)]
     #[inline]
@@ -173,11 +167,7 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
                 return None;
             }
         }
-        let mut index = self.clone();
-        for rr in index.slice_mut().iter_mut() {
-            *rr = 0;
-        }
-        Some(index)
+        Some(Self::zeros(self.ndim()))
     }
 
     #[doc(hidden)]
@@ -380,7 +370,7 @@ impl Dimension for Dim<[Ix; 0]> {
     #[inline]
     fn into_pattern(self) -> Self::Pattern { }
     #[inline]
-    fn zero_index_with_ndim(ndim: usize) -> Self {
+    fn zeros(ndim: usize) -> Self {
         assert_eq!(ndim, 0);
         Self::default()
     }
@@ -416,7 +406,7 @@ impl Dimension for Dim<[Ix; 1]> {
         get!(&self, 0)
     }
     #[inline]
-    fn zero_index_with_ndim(ndim: usize) -> Self {
+    fn zeros(ndim: usize) -> Self {
         assert_eq!(ndim, 1);
         Self::default()
     }
@@ -510,7 +500,7 @@ impl Dimension for Dim<[Ix; 2]> {
     #[inline]
     fn slice_mut(&mut self) -> &mut [Ix] { self.ixm() }
     #[inline]
-    fn zero_index_with_ndim(ndim: usize) -> Self {
+    fn zeros(ndim: usize) -> Self {
         assert_eq!(ndim, 2);
         Self::default()
     }
@@ -655,7 +645,7 @@ impl Dimension for Dim<[Ix; 3]> {
     }
 
     #[inline]
-    fn zero_index_with_ndim(ndim: usize) -> Self {
+    fn zeros(ndim: usize) -> Self {
         assert_eq!(ndim, 3);
         Self::default()
     }
@@ -764,7 +754,7 @@ macro_rules! large_dim {
             #[inline]
             fn slice_mut(&mut self) -> &mut [Ix] { self.ixm() }
             #[inline]
-            fn zero_index_with_ndim(ndim: usize) -> Self {
+            fn zeros(ndim: usize) -> Self {
                 assert_eq!(ndim, $n);
                 Self::default()
             }
@@ -817,12 +807,7 @@ impl Dimension for IxDyn
     }
 
     #[inline]
-    fn zero_index(&self) -> Self {
-        IxDyn::zeros(self.ndim())
-    }
-
-    #[inline]
-    fn zero_index_with_ndim(ndim: usize) -> Self {
+    fn zeros(ndim: usize) -> Self {
         IxDyn::zeros(ndim)
     }
 

src/impl_methods.rs

@@ -16,17 +16,9 @@ use imp_prelude::*;
 
 use arraytraits;
 use dimension;
-use iterators;
 use error::{self, ShapeError, ErrorKind};
 use dimension::IntoDimension;
 use dimension::{abs_index, axes_of, Axes, do_slice, merge_axes, stride_offset};
-use iterators::{
-    new_lanes,
-    new_lanes_mut,
-    exact_chunks_of,
-    exact_chunks_mut_of,
-    windows
-};
 use zip::Zip;
 
 use {
@@ -199,6 +191,29 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         }
     }
 
+    /// Returns a reference to the first element of the array, or `None` if it
+    /// is empty.
+    pub fn first(&self) -> Option<&A> {
+        if self.is_empty() {
+            None
+        } else {
+            Some(unsafe { &*self.as_ptr() })
+        }
+    }
+
+    /// Returns a mutable reference to the first element of the array, or
+    /// `None` if it is empty.
+    pub fn first_mut(&mut self) -> Option<&mut A>
+    where
+        S: DataMut,
+    {
+        if self.is_empty() {
+            None
+        } else {
+            Some(unsafe { &mut *self.as_mut_ptr() })
+        }
+    }
+
     /// Return an iterator of references to the elements of the array.
     ///
     /// Elements are visited in the *logical order* of the array, which
@@ -303,8 +318,8 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
 
         // Copy the dim and strides that remain after removing the subview axes.
         let out_ndim = info.out_ndim();
-        let mut new_dim = Do::zero_index_with_ndim(out_ndim);
-        let mut new_strides = Do::zero_index_with_ndim(out_ndim);
+        let mut new_dim = Do::zeros(out_ndim);
+        let mut new_strides = Do::zeros(out_ndim);
         izip!(self.dim.slice(), self.strides.slice(), indices)
             .filter_map(|(d, s, slice_or_index)| match slice_or_index {
                 &SliceOrIndex::Slice {..} => Some((d, s)),
@@ -676,7 +691,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     pub fn genrows(&self) -> Lanes<A, D::Smaller> {
         let mut n = self.ndim();
         if n == 0 { n += 1; }
-        new_lanes(self.view(), Axis(n - 1))
+        Lanes::new(self.view(), Axis(n - 1))
     }
 
     /// Return a producer and iterable that traverses over the *generalized*
@@ -688,7 +703,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     {
         let mut n = self.ndim();
         if n == 0 { n += 1; }
-        new_lanes_mut(self.view_mut(), Axis(n - 1))
+        LanesMut::new(self.view_mut(), Axis(n - 1))
     }
 
     /// Return a producer and iterable that traverses over the *generalized*
@@ -718,7 +733,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     /// }
     /// ```
     pub fn gencolumns(&self) -> Lanes<A, D::Smaller> {
-        new_lanes(self.view(), Axis(0))
+        Lanes::new(self.view(), Axis(0))
     }
 
     /// Return a producer and iterable that traverses over the *generalized*
@@ -728,7 +743,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     pub fn gencolumns_mut(&mut self) -> LanesMut<A, D::Smaller>
         where S: DataMut
     {
-        new_lanes_mut(self.view_mut(), Axis(0))
+        LanesMut::new(self.view_mut(), Axis(0))
     }
 
     /// Return a producer and iterable that traverses over all 1D lanes
@@ -760,7 +775,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     /// assert_eq!(inner2.into_iter().next().unwrap(), aview1(&[0, 1, 2]));
     /// ```
     pub fn lanes(&self, axis: Axis) -> Lanes<A, D::Smaller> {
-        new_lanes(self.view(), axis)
+        Lanes::new(self.view(), axis)
     }
 
     /// Return a producer and iterable that traverses over all 1D lanes
@@ -770,7 +785,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     pub fn lanes_mut(&mut self, axis: Axis) -> LanesMut<A, D::Smaller>
         where S: DataMut
     {
-        new_lanes_mut(self.view_mut(), axis)
+        LanesMut::new(self.view_mut(), axis)
     }
 
 
@@ -819,7 +834,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     pub fn axis_iter(&self, axis: Axis) -> AxisIter<A, D::Smaller>
         where D: RemoveAxis,
     {
-        iterators::new_axis_iter(self.view(), axis.index())
+        AxisIter::new(self.view(), axis)
     }
 
 
@@ -834,7 +849,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         where S: DataMut,
               D: RemoveAxis,
     {
-        iterators::new_axis_iter_mut(self.view_mut(), axis.index())
+        AxisIterMut::new(self.view_mut(), axis)
     }
 
 
@@ -865,7 +880,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     ///                                              [[26, 27]]]));
     /// ```
     pub fn axis_chunks_iter(&self, axis: Axis, size: usize) -> AxisChunksIter<A, D> {
-        iterators::new_chunk_iter(self.view(), axis.index(), size)
+        AxisChunksIter::new(self.view(), axis, size)
     }
 
     /// Return an iterator that traverses over `axis` by chunks of `size`,
@@ -878,7 +893,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         -> AxisChunksIterMut<A, D>
         where S: DataMut
     {
-        iterators::new_chunk_iter_mut(self.view_mut(), axis.index(), size)
+        AxisChunksIterMut::new(self.view_mut(), axis, size)
     }
 
     /// Return an exact chunks producer (and iterable).
@@ -895,7 +910,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     pub fn exact_chunks<E>(&self, chunk_size: E) -> ExactChunks<A, D>
         where E: IntoDimension<Dim=D>,
     {
-        exact_chunks_of(self.view(), chunk_size)
+        ExactChunks::new(self.view(), chunk_size)
     }
 
     /// Return an exact chunks producer (and iterable).
@@ -934,7 +949,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         where E: IntoDimension<Dim=D>,
               S: DataMut
     {
-        exact_chunks_mut_of(self.view_mut(), chunk_size)
+        ExactChunksMut::new(self.view_mut(), chunk_size)
     }
 
     /// Return a window producer and iterable.
@@ -954,7 +969,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     pub fn windows<E>(&self, window_size: E) -> Windows<A, D>
         where E: IntoDimension<Dim=D>
     {
-        windows(self.view(), window_size)
+        Windows::new(self.view(), window_size)
     }
 
     // Return (length, stride) for diagonal
@@ -1386,7 +1401,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     {
         let axes = axes.into_dimension();
         // Ensure that each axis is used exactly once.
-        let mut usage_counts = D::zero_index_with_ndim(self.ndim());
+        let mut usage_counts = D::zeros(self.ndim());
         for axis in axes.slice() {
             usage_counts[*axis] += 1;
         }
@@ -1395,7 +1410,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         }
         // Determine the new shape and strides.
         let mut new_dim = usage_counts; // reuse to avoid an allocation
-        let mut new_strides = D::zero_index_with_ndim(self.ndim());
+        let mut new_strides = D::zeros(self.ndim());
         {
             let dim = self.dim.slice();
             let strides = self.strides.slice();
@@ -1597,8 +1612,8 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         // break the arrays up into their inner rows
         let n = self.ndim();
         let dim = self.raw_dim();
-        Zip::from(new_lanes_mut(self.view_mut(), Axis(n - 1)))
-            .and(new_lanes(rhs.broadcast_assume(dim), Axis(n - 1)))
+        Zip::from(LanesMut::new(self.view_mut(), Axis(n - 1)))
+            .and(Lanes::new(rhs.broadcast_assume(dim), Axis(n - 1)))
             .apply(move |s_row, r_row| {
                 Zip::from(s_row).and(r_row).apply(|a, b| f(a, b))
             });

src/impl_views.rs

@@ -23,8 +23,7 @@ use {
     Baseiter,
 };
 
-use iter;
-use iterators;
+use iter::{self, AxisIter, AxisIterMut};
 
 /// Methods for read-only array views.
 impl<'a, A, D> ArrayView<'a, A, D>
@@ -469,15 +468,15 @@ impl<'a, A, D> ArrayView<'a, A, D>
     }
 
     #[inline]
-    pub(crate) fn into_base_iter(self) -> Baseiter<'a, A, D> {
+    pub(crate) fn into_base_iter(self) -> Baseiter<A, D> {
         unsafe {
             Baseiter::new(self.ptr, self.dim, self.strides)
         }
     }
 
     #[inline]
     pub(crate) fn into_elements_base(self) -> ElementsBase<'a, A, D> {
-        ElementsBase { inner: self.into_base_iter() }
+        ElementsBase::new(self)
     }
 
     pub(crate) fn into_iter_(self) -> Iter<'a, A, D> {
@@ -490,7 +489,7 @@ impl<'a, A, D> ArrayView<'a, A, D>
     pub fn into_outer_iter(self) -> iter::AxisIter<'a, A, D::Smaller>
         where D: RemoveAxis,
     {
-        iterators::new_outer_iter(self)
+        AxisIter::new(self, Axis(0))
     }
 
 }
@@ -519,15 +518,15 @@ impl<'a, A, D> ArrayViewMut<'a, A, D>
     }
 
     #[inline]
-    pub(crate) fn into_base_iter(self) -> Baseiter<'a, A, D> {
+    pub(crate) fn into_base_iter(self) -> Baseiter<A, D> {
         unsafe {
             Baseiter::new(self.ptr, self.dim, self.strides)
         }
     }
 
     #[inline]
     pub(crate) fn into_elements_base(self) -> ElementsBaseMut<'a, A, D> {
-        ElementsBaseMut { inner: self.into_base_iter() }
+        ElementsBaseMut::new(self)
     }
 
     pub(crate) fn into_slice_(self) -> Result<&'a mut [A], Self> {
@@ -550,7 +549,7 @@ impl<'a, A, D> ArrayViewMut<'a, A, D>
     pub fn into_outer_iter(self) -> iter::AxisIterMut<'a, A, D::Smaller>
         where D: RemoveAxis,
     {
-        iterators::new_outer_iter_mut(self)
+        AxisIterMut::new(self, Axis(0))
     }
 }
 

src/indexes.rs

@@ -31,7 +31,7 @@ pub fn indices<E>(shape: E) -> Indices<E::Dim>
 {
     let dim = shape.into_dimension();
     Indices {
-        start: dim.zero_index(),
+        start: E::Dim::zeros(dim.ndim()),
         dim: dim,
     }
 }
@@ -210,7 +210,7 @@ pub fn indices_iter_f<E>(shape: E) -> IndicesIterF<E::Dim>
     where E: IntoDimension,
 {
     let dim = shape.into_dimension();
-    let zero = dim.zero_index();
+    let zero = E::Dim::zeros(dim.ndim());
     IndicesIterF {
         has_remaining: dim.size_checked() != Some(0),
         index: zero,