pub struct Zip<Parts, D> {
parts: Parts,
dimension: D,
layout: Layout,
layout_tendency: i32,
}
Expand description
Lock step function application across several arrays or other producers.
Zip allows matching several producers to each other elementwise and applying a function over all tuples of elements (one item 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 item 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 layout 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 item type.
The Zip
has two methods for function application: for_each
and
fold_while
. The zip object can be split, which allows parallelization.
A read-only zip object (no mutable producers) can be cloned.
See also the azip!()
which offers a convenient shorthand
to common ways to use Zip
.
use ndarray::Zip;
use ndarray::Array2;
type M = Array2<f64>;
// Create four 2d arrays of the same size
let mut a = M::zeros((64, 32));
let b = M::from_elem(a.dim(), 1.);
let c = M::from_elem(a.dim(), 2.);
let d = M::from_elem(a.dim(), 3.);
// Example 1: Perform an elementwise arithmetic operation across
// the four arrays a, b, c, d.
Zip::from(&mut a)
.and(&b)
.and(&c)
.and(&d)
.for_each(|w, &x, &y, &z| {
*w += x + y * z;
});
// Example 2: Create a new array `totals` with one entry per row of `a`.
// Use Zip to traverse the rows of `a` and assign to the corresponding
// entry in `totals` with the sum across each row.
// This is possible because the producer for `totals` and the row producer
// for `a` have the same shape and dimensionality.
// The rows producer yields one array view (`row`) per iteration.
use ndarray::{Array1, Axis};
let mut totals = Array1::zeros(a.nrows());
Zip::from(&mut totals)
.and(a.rows())
.for_each(|totals, row| *totals = row.sum());
// Check the result against the built in `.sum_axis()` along axis 1.
assert_eq!(totals, a.sum_axis(Axis(1)));
// Example 3: Recreate Example 2 using map_collect to make a new array
let totals2 = Zip::from(a.rows()).map_collect(|row| row.sum());
// Check the result against the previous example.
assert_eq!(totals, totals2);
Fields§
§parts: Parts
§dimension: D
§layout: Layout
§layout_tendency: i32
Implementations§
source§impl<P, D> Zip<(P,), D>where
D: Dimension,
P: NdProducer<Dim = D>,
impl<P, D> Zip<(P,), D>where
D: Dimension,
P: NdProducer<Dim = D>,
source§impl<P, D> Zip<(Indices<D>, P), D>
impl<P, D> Zip<(Indices<D>, P), D>
source§impl<D, P1> Zip<(P1,), D>where
D: Dimension,
P1: NdProducer<Dim = D>,
impl<D, P1> Zip<(P1,), D>where
D: Dimension,
P1: NdProducer<Dim = D>,
sourcepub fn for_each<F>(self, function: F)
pub fn for_each<F>(self, function: F)
Apply a function to all elements of the input arrays, visiting elements in lock step.
sourcepub fn fold<F, Acc>(self, acc: Acc, function: F) -> Acc
pub fn fold<F, Acc>(self, acc: Acc, function: F) -> Acc
Apply a fold function to all elements of the input arrays, visiting elements in lock step.
§Example
The expression tr(AᵀB)
can be more efficiently computed as
the equivalent expression ∑ᵢⱼ(A∘B)ᵢⱼ
(i.e. the sum of the
elements of the entry-wise product). It would be possible to
evaluate this expression by first computing the entry-wise
product, A∘B
, and then computing the elementwise sum of that
product, but it’s possible to do this in a single loop (and
avoid an extra heap allocation if A
and B
can’t be
consumed) by using Zip
:
use ndarray::{array, Zip};
let a = array![[1, 5], [3, 7]];
let b = array![[2, 4], [8, 6]];
// Without using `Zip`. This involves two loops and an extra
// heap allocation for the result of `&a * &b`.
let sum_prod_nonzip = (&a * &b).sum();
// Using `Zip`. This is a single loop without any heap allocations.
let sum_prod_zip = Zip::from(&a).and(&b).fold(0, |acc, a, b| acc + a * b);
assert_eq!(sum_prod_nonzip, sum_prod_zip);
sourcepub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>
pub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>
Apply a fold function to the input arrays while the return
value is FoldWhile::Continue
, visiting elements in lock step.
sourcepub fn all<F>(self, predicate: F) -> bool
pub fn all<F>(self, predicate: F) -> bool
Tests if every element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for all elements.
Returns true
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).all(|&a, &b| a * a == b));
sourcepub fn any<F>(self, predicate: F) -> bool
pub fn any<F>(self, predicate: F) -> bool
Tests if at least one element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for at least one element.
Returns false
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).any(|&a, &b| a == b));
assert!(!Zip::from(&a).and(&b).any(|&a, &b| a - 1 == b));
sourcepub fn and<P>(self, p: P) -> Zip<(P1, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
pub fn and<P>(self, p: P) -> Zip<(P1, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
Include the producer p
in the Zip.
Panics if p
’s shape doesn’t match the Zip’s exactly.
sourcepub fn and_broadcast<'a, P, D2, Elem>(
self,
p: P
) -> Zip<(P1, ArrayBase<ViewRepr<&'a Elem>, D>), D>
pub fn and_broadcast<'a, P, D2, Elem>( self, p: P ) -> Zip<(P1, ArrayBase<ViewRepr<&'a Elem>, D>), D>
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.
sourcepub fn map_collect<R>(
self,
f: impl FnMut(<P1 as NdProducer>::Item) -> R
) -> ArrayBase<OwnedRepr<R>, D>
pub fn map_collect<R>( self, f: impl FnMut(<P1 as NdProducer>::Item) -> R ) -> ArrayBase<OwnedRepr<R>, D>
Map and collect the results into a new array, which has the same size as the inputs.
If all inputs are c- or f-order respectively, that is preserved in the output.
sourcepub fn map_assign_into<R, Q>(
self,
into: Q,
f: impl FnMut(<P1 as NdProducer>::Item) -> R
)
pub fn map_assign_into<R, Q>( self, into: Q, f: impl FnMut(<P1 as NdProducer>::Item) -> R )
Map and assign the results into the producer into
, which should have the same
size as the other inputs.
The producer should have assignable items as dictated by the AssignElem
trait,
for example &mut R
.
source§impl<D, P1, P2> Zip<(P1, P2), D>
impl<D, P1, P2> Zip<(P1, P2), D>
sourcepub fn for_each<F>(self, function: F)
pub fn for_each<F>(self, function: F)
Apply a function to all elements of the input arrays, visiting elements in lock step.
sourcepub fn fold<F, Acc>(self, acc: Acc, function: F) -> Acc
pub fn fold<F, Acc>(self, acc: Acc, function: F) -> Acc
Apply a fold function to all elements of the input arrays, visiting elements in lock step.
§Example
The expression tr(AᵀB)
can be more efficiently computed as
the equivalent expression ∑ᵢⱼ(A∘B)ᵢⱼ
(i.e. the sum of the
elements of the entry-wise product). It would be possible to
evaluate this expression by first computing the entry-wise
product, A∘B
, and then computing the elementwise sum of that
product, but it’s possible to do this in a single loop (and
avoid an extra heap allocation if A
and B
can’t be
consumed) by using Zip
:
use ndarray::{array, Zip};
let a = array![[1, 5], [3, 7]];
let b = array![[2, 4], [8, 6]];
// Without using `Zip`. This involves two loops and an extra
// heap allocation for the result of `&a * &b`.
let sum_prod_nonzip = (&a * &b).sum();
// Using `Zip`. This is a single loop without any heap allocations.
let sum_prod_zip = Zip::from(&a).and(&b).fold(0, |acc, a, b| acc + a * b);
assert_eq!(sum_prod_nonzip, sum_prod_zip);
sourcepub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>
pub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>
Apply a fold function to the input arrays while the return
value is FoldWhile::Continue
, visiting elements in lock step.
sourcepub fn all<F>(self, predicate: F) -> bool
pub fn all<F>(self, predicate: F) -> bool
Tests if every element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for all elements.
Returns true
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).all(|&a, &b| a * a == b));
sourcepub fn any<F>(self, predicate: F) -> bool
pub fn any<F>(self, predicate: F) -> bool
Tests if at least one element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for at least one element.
Returns false
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).any(|&a, &b| a == b));
assert!(!Zip::from(&a).and(&b).any(|&a, &b| a - 1 == b));
sourcepub fn and<P>(self, p: P) -> Zip<(P1, P2, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
pub fn and<P>(self, p: P) -> Zip<(P1, P2, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
Include the producer p
in the Zip.
Panics if p
’s shape doesn’t match the Zip’s exactly.
sourcepub fn and_broadcast<'a, P, D2, Elem>(
self,
p: P
) -> Zip<(P1, P2, ArrayBase<ViewRepr<&'a Elem>, D>), D>
pub fn and_broadcast<'a, P, D2, Elem>( self, p: P ) -> Zip<(P1, P2, ArrayBase<ViewRepr<&'a Elem>, D>), D>
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.
sourcepub fn map_collect<R>(
self,
f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item) -> R
) -> ArrayBase<OwnedRepr<R>, D>
pub fn map_collect<R>( self, f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item) -> R ) -> ArrayBase<OwnedRepr<R>, D>
Map and collect the results into a new array, which has the same size as the inputs.
If all inputs are c- or f-order respectively, that is preserved in the output.
sourcepub fn map_assign_into<R, Q>(
self,
into: Q,
f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item) -> R
)
pub fn map_assign_into<R, Q>( self, into: Q, f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item) -> R )
Map and assign the results into the producer into
, which should have the same
size as the other inputs.
The producer should have assignable items as dictated by the AssignElem
trait,
for example &mut R
.
source§impl<D, P1, P2, P3> Zip<(P1, P2, P3), D>
impl<D, P1, P2, P3> Zip<(P1, P2, P3), D>
sourcepub fn for_each<F>(self, function: F)
pub fn for_each<F>(self, function: F)
Apply a function to all elements of the input arrays, visiting elements in lock step.
sourcepub fn fold<F, Acc>(self, acc: Acc, function: F) -> Accwhere
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> Acc,
pub fn fold<F, Acc>(self, acc: Acc, function: F) -> Accwhere
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> Acc,
Apply a fold function to all elements of the input arrays, visiting elements in lock step.
§Example
The expression tr(AᵀB)
can be more efficiently computed as
the equivalent expression ∑ᵢⱼ(A∘B)ᵢⱼ
(i.e. the sum of the
elements of the entry-wise product). It would be possible to
evaluate this expression by first computing the entry-wise
product, A∘B
, and then computing the elementwise sum of that
product, but it’s possible to do this in a single loop (and
avoid an extra heap allocation if A
and B
can’t be
consumed) by using Zip
:
use ndarray::{array, Zip};
let a = array![[1, 5], [3, 7]];
let b = array![[2, 4], [8, 6]];
// Without using `Zip`. This involves two loops and an extra
// heap allocation for the result of `&a * &b`.
let sum_prod_nonzip = (&a * &b).sum();
// Using `Zip`. This is a single loop without any heap allocations.
let sum_prod_zip = Zip::from(&a).and(&b).fold(0, |acc, a, b| acc + a * b);
assert_eq!(sum_prod_nonzip, sum_prod_zip);
sourcepub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>where
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> FoldWhile<Acc>,
pub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>where
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> FoldWhile<Acc>,
Apply a fold function to the input arrays while the return
value is FoldWhile::Continue
, visiting elements in lock step.
sourcepub fn all<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> bool,
pub fn all<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> bool,
Tests if every element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for all elements.
Returns true
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).all(|&a, &b| a * a == b));
sourcepub fn any<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> bool,
pub fn any<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> bool,
Tests if at least one element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for at least one element.
Returns false
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).any(|&a, &b| a == b));
assert!(!Zip::from(&a).and(&b).any(|&a, &b| a - 1 == b));
sourcepub fn and<P>(self, p: P) -> Zip<(P1, P2, P3, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
pub fn and<P>(self, p: P) -> Zip<(P1, P2, P3, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
Include the producer p
in the Zip.
Panics if p
’s shape doesn’t match the Zip’s exactly.
sourcepub fn and_broadcast<'a, P, D2, Elem>(
self,
p: P
) -> Zip<(P1, P2, P3, ArrayBase<ViewRepr<&'a Elem>, D>), D>
pub fn and_broadcast<'a, P, D2, Elem>( self, p: P ) -> Zip<(P1, P2, P3, ArrayBase<ViewRepr<&'a Elem>, D>), D>
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.
sourcepub fn map_collect<R>(
self,
f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> R
) -> ArrayBase<OwnedRepr<R>, D>
pub fn map_collect<R>( self, f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> R ) -> ArrayBase<OwnedRepr<R>, D>
Map and collect the results into a new array, which has the same size as the inputs.
If all inputs are c- or f-order respectively, that is preserved in the output.
sourcepub fn map_assign_into<R, Q>(
self,
into: Q,
f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> R
)
pub fn map_assign_into<R, Q>( self, into: Q, f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item) -> R )
Map and assign the results into the producer into
, which should have the same
size as the other inputs.
The producer should have assignable items as dictated by the AssignElem
trait,
for example &mut R
.
sourcepub fn split(self) -> (Zip<(P1, P2, P3), D>, Zip<(P1, P2, P3), D>)
pub fn split(self) -> (Zip<(P1, P2, P3), D>, Zip<(P1, P2, P3), D>)
Split the Zip
evenly in two.
It will be split in the way that best preserves element locality.
source§impl<D, P1, P2, P3, P4> Zip<(P1, P2, P3, P4), D>where
D: Dimension,
P1: NdProducer<Dim = D>,
P2: NdProducer<Dim = D>,
P3: NdProducer<Dim = D>,
P4: NdProducer<Dim = D>,
impl<D, P1, P2, P3, P4> Zip<(P1, P2, P3, P4), D>where
D: Dimension,
P1: NdProducer<Dim = D>,
P2: NdProducer<Dim = D>,
P3: NdProducer<Dim = D>,
P4: NdProducer<Dim = D>,
sourcepub fn for_each<F>(self, function: F)where
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item),
pub fn for_each<F>(self, function: F)where
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item),
Apply a function to all elements of the input arrays, visiting elements in lock step.
sourcepub fn fold<F, Acc>(self, acc: Acc, function: F) -> Accwhere
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> Acc,
pub fn fold<F, Acc>(self, acc: Acc, function: F) -> Accwhere
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> Acc,
Apply a fold function to all elements of the input arrays, visiting elements in lock step.
§Example
The expression tr(AᵀB)
can be more efficiently computed as
the equivalent expression ∑ᵢⱼ(A∘B)ᵢⱼ
(i.e. the sum of the
elements of the entry-wise product). It would be possible to
evaluate this expression by first computing the entry-wise
product, A∘B
, and then computing the elementwise sum of that
product, but it’s possible to do this in a single loop (and
avoid an extra heap allocation if A
and B
can’t be
consumed) by using Zip
:
use ndarray::{array, Zip};
let a = array![[1, 5], [3, 7]];
let b = array![[2, 4], [8, 6]];
// Without using `Zip`. This involves two loops and an extra
// heap allocation for the result of `&a * &b`.
let sum_prod_nonzip = (&a * &b).sum();
// Using `Zip`. This is a single loop without any heap allocations.
let sum_prod_zip = Zip::from(&a).and(&b).fold(0, |acc, a, b| acc + a * b);
assert_eq!(sum_prod_nonzip, sum_prod_zip);
sourcepub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>where
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> FoldWhile<Acc>,
pub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>where
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> FoldWhile<Acc>,
Apply a fold function to the input arrays while the return
value is FoldWhile::Continue
, visiting elements in lock step.
sourcepub fn all<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> bool,
pub fn all<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> bool,
Tests if every element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for all elements.
Returns true
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).all(|&a, &b| a * a == b));
sourcepub fn any<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> bool,
pub fn any<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> bool,
Tests if at least one element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for at least one element.
Returns false
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).any(|&a, &b| a == b));
assert!(!Zip::from(&a).and(&b).any(|&a, &b| a - 1 == b));
sourcepub fn and<P>(
self,
p: P
) -> Zip<(P1, P2, P3, P4, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
pub fn and<P>(
self,
p: P
) -> Zip<(P1, P2, P3, P4, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
Include the producer p
in the Zip.
Panics if p
’s shape doesn’t match the Zip’s exactly.
sourcepub fn and_broadcast<'a, P, D2, Elem>(
self,
p: P
) -> Zip<(P1, P2, P3, P4, ArrayBase<ViewRepr<&'a Elem>, D>), D>
pub fn and_broadcast<'a, P, D2, Elem>( self, p: P ) -> Zip<(P1, P2, P3, P4, ArrayBase<ViewRepr<&'a Elem>, D>), D>
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.
sourcepub fn map_collect<R>(
self,
f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> R
) -> ArrayBase<OwnedRepr<R>, D>
pub fn map_collect<R>( self, f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> R ) -> ArrayBase<OwnedRepr<R>, D>
Map and collect the results into a new array, which has the same size as the inputs.
If all inputs are c- or f-order respectively, that is preserved in the output.
sourcepub fn map_assign_into<R, Q>(
self,
into: Q,
f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> R
)
pub fn map_assign_into<R, Q>( self, into: Q, f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item) -> R )
Map and assign the results into the producer into
, which should have the same
size as the other inputs.
The producer should have assignable items as dictated by the AssignElem
trait,
for example &mut R
.
sourcepub fn split(self) -> (Zip<(P1, P2, P3, P4), D>, Zip<(P1, P2, P3, P4), D>)
pub fn split(self) -> (Zip<(P1, P2, P3, P4), D>, Zip<(P1, P2, P3, P4), D>)
Split the Zip
evenly in two.
It will be split in the way that best preserves element locality.
source§impl<D, P1, P2, P3, P4, P5> Zip<(P1, P2, P3, P4, P5), D>where
D: Dimension,
P1: NdProducer<Dim = D>,
P2: NdProducer<Dim = D>,
P3: NdProducer<Dim = D>,
P4: NdProducer<Dim = D>,
P5: NdProducer<Dim = D>,
impl<D, P1, P2, P3, P4, P5> Zip<(P1, P2, P3, P4, P5), D>where
D: Dimension,
P1: NdProducer<Dim = D>,
P2: NdProducer<Dim = D>,
P3: NdProducer<Dim = D>,
P4: NdProducer<Dim = D>,
P5: NdProducer<Dim = D>,
sourcepub fn for_each<F>(self, function: F)where
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item),
pub fn for_each<F>(self, function: F)where
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item),
Apply a function to all elements of the input arrays, visiting elements in lock step.
sourcepub fn fold<F, Acc>(self, acc: Acc, function: F) -> Accwhere
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> Acc,
pub fn fold<F, Acc>(self, acc: Acc, function: F) -> Accwhere
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> Acc,
Apply a fold function to all elements of the input arrays, visiting elements in lock step.
§Example
The expression tr(AᵀB)
can be more efficiently computed as
the equivalent expression ∑ᵢⱼ(A∘B)ᵢⱼ
(i.e. the sum of the
elements of the entry-wise product). It would be possible to
evaluate this expression by first computing the entry-wise
product, A∘B
, and then computing the elementwise sum of that
product, but it’s possible to do this in a single loop (and
avoid an extra heap allocation if A
and B
can’t be
consumed) by using Zip
:
use ndarray::{array, Zip};
let a = array![[1, 5], [3, 7]];
let b = array![[2, 4], [8, 6]];
// Without using `Zip`. This involves two loops and an extra
// heap allocation for the result of `&a * &b`.
let sum_prod_nonzip = (&a * &b).sum();
// Using `Zip`. This is a single loop without any heap allocations.
let sum_prod_zip = Zip::from(&a).and(&b).fold(0, |acc, a, b| acc + a * b);
assert_eq!(sum_prod_nonzip, sum_prod_zip);
sourcepub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>where
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> FoldWhile<Acc>,
pub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>where
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> FoldWhile<Acc>,
Apply a fold function to the input arrays while the return
value is FoldWhile::Continue
, visiting elements in lock step.
sourcepub fn all<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> bool,
pub fn all<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> bool,
Tests if every element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for all elements.
Returns true
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).all(|&a, &b| a * a == b));
sourcepub fn any<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> bool,
pub fn any<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> bool,
Tests if at least one element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for at least one element.
Returns false
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).any(|&a, &b| a == b));
assert!(!Zip::from(&a).and(&b).any(|&a, &b| a - 1 == b));
sourcepub fn and<P>(
self,
p: P
) -> Zip<(P1, P2, P3, P4, P5, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
pub fn and<P>(
self,
p: P
) -> Zip<(P1, P2, P3, P4, P5, <P as IntoNdProducer>::Output), D>where
P: IntoNdProducer<Dim = D>,
Include the producer p
in the Zip.
Panics if p
’s shape doesn’t match the Zip’s exactly.
sourcepub fn and_broadcast<'a, P, D2, Elem>(
self,
p: P
) -> Zip<(P1, P2, P3, P4, P5, ArrayBase<ViewRepr<&'a Elem>, D>), D>
pub fn and_broadcast<'a, P, D2, Elem>( self, p: P ) -> Zip<(P1, P2, P3, P4, P5, ArrayBase<ViewRepr<&'a Elem>, D>), D>
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.
sourcepub fn map_collect<R>(
self,
f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> R
) -> ArrayBase<OwnedRepr<R>, D>
pub fn map_collect<R>( self, f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> R ) -> ArrayBase<OwnedRepr<R>, D>
Map and collect the results into a new array, which has the same size as the inputs.
If all inputs are c- or f-order respectively, that is preserved in the output.
sourcepub fn map_assign_into<R, Q>(
self,
into: Q,
f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> R
)
pub fn map_assign_into<R, Q>( self, into: Q, f: impl FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item) -> R )
Map and assign the results into the producer into
, which should have the same
size as the other inputs.
The producer should have assignable items as dictated by the AssignElem
trait,
for example &mut R
.
sourcepub fn split(
self
) -> (Zip<(P1, P2, P3, P4, P5), D>, Zip<(P1, P2, P3, P4, P5), D>)
pub fn split( self ) -> (Zip<(P1, P2, P3, P4, P5), D>, Zip<(P1, P2, P3, P4, P5), D>)
Split the Zip
evenly in two.
It will be split in the way that best preserves element locality.
source§impl<D, P1, P2, P3, P4, P5, P6> Zip<(P1, P2, P3, P4, P5, P6), D>where
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>,
impl<D, P1, P2, P3, P4, P5, P6> Zip<(P1, P2, P3, P4, P5, P6), D>where
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>,
sourcepub fn for_each<F>(self, function: F)where
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item),
pub fn for_each<F>(self, function: F)where
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item),
Apply a function to all elements of the input arrays, visiting elements in lock step.
sourcepub fn fold<F, Acc>(self, acc: Acc, function: F) -> Accwhere
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item) -> Acc,
pub fn fold<F, Acc>(self, acc: Acc, function: F) -> Accwhere
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item) -> Acc,
Apply a fold function to all elements of the input arrays, visiting elements in lock step.
§Example
The expression tr(AᵀB)
can be more efficiently computed as
the equivalent expression ∑ᵢⱼ(A∘B)ᵢⱼ
(i.e. the sum of the
elements of the entry-wise product). It would be possible to
evaluate this expression by first computing the entry-wise
product, A∘B
, and then computing the elementwise sum of that
product, but it’s possible to do this in a single loop (and
avoid an extra heap allocation if A
and B
can’t be
consumed) by using Zip
:
use ndarray::{array, Zip};
let a = array![[1, 5], [3, 7]];
let b = array![[2, 4], [8, 6]];
// Without using `Zip`. This involves two loops and an extra
// heap allocation for the result of `&a * &b`.
let sum_prod_nonzip = (&a * &b).sum();
// Using `Zip`. This is a single loop without any heap allocations.
let sum_prod_zip = Zip::from(&a).and(&b).fold(0, |acc, a, b| acc + a * b);
assert_eq!(sum_prod_nonzip, sum_prod_zip);
sourcepub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>where
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item) -> FoldWhile<Acc>,
pub fn fold_while<F, Acc>(self, acc: Acc, function: F) -> FoldWhile<Acc>where
F: FnMut(Acc, <P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item) -> FoldWhile<Acc>,
Apply a fold function to the input arrays while the return
value is FoldWhile::Continue
, visiting elements in lock step.
sourcepub fn all<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item) -> bool,
pub fn all<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item) -> bool,
Tests if every element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for all elements.
Returns true
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).all(|&a, &b| a * a == b));
sourcepub fn any<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item) -> bool,
pub fn any<F>(self, predicate: F) -> boolwhere
F: FnMut(<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item) -> bool,
Tests if at least one element of the iterator matches a predicate.
Returns true
if predicate
evaluates to true
for at least one element.
Returns false
if the input arrays are empty.
Example:
use ndarray::{array, Zip};
let a = array![1, 2, 3];
let b = array![1, 4, 9];
assert!(Zip::from(&a).and(&b).any(|&a, &b| a == b));
assert!(!Zip::from(&a).and(&b).any(|&a, &b| a - 1 == b));
sourcepub fn split(
self
) -> (Zip<(P1, P2, P3, P4, P5, P6), D>, Zip<(P1, P2, P3, P4, P5, P6), D>)
pub fn split( self ) -> (Zip<(P1, P2, P3, P4, P5, P6), D>, Zip<(P1, P2, P3, P4, P5, P6), D>)
Split the Zip
evenly in two.
It will be split in the way that best preserves element locality.
Trait Implementations§
Auto Trait Implementations§
impl<Parts, D> Freeze for Zip<Parts, D>
impl<Parts, D> RefUnwindSafe for Zip<Parts, D>where
Parts: RefUnwindSafe,
D: RefUnwindSafe,
impl<Parts, D> Send for Zip<Parts, D>
impl<Parts, D> Sync for Zip<Parts, D>
impl<Parts, D> Unpin for Zip<Parts, D>
impl<Parts, D> UnwindSafe for Zip<Parts, D>where
Parts: UnwindSafe,
D: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CheckedAs for T
impl<T> CheckedAs for T
source§fn checked_as<Dst>(self) -> Option<Dst>where
T: CheckedCast<Dst>,
fn checked_as<Dst>(self) -> Option<Dst>where
T: CheckedCast<Dst>,
source§impl<Src, Dst> CheckedCastFrom<Src> for Dstwhere
Src: CheckedCast<Dst>,
impl<Src, Dst> CheckedCastFrom<Src> for Dstwhere
Src: CheckedCast<Dst>,
source§fn checked_cast_from(src: Src) -> Option<Dst>
fn checked_cast_from(src: Src) -> Option<Dst>
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T
in a tonic::Request