Merge pull request #808 from rust-ndarray/zip-minor-cleanups

Small refactoring and improvement around Zip

Author: bluss

src/indexes.rs

@@ -157,6 +157,20 @@ where
     private_impl! {}
 }
 
+// How the NdProducer for Indices works.
+//
+// NdProducer allows for raw pointers (Ptr), strides (Stride) and the produced
+// item (Item).
+//
+// Instead of Ptr, there is `IndexPtr<D>` which is an index value, like [0, 0, 0]
+// for the three dimensional case.
+//
+// The stride is simply which axis is currently being incremented. The stride for axis 1, is 1.
+//
+// .stride_offset(stride, index) simply computes the new index along that axis, for example:
+// [0, 0, 0].stride_offset(1, 10) => [0, 10, 0]  axis 1 is incremented by 10.
+//
+// .as_ref() converts the Ptr value to an Item. For example [0, 10, 0] => (0, 10, 0)
 impl<D: Dimension + Copy> NdProducer for Indices<D> {
     type Item = D::Pattern;
     type Dim = D;

src/zip/mod.rs

@@ -969,15 +969,9 @@ macro_rules! map_impl {
             pub fn and<P>(self, p: P) -> Zip<($($p,)* P::Output, ), D>
                 where P: IntoNdProducer<Dim=D>,
             {
-                let array = p.into_producer();
-                self.check(&array);
-                let part_layout = array.layout();
-                let ($($p,)*) = self.parts;
-                Zip {
-                    parts: ($($p,)* array, ),
-                    layout: self.layout.and(part_layout),
-                    dimension: self.dimension,
-                }
+                let part = p.into_producer();
+                self.check(&part);
+                self.build_and(part)
             }
 
             /// Include the producer `p` in the Zip, broadcasting if needed.
@@ -990,11 +984,17 @@ macro_rules! map_impl {
                 where P: IntoNdProducer<Dim=D2, Output=ArrayView<'a, Elem, D2>, Item=&'a Elem>,
                       D2: Dimension,
             {
-                let array = p.into_producer().broadcast_unwrap(self.dimension.clone());
-                let part_layout = array.layout();
+                let part = p.into_producer().broadcast_unwrap(self.dimension.clone());
+                self.build_and(part)
+            }
+
+            fn build_and<P>(self, part: P) -> Zip<($($p,)* P, ), D>
+                where P: NdProducer<Dim=D>,
+            {
+                let part_layout = part.layout();
                 let ($($p,)*) = self.parts;
                 Zip {
-                    parts: ($($p,)* array, ),
+                    parts: ($($p,)* part, ),
                     layout: self.layout.and(part_layout),
                     dimension: self.dimension,
                 }