Struct ndarray::Zip

pub struct Zip<Parts, D> { /* fields omitted */ }

Lock step function application across several arrays or other producers.

Zip allows matching several arrays to each other elementwise and applying a function over all tuples of elements (one element from each input at a time).

In general, the zip uses a tuple of producers (NdProducer trait) that all have to be of the same shape. The NdProducer implementation defines what its element type is (for example if it's a shared reference, mutable reference or an array view etc).

If all the input arrays are of the same memory order the zip performs much better and the compiler can usually vectorize the loop (if applicable).

The order elements are visited is not specified. The producers don’t have to have the same element type.

The Zip has two methods for function application: apply and fold_while. These can be called several times on the same zip object. The zip object can be split, which allows parallelization.

See also the azip!() macro which offers a convenient shorthand to common ways to use Zip.

use ndarray::Zip;
use ndarray::Array2;

type M = Array2<f64>;

let mut a = M::zeros((64, 64));
let b = M::zeros((64, 64));
let c = M::zeros((64, 64));
let d = M::zeros((64, 64));

Zip::from(&mut a).and(&b).and(&c).and(&d).apply(|w, &x, &y, &z| {
    *w += x + y * z;
});

Methods

impl<P, D> Zip<(P,), D> where D: Dimension, P: NdProducer<Dim=D>

fn from<Part>(array: Part) -> Self where Part: IntoNdProducer<Dim=D, Output=P>

Create a new Zip from the input array array.

The Zip will take the exact dimension of array and all inputs must have the same dimensions (or be broadcast to them).

impl<Parts, D> Zip<Parts, D> where D: Dimension

fn size(&self) -> usize

Return a the number of element tuples in the Zip

impl<D: Dimension, P1: NdProducer<Dim=D>> Zip<(P1,), D>

fn apply<F>(&mut self, function: F) where F: FnMut(P1::Item)

Apply a function to all elements of the input arrays, visiting elements in lock step.

fn fold_while<F, Acc>(&mut self, acc: Acc, function: F) -> FoldWhile<Acc> where F: FnMut(Acc, P1::Item) -> FoldWhile<Acc>

Apply a fold function to all elements of the input arrays, visiting elements in lock step.

The fold continues while the return value is a FoldWhile::Continue.

fn and<P>(self, p: P) -> Zip<(P1, P::Output), D> where P: IntoNdProducer<Dim=D>

Include the producer p in the Zip.

Panics if p’s shape doen't match the Zip’s exactly.

fn and_broadcast<'a, P, D2, Elem>(self,
                                  p: P)
                                  -> Zip<(P1, ArrayView<'a, Elem, D>), D> where P: IntoNdProducer<Dim=D2, Output=ArrayView<'a, Elem, D2>>,
        D2: Dimension

Include the producer p in the Zip, broadcasting if needed.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn split(self) -> (Self, Self)

Split the Zip evenly in two.

It will be split in the way that best preserves element locality.

impl<D: Dimension, P1: NdProducer<Dim=D>, P2: NdProducer<Dim=D>> Zip<(P1, P2), D>

fn apply<F>(&mut self, function: F) where F: FnMut(P1::Item, P2::Item)

Apply a function to all elements of the input arrays, visiting elements in lock step.

fn fold_while<F, Acc>(&mut self, acc: Acc, function: F) -> FoldWhile<Acc> where F: FnMut(Acc, P1::Item, P2::Item) -> FoldWhile<Acc>

Apply a fold function to all elements of the input arrays, visiting elements in lock step.

The fold continues while the return value is a FoldWhile::Continue.

fn and<P>(self, p: P) -> Zip<(P1, P2, P::Output), D> where P: IntoNdProducer<Dim=D>

Include the producer p in the Zip.

Panics if p’s shape doen't match the Zip’s exactly.

fn and_broadcast<'a, P, D2, Elem>(self,
                                  p: P)
                                  -> Zip<(P1, P2, ArrayView<'a, Elem, D>), D> where P: IntoNdProducer<Dim=D2, Output=ArrayView<'a, Elem, D2>>,
        D2: Dimension

Include the producer p in the Zip, broadcasting if needed.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn split(self) -> (Self, Self)

Split the Zip evenly in two.

It will be split in the way that best preserves element locality.

impl<D: Dimension, P1: NdProducer<Dim=D>, P2: NdProducer<Dim=D>, P3: NdProducer<Dim=D>> Zip<(P1, P2, P3), D>

fn apply<F>(&mut self, function: F) where F: FnMut(P1::Item, P2::Item, P3::Item)

Apply a function to all elements of the input arrays, visiting elements in lock step.

fn fold_while<F, Acc>(&mut self, acc: Acc, function: F) -> FoldWhile<Acc> where F: FnMut(Acc, P1::Item, P2::Item, P3::Item) -> FoldWhile<Acc>

Apply a fold function to all elements of the input arrays, visiting elements in lock step.

The fold continues while the return value is a FoldWhile::Continue.

fn and<P>(self, p: P) -> Zip<(P1, P2, P3, P::Output), D> where P: IntoNdProducer<Dim=D>

Include the producer p in the Zip.

Panics if p’s shape doen't match the Zip’s exactly.

fn and_broadcast<'a, P, D2, Elem>(self,
                                  p: P)
                                  -> Zip<(P1, P2, P3, ArrayView<'a, Elem, D>), D> where P: IntoNdProducer<Dim=D2, Output=ArrayView<'a, Elem, D2>>,
        D2: Dimension

Include the producer p in the Zip, broadcasting if needed.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn split(self) -> (Self, Self)

Split the Zip evenly in two.

It will be split in the way that best preserves element locality.

impl<D: Dimension, P1: NdProducer<Dim=D>, P2: NdProducer<Dim=D>, P3: NdProducer<Dim=D>, P4: NdProducer<Dim=D>> Zip<(P1, P2, P3, P4), D>

fn apply<F>(&mut self, function: F) where F: FnMut(P1::Item, P2::Item, P3::Item, P4::Item)

Apply a function to all elements of the input arrays, visiting elements in lock step.

fn fold_while<F, Acc>(&mut self, acc: Acc, function: F) -> FoldWhile<Acc> where F: FnMut(Acc, P1::Item, P2::Item, P3::Item, P4::Item) -> FoldWhile<Acc>

Apply a fold function to all elements of the input arrays, visiting elements in lock step.

The fold continues while the return value is a FoldWhile::Continue.

fn and<P>(self, p: P) -> Zip<(P1, P2, P3, P4, P::Output), D> where P: IntoNdProducer<Dim=D>

Include the producer p in the Zip.

Panics if p’s shape doen't match the Zip’s exactly.

fn and_broadcast<'a, P, D2, Elem>(self,
                                  p: P)
                                  -> Zip<(P1, P2, P3, P4, ArrayView<'a, Elem, D>), D> where P: IntoNdProducer<Dim=D2, Output=ArrayView<'a, Elem, D2>>,
        D2: Dimension

Include the producer p in the Zip, broadcasting if needed.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn split(self) -> (Self, Self)

Split the Zip evenly in two.

It will be split in the way that best preserves element locality.

impl<D: Dimension, P1: NdProducer<Dim=D>, P2: NdProducer<Dim=D>, P3: NdProducer<Dim=D>, P4: NdProducer<Dim=D>, P5: NdProducer<Dim=D>> Zip<(P1, P2, P3, P4, P5), D>

fn apply<F>(&mut self, function: F) where F: FnMut(P1::Item, P2::Item, P3::Item, P4::Item, P5::Item)

Apply a function to all elements of the input arrays, visiting elements in lock step.

fn fold_while<F, Acc>(&mut self, acc: Acc, function: F) -> FoldWhile<Acc> where F: FnMut(Acc, P1::Item, P2::Item, P3::Item, P4::Item, P5::Item) -> FoldWhile<Acc>

Apply a fold function to all elements of the input arrays, visiting elements in lock step.

The fold continues while the return value is a FoldWhile::Continue.

fn and<P>(self, p: P) -> Zip<(P1, P2, P3, P4, P5, P::Output), D> where P: IntoNdProducer<Dim=D>

Include the producer p in the Zip.

Panics if p’s shape doen't match the Zip’s exactly.

fn and_broadcast<'a, P, D2, Elem>(self,
                                  p: P)
                                  -> Zip<(P1, P2, P3, P4, P5, ArrayView<'a, Elem, D>), D> where P: IntoNdProducer<Dim=D2, Output=ArrayView<'a, Elem, D2>>,
        D2: Dimension

Include the producer p in the Zip, broadcasting if needed.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn split(self) -> (Self, Self)

Split the Zip evenly in two.

It will be split in the way that best preserves element locality.

impl<D: Dimension, P1: NdProducer<Dim=D>, P2: NdProducer<Dim=D>, P3: NdProducer<Dim=D>, P4: NdProducer<Dim=D>, P5: NdProducer<Dim=D>, P6: NdProducer<Dim=D>> Zip<(P1, P2, P3, P4, P5, P6), D>

fn apply<F>(&mut self, function: F) where F: FnMut(P1::Item, P2::Item, P3::Item, P4::Item, P5::Item, P6::Item)

Apply a function to all elements of the input arrays, visiting elements in lock step.

fn fold_while<F, Acc>(&mut self, acc: Acc, function: F) -> FoldWhile<Acc> where F: FnMut(Acc, P1::Item, P2::Item, P3::Item, P4::Item, P5::Item, P6::Item) -> FoldWhile<Acc>

Apply a fold function to all elements of the input arrays, visiting elements in lock step.

The fold continues while the return value is a FoldWhile::Continue.

fn split(self) -> (Self, Self)

Split the Zip evenly in two.

It will be split in the way that best preserves element locality.

Trait Implementations

impl<Parts: Debug, D: Debug> Debug for Zip<Parts, D>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<Parts: Clone, D: Clone> Clone for Zip<Parts, D>

fn clone(&self) -> Zip<Parts, D>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.