debloat: Factor out layout c/f check from layout computation

Factor out the code that checks C/F memory layout into standalone
functions. These functions will be more useful on their own. Also factor
out the NdProducer Layout computation function, so that more of that
code is shared between generic instatiations.

Tested using cargo llvm-lines.

Author: bluss

src/dimension/mod.rs

@@ -668,6 +668,56 @@ pub fn slices_intersect<D: Dimension>(
     true
 }
 
+pub(crate) fn is_layout_c<D: Dimension>(dim: &D, strides: &D) -> bool {
+    if let Some(1) = D::NDIM {
+        return strides[0] == 1 || dim[0] <= 1;
+    }
+
+    for &d in dim.slice() {
+        if d == 0 {
+            return true;
+        }
+    }
+
+    let mut contig_stride = 1_isize;
+    // check all dimensions -- a dimension of length 1 can have unequal strides
+    for (&dim, &s) in izip!(dim.slice().iter().rev(), strides.slice().iter().rev()) {
+        if dim != 1 {
+            let s = s as isize;
+            if s != contig_stride {
+                return false;
+            }
+            contig_stride *= dim as isize;
+        }
+    }
+    true
+}
+
+pub(crate) fn is_layout_f<D: Dimension>(dim: &D, strides: &D) -> bool {
+    if let Some(1) = D::NDIM {
+        return strides[0] == 1 || dim[0] <= 1;
+    }
+
+    for &d in dim.slice() {
+        if d == 0 {
+            return true;
+        }
+    }
+
+    let mut contig_stride = 1_isize;
+    // check all dimensions -- a dimension of length 1 can have unequal strides
+    for (&dim, &s) in izip!(dim.slice(), strides.slice()) {
+        if dim != 1 {
+            let s = s as isize;
+            if s != contig_stride {
+                return false;
+            }
+            contig_stride *= dim as isize;
+        }
+    }
+    true
+}
+
 pub fn merge_axes<D>(dim: &mut D, strides: &mut D, take: Axis, into: Axis) -> bool
 where
     D: Dimension,

src/impl_methods.rs

@@ -1382,23 +1382,7 @@ where
     /// Return `false` otherwise, i.e. the array is possibly not
     /// 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 {
-            if let Some(1) = D::NDIM {
-                return strides[0] == 1 || dim[0] <= 1;
-            }
-            if dim.slice().iter().any(|&d| d == 0) {
-                return true;
-            }
-            let defaults = dim.default_strides();
-            // check all dimensions -- a dimension of length 1 can have unequal strides
-            for (&dim, &s, &ds) in izip!(dim.slice(), strides.slice(), defaults.slice()) {
-                if dim != 1 && s != ds {
-                    return false;
-                }
-            }
-            true
-        }
-        is_standard_layout(&self.dim, &self.strides)
+        dimension::is_layout_c(&self.dim, &self.strides)
     }
 
     /// Return true if the array is known to be contiguous.

src/zip/mod.rs

@@ -21,6 +21,7 @@ use crate::partial::Partial;
 
 use crate::indexes::{indices, Indices};
 use crate::split_at::{SplitPreference, SplitAt};
+use crate::dimension;
 
 pub use self::ndproducer::{NdProducer, IntoNdProducer, Offset};
 
@@ -51,33 +52,38 @@ where
     private_decl! {}
 }
 
+/// Compute `Layout` hints for array shape dim, strides
+fn array_layout<D: Dimension>(dim: &D, strides: &D) -> Layout {
+    let n = dim.ndim();
+    if dimension::is_layout_c(dim, strides) {
+        // effectively one-dimensional => C and F layout compatible
+        if n <= 1 || dim.slice().iter().filter(|&&len| len > 1).count() <= 1 {
+            Layout::one_dimensional()
+        } else {
+            Layout::c()
+        }
+    } else if n > 1 && dimension::is_layout_f(dim, strides) {
+        Layout::f()
+    } else if n > 1 {
+        if dim[0] > 1 && strides[0] == 1 {
+            Layout::fpref()
+        } else if dim[n - 1] > 1 && strides[n - 1] == 1 {
+            Layout::cpref()
+        } else {
+            Layout::none()
+        }
+    } else {
+        Layout::none()
+    }
+}
+
 impl<S, D> ArrayBase<S, D>
 where
     S: RawData,
     D: Dimension,
 {
     pub(crate) fn layout_impl(&self) -> Layout {
-        let n = self.ndim();
-        if self.is_standard_layout() {
-            // effectively one-dimensional => C and F layout compatible
-            if n <= 1 || self.shape().iter().filter(|&&len| len > 1).count() <= 1 {
-                Layout::one_dimensional()
-            } else {
-                Layout::c()
-            }
-        } else if n > 1 && self.raw_view().reversed_axes().is_standard_layout() {
-            Layout::f()
-        } else if n > 1 {
-            if self.len_of(Axis(0)) > 1 && self.stride_of(Axis(0)) == 1 {
-                Layout::fpref()
-            } else if self.len_of(Axis(n - 1)) > 1 && self.stride_of(Axis(n - 1)) == 1 {
-                Layout::cpref()
-            } else {
-                Layout::none()
-            }
-        } else {
-            Layout::none()
-        }
+        array_layout(&self.dim, &self.strides)
     }
 }