rust-ndarray · dineshadepu · Mar 23, 2019
diff --git a/src/arrayformat.rs b/src/arrayformat.rs
@@ -55,7 +55,7 @@ fn format_array<A, S, D, F>(view: &ArrayBase<S, D>, f: &mut fmt::Formatter,
                     write!(f, "]")?;
                 }
                 write!(f, ",")?;
-                write!(f, "\n")?;
+                writeln!(f)?;
                 for _ in 0..ndim - n {
                     write!(f, " ")?;
                 }

diff --git a/src/data_traits.rs b/src/data_traits.rs
@@ -236,7 +236,7 @@ unsafe impl<A> Data for OwnedArcRepr<A> {
         Self::ensure_unique(&mut self_);
         let data = OwnedRepr(Arc::try_unwrap(self_.data.0).ok().unwrap());
         ArrayBase {
-            data: data,
+            data,
             ptr: self_.ptr,
             dim: self_.dim,
             strides: self_.strides,

diff --git a/src/dimension/axes.rs b/src/dimension/axes.rs
@@ -1,4 +1,3 @@
-
 use crate::{Dimension, Axis, Ix, Ixs};
 
 /// Create a new Axes iterator
@@ -7,7 +6,7 @@ pub fn axes_of<'a, D>(d: &'a D, strides: &'a D) -> Axes<'a, D>
 {
     Axes {
         dim: d,
-        strides: strides,
+        strides,
         start: 0,
         end: d.ndim(),
     }
@@ -56,6 +55,9 @@ impl AxisDescription {
     /// Return stride
     #[inline(always)]
     pub fn stride(self) -> Ixs { self.2 }
+    /// Returns True if axis is of length 0
+    #[inline(always)]
+    pub fn is_empty(self) -> bool { self.len() == 0 }
 }
 
 copy_and_clone!(['a, D] Axes<'a, D>);
@@ -128,4 +130,3 @@ impl IncOps for usize {
         *self
     }
 }
-
diff --git a/src/dimension/axis.rs b/src/dimension/axis.rs
@@ -21,7 +21,7 @@ pub struct Axis(pub usize);
 impl Axis {
     /// Return the index of the axis.
     #[inline(always)]
-    pub fn index(&self) -> usize { self.0 }
+    pub fn index(self) -> usize { self.0 }
 }
 
 copy_and_clone!{Axis}
@@ -39,4 +39,3 @@ macro_rules! derive_cmp {
 
 derive_cmp!{PartialEq for Axis, eq -> bool}
 derive_cmp!{PartialOrd for Axis, partial_cmp -> Option<Ordering>}
-
diff --git a/src/dimension/dim.rs b/src/dimension/dim.rs
@@ -45,7 +45,7 @@ impl<I> Dim<I> {
     /// Private constructor and accessors for Dim
     pub(crate) fn new(index: I) -> Dim<I> {
         Dim {
-            index: index,
+            index,
         }
     }
     #[inline(always)]
@@ -181,4 +181,3 @@ impl_op!(Sub, sub, SubAssign, sub_assign, sub);
 impl_single_op!(Sub, sub, SubAssign, sub_assign, sub);
 impl_op!(Mul, mul, MulAssign, mul_assign, mul);
 impl_scalar_op!(Mul, mul, MulAssign, mul_assign, mul);
-
diff --git a/src/dimension/dimension_trait.rs b/src/dimension/dimension_trait.rs
@@ -356,7 +356,7 @@ macro_rules! impl_insert_axis_array(
             debug_assert!(axis.index() <= $n);
             let mut out = [1; $n + 1];
             out[0..axis.index()].copy_from_slice(&self.slice()[0..axis.index()]);
-            out[axis.index()+1..$n+1].copy_from_slice(&self.slice()[axis.index()..$n]);
+            out[axis.index()+1..=$n].copy_from_slice(&self.slice()[axis.index()..$n]);
             Dim(out)
         }
     );

diff --git a/src/dimension/dynindeximpl.rs b/src/dimension/dynindeximpl.rs
@@ -1,4 +1,3 @@
-
 use std::ops::{
     Index,
     IndexMut,
@@ -59,9 +58,8 @@ impl<T: Copy + Zero> IxDynRepr<T> {
     pub fn copy_from(x: &[T]) -> Self {
         if x.len() <= CAP {
             let mut arr = [T::zero(); CAP];
-            for i in 0..x.len() {
-                arr[i] = x[i];
-            }
+            // copy x elements to arr
+            arr[..x.len()].clone_from_slice(&x[..]);
             IxDynRepr::Inline(x.len() as _, arr)
         } else {
             Self::from(x)
@@ -134,7 +132,7 @@ impl IxDynImpl {
             if len < CAP {
                 let mut out = [1; CAP];
                 out[0..i].copy_from_slice(&self[0..i]);
-                out[i+1..len+1].copy_from_slice(&self[i..len]);
+                out[i+1..=len].copy_from_slice(&self[i..len]);
                 IxDynRepr::Inline((len + 1) as u32, out)
             } else {
                 let mut out = Vec::with_capacity(len + 1);
@@ -218,7 +216,7 @@ impl<'a> IntoIterator for &'a IxDynImpl {
     type IntoIter = <&'a [Ix] as IntoIterator>::IntoIter;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
-        self[..].into_iter()
+        self[..].iter()
     }
 }
 
@@ -233,7 +231,7 @@ impl IxDyn {
     /// Create a new dimension value with `n` axes, all zeros
     #[inline]
     pub fn zeros(n: usize) -> IxDyn {
-        const ZEROS: &'static [usize] = &[0; 4];
+        const ZEROS: &[usize] = &[0; 4];
         if n <= ZEROS.len() {
             Dim(&ZEROS[..n])
         } else {

diff --git a/src/dimension/mod.rs b/src/dimension/mod.rs
@@ -262,13 +262,11 @@ pub trait DimensionExt {
     /// Get the dimension at `axis`.
     ///
     /// *Panics* if `axis` is out of bounds.
-    #[inline]
     fn axis(&self, axis: Axis) -> Ix;
 
     /// Set the dimension at `axis`.
     ///
     /// *Panics* if `axis` is out of bounds.
-    #[inline]
     fn set_axis(&mut self, axis: Axis, value: Ix);
 }
 
@@ -520,12 +518,11 @@ fn slice_min_max(axis_len: usize, slice: Slice) -> Option<(usize, usize)> {
     let (start, end, step) = to_abs_slice(axis_len, slice);
     if start == end {
         None
+    }
+    else if step > 0 {
+        Some((start, end - 1 - (end - start - 1) % (step as usize)))
     } else {
-        if step > 0 {
-            Some((start, end - 1 - (end - start - 1) % (step as usize)))
-        } else {
-            Some((start + (end - start - 1) % (-step as usize), end - 1))
-        }
+        Some((start + (end - start - 1) % (-step as usize), end - 1))
     }
 }
 

diff --git a/src/impl_1d.rs b/src/impl_1d.rs
@@ -27,4 +27,3 @@ impl<A, S> ArrayBase<S, Ix1>
         }
     }
 }
-
diff --git a/src/impl_clone.rs b/src/impl_clone.rs
@@ -13,8 +13,8 @@ impl<S: RawDataClone, D: Clone> Clone for ArrayBase<S, D> {
         unsafe {
             let (data, ptr) = self.data.clone_with_ptr(self.ptr);
             ArrayBase {
-                data: data,
-                ptr: ptr,
+                data,
+                ptr,
                 dim: self.dim.clone(),
                 strides: self.strides.clone(),
             }

diff --git a/src/impl_constructors.rs b/src/impl_constructors.rs
@@ -246,7 +246,7 @@ impl<S, A, D> ArrayBase<S, D>
             unsafe { Self::from_shape_vec_unchecked(shape, v) }
         } else {
             let dim = shape.dim.clone();
-            let v = to_vec_mapped(indexes::indices_iter_f(dim).into_iter(), f);
+            let v = to_vec_mapped(indexes::indices_iter_f(dim), f);
             unsafe { Self::from_shape_vec_unchecked(shape, v) }
         }
     }
@@ -342,8 +342,8 @@ impl<S, A, D> ArrayBase<S, D>
         ArrayBase {
             ptr: v.as_mut_ptr(),
             data: DataOwned::new(v),
-            strides: strides,
-            dim: dim
+            strides,
+            dim
         }
     }
 

diff --git a/src/impl_methods.rs b/src/impl_methods.rs
@@ -206,7 +206,7 @@ where
     {
         let data = self.data.into_shared();
         ArrayBase {
-            data: data,
+            data,
             ptr: self.ptr,
             dim: self.dim,
             strides: self.strides,
@@ -353,9 +353,9 @@ where
         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)),
-                &SliceOrIndex::Index(_) => None,
+            .filter_map(|(d, s, slice_or_index)| match *slice_or_index {
+                SliceOrIndex::Slice {..} => Some((d, s)),
+                SliceOrIndex::Index(_) => None,
             })
             .zip(izip!(new_dim.slice_mut(), new_strides.slice_mut()))
             .for_each(|((d, s), (new_d, new_s))| {
@@ -391,11 +391,11 @@ where
         indices
             .iter()
             .enumerate()
-            .for_each(|(axis, slice_or_index)| match slice_or_index {
-                &SliceOrIndex::Slice { start, end, step } => {
+            .for_each(|(axis, slice_or_index)| match *slice_or_index {
+                SliceOrIndex::Slice { start, end, step } => {
                     self.slice_axis_inplace(Axis(axis), Slice { start, end, step })
                 }
-                &SliceOrIndex::Index(index) => {
+                SliceOrIndex::Index(index) => {
                     let i_usize = abs_index(self.len_of(Axis(axis)), index);
                     self.collapse_axis(Axis(axis), i_usize)
                 }
@@ -1101,8 +1101,7 @@ where
         /* empty shape has len 1 */
         let len = self.dim.slice().iter().cloned().min().unwrap_or(1);
         let stride = self.strides()
-                         .iter()
-                         .fold(0, |sum, s| sum + s);
+            .iter().sum();
         (len, stride)
     }
 
@@ -1166,9 +1165,8 @@ where
     /// contiguous in memory, it has custom strides, etc.
     pub fn is_standard_layout(&self) -> bool {
         fn is_standard_layout<D: Dimension>(dim: &D, strides: &D) -> bool {
-            match D::NDIM {
-                Some(1) => return strides[0] == 1 || dim[0] <= 1,
-                _ =>  { }
+            if let Some(1) = D::NDIM  {
+                return strides[0] == 1 || dim[0] <= 1;
             }
             if dim.slice().iter().any(|&d| d == 0) {
                 return true;
@@ -1379,7 +1377,7 @@ where
                 dim: shape,
             }
         } else {
-            let v = self.iter().map(|x| x.clone()).collect::<Vec<A>>();
+            let v = self.iter().cloned().collect::<Vec<A>>();
             unsafe {
                 ArrayBase::from_shape_vec_unchecked(shape, v)
             }
@@ -1425,8 +1423,8 @@ where
                 return Ok(ArrayBase {
                     data: self.data,
                     ptr: self.ptr,
-                    dim: dim,
-                    strides: strides,
+                    dim,
+                    strides,
                 });
             }
         }
@@ -1737,7 +1735,7 @@ where
             Some(slc) => {
                 let ptr = slc.as_ptr() as *mut A;
                 let end = unsafe {
-                    ptr.offset(slc.len() as isize)
+                    ptr.add(slc.len())
                 };
                 self.ptr >= ptr && self.ptr <= end
             }

diff --git a/src/impl_raw_views.rs b/src/impl_raw_views.rs
@@ -15,7 +15,7 @@ where
         RawArrayView {
             data: RawViewRepr::new(),
             ptr: ptr as *mut A,
-            dim: dim,
+            dim,
             strides: strides,
         }
     }
@@ -118,9 +118,9 @@ where
     pub(crate) unsafe fn new_(ptr: *mut A, dim: D, strides: D) -> Self {
         RawArrayViewMut {
             data: RawViewRepr::new(),
-            ptr: ptr,
-            dim: dim,
-            strides: strides,
+            ptr,
+            dim,
+            strides,
         }
     }
 

diff --git a/src/impl_views.rs b/src/impl_views.rs
@@ -486,8 +486,8 @@ impl<'a, A, D> ArrayView<'a, A, D>
         ArrayView {
             data: ViewRepr::new(),
             ptr: ptr as *mut A,
-            dim: dim,
-            strides: strides,
+            dim,
+            strides,
         }
     }
 
@@ -533,9 +533,9 @@ impl<'a, A, D> ArrayViewMut<'a, A, D>
         }
         ArrayViewMut {
             data: ViewRepr::new(),
-            ptr: ptr,
-            dim: dim,
-            strides: strides,
+            ptr,
+            dim,
+            strides,
         }
     }
 
@@ -586,4 +586,3 @@ impl<'a, A, D> ArrayViewMut<'a, A, D>
         AxisIterMut::new(self, Axis(0))
     }
 }
-
diff --git a/src/indexes.rs b/src/indexes.rs
@@ -32,7 +32,7 @@ pub fn indices<E>(shape: E) -> Indices<E::Dim>
     let dim = shape.into_dimension();
     Indices {
         start: E::Dim::zeros(dim.ndim()),
-        dim: dim,
+        dim,
     }
 }
 
@@ -90,7 +90,7 @@ impl<D> IntoIterator for Indices<D>
         let sz = self.dim.size();
         let index = if sz != 0 { Some(self.start) } else { None };
         IndicesIter {
-            index: index,
+            index,
             dim: self.dim,
         }
     }
@@ -135,7 +135,7 @@ impl<D: Dimension + Copy> NdProducer for Indices<D> {
 
     #[doc(hidden)]
     fn raw_dim(&self) -> Self::Dim {
-        self.dim.clone()
+        self.dim
     }
 
     #[doc(hidden)]
@@ -168,7 +168,7 @@ impl<D: Dimension + Copy> NdProducer for Indices<D> {
     unsafe fn uget_ptr(&self, i: &Self::Dim) -> Self::Ptr {
         let mut index = *i;
         index += &self.start;
-        IndexPtr { index: index }
+        IndexPtr { index }
     }
 
     #[doc(hidden)]
@@ -214,7 +214,7 @@ pub fn indices_iter_f<E>(shape: E) -> IndicesIterF<E::Dim>
     IndicesIterF {
         has_remaining: dim.size_checked() != Some(0),
         index: zero,
-        dim: dim,
+        dim,
     }
 }