FIX: Broken debug assertion in collect to f-order array

This fixes a "bug" in layout_impl - if an array is effectively
one-dimensional, like for example has dimension 2 x 1 x 1 (3d array
with len two), then it's possible it is both C and F-contig.

This was the reason for the debug assertion firing: collection starts
into an f-order output array, but when we've split the array enough
times, it's still an f-order array but in shape 1 x 1 x 1 or 2 x 1 x 1
in this case - and we detected that as a c-order array.

Author: bluss

src/zip/mod.rs

@@ -58,7 +58,8 @@ where
     pub(crate) fn layout_impl(&self) -> Layout {
         let n = self.ndim();
         if self.is_standard_layout() {
-            if n <= 1 {
+            // 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()
@@ -1173,8 +1174,19 @@ macro_rules! map_impl {
                 {
                     // Get the last producer; and make a Partial that aliases its data pointer
                     let (.., ref output) = &self.parts;
-                    debug_assert!(output.layout().is(CORDER | FORDER));
-                    debug_assert_eq!(output.layout().tendency() >= 0, self.layout_tendency >= 0);
+
+                    // debug assert that the output is contiguous in the memory layout we need
+                    if cfg!(debug_assertions) {
+                        let out_layout = output.layout();
+                        assert!(out_layout.is(CORDER | FORDER));
+                        assert!(
+                            (self.layout_tendency <= 0 && out_layout.tendency() <= 0) ||
+                            (self.layout_tendency >= 0 && out_layout.tendency() >= 0),
+                            "layout tendency violation for self layout {:?}, output layout {:?},\
+                            output shape {:?}",
+                            self.layout, out_layout, output.raw_dim());
+                    }
+
                     let mut partial = Partial::new(output.as_ptr());
 
                     // Apply the mapping function on this zip

tests/par_zip.rs

@@ -107,20 +107,26 @@ fn test_zip_small_collect() {
 
     for m in 0..32 {
         for n in 0..16 {
-            let dim = (m, n);
-            let b = Array::from_shape_fn(dim, |(i, j)| 1. / (i + 2 * j + 1) as f32);
-            let c = Array::from_shape_fn(dim, |(i, j)| f32::ln((1 + i + j) as f32));
-
-            {
-                let a = Zip::from(&b).and(&c).par_map_collect(|x, y| x + y);
-
-                assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
-                assert_eq!(a.strides(), b.strides());
+            for &is_f in &[false, true] {
+                let dim = (m, n).set_f(is_f);
+                let b = Array::from_shape_fn(dim, |(i, j)| 1. / (i + 2 * j + 1) as f32);
+                let c = Array::from_shape_fn(dim, |(i, j)| f32::ln((1 + i + j) as f32));
+
+                {
+                    let a = Zip::from(&b).and(&c).par_map_collect(|x, y| x + y);
+
+                    assert_abs_diff_eq!(a, &b + &c, epsilon = 1e-6);
+                    if m > 1 && n > 1 {
+                        assert_eq!(a.strides(), b.strides(),
+                            "Failure for {}x{} c/f: {:?}", m, n, is_f);
+                    }
+                }
             }
         }
     }
 }
 
+
 #[test]
 #[cfg(feature = "approx")]
 fn test_zip_assign_into() {