Create a new Zip from the input array or other producer p.

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

Create a new Zip with an index producer and the producer p.

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

Note: Indexed zip has overhead.

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);

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));

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));

Include the producer p in the Zip.

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

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.

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.

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.

Split the Zip evenly in two.

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

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);

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));

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));

Include the producer p in the Zip.

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

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.

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.

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.

Split the Zip evenly in two.

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

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);

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));

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));

Include the producer p in the Zip.

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

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.

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.

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.

Split the Zip evenly in two.

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

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);

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));

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));

Include the producer p in the Zip.

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

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.

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.

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.

Split the Zip evenly in two.

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

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);

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));

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));

Include the producer p in the Zip.

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

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.

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.

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.

Split the Zip evenly in two.

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

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);

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));

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));

Split the Zip evenly in two.

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

The par_for_each method for Zip.

This is a shorthand for using .into_par_iter().for_each() on Zip.

Requires crate feature rayon.

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.

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.

Parallel version of fold.

Splits the producer in multiple tasks which each accumulate a single value using the fold closure. Those tasks are executed in parallel and their results are then combined to a single value using the reduce closure.

The identity closure provides the initial values for each of the tasks and for the final reduction.

This is a shorthand for calling self.into_par_iter().fold(...).reduce(...).

Note that it is often more efficient to parallelize not per-element but rather based on larger chunks of an array like generalized rows and operating on each chunk using a sequential variant of the accumulation. For example, sum each row sequentially and in parallel, taking advantage of locality and vectorization within each task, and then reduce their sums to the sum of the matrix.

Also note that the splitting of the producer into multiple tasks is not deterministic which needs to be considered when the accuracy of such an operation is analyzed.

§Examples

use ndarray::{Array, Zip};

let a = Array::<usize, _>::ones((128, 1024));
let b = Array::<usize, _>::ones(128);

let weighted_sum = Zip::from(a.rows()).and(&b).par_fold(
    || 0,
    |sum, row, factor| sum + row.sum() * factor,
    |sum, other_sum| sum + other_sum,
);

assert_eq!(weighted_sum, a.len());

The par_for_each method for Zip.

This is a shorthand for using .into_par_iter().for_each() on Zip.

Requires crate feature rayon.

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.

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.

Parallel version of fold.

Splits the producer in multiple tasks which each accumulate a single value using the fold closure. Those tasks are executed in parallel and their results are then combined to a single value using the reduce closure.

The identity closure provides the initial values for each of the tasks and for the final reduction.

This is a shorthand for calling self.into_par_iter().fold(...).reduce(...).

Note that it is often more efficient to parallelize not per-element but rather based on larger chunks of an array like generalized rows and operating on each chunk using a sequential variant of the accumulation. For example, sum each row sequentially and in parallel, taking advantage of locality and vectorization within each task, and then reduce their sums to the sum of the matrix.

Also note that the splitting of the producer into multiple tasks is not deterministic which needs to be considered when the accuracy of such an operation is analyzed.

§Examples

use ndarray::{Array, Zip};

let a = Array::<usize, _>::ones((128, 1024));
let b = Array::<usize, _>::ones(128);

let weighted_sum = Zip::from(a.rows()).and(&b).par_fold(
    || 0,
    |sum, row, factor| sum + row.sum() * factor,
    |sum, other_sum| sum + other_sum,
);

assert_eq!(weighted_sum, a.len());

The par_for_each method for Zip.

This is a shorthand for using .into_par_iter().for_each() on Zip.

Requires crate feature rayon.

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.

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.

Parallel version of fold.

Splits the producer in multiple tasks which each accumulate a single value using the fold closure. Those tasks are executed in parallel and their results are then combined to a single value using the reduce closure.

The identity closure provides the initial values for each of the tasks and for the final reduction.

This is a shorthand for calling self.into_par_iter().fold(...).reduce(...).

Note that it is often more efficient to parallelize not per-element but rather based on larger chunks of an array like generalized rows and operating on each chunk using a sequential variant of the accumulation. For example, sum each row sequentially and in parallel, taking advantage of locality and vectorization within each task, and then reduce their sums to the sum of the matrix.

Also note that the splitting of the producer into multiple tasks is not deterministic which needs to be considered when the accuracy of such an operation is analyzed.

§Examples

use ndarray::{Array, Zip};

let a = Array::<usize, _>::ones((128, 1024));
let b = Array::<usize, _>::ones(128);

let weighted_sum = Zip::from(a.rows()).and(&b).par_fold(
    || 0,
    |sum, row, factor| sum + row.sum() * factor,
    |sum, other_sum| sum + other_sum,
);

assert_eq!(weighted_sum, a.len());

The par_for_each method for Zip.

This is a shorthand for using .into_par_iter().for_each() on Zip.

Requires crate feature rayon.

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.

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.

Parallel version of fold.

Splits the producer in multiple tasks which each accumulate a single value using the fold closure. Those tasks are executed in parallel and their results are then combined to a single value using the reduce closure.

The identity closure provides the initial values for each of the tasks and for the final reduction.

This is a shorthand for calling self.into_par_iter().fold(...).reduce(...).

Note that it is often more efficient to parallelize not per-element but rather based on larger chunks of an array like generalized rows and operating on each chunk using a sequential variant of the accumulation. For example, sum each row sequentially and in parallel, taking advantage of locality and vectorization within each task, and then reduce their sums to the sum of the matrix.

Also note that the splitting of the producer into multiple tasks is not deterministic which needs to be considered when the accuracy of such an operation is analyzed.

§Examples

use ndarray::{Array, Zip};

let a = Array::<usize, _>::ones((128, 1024));
let b = Array::<usize, _>::ones(128);

let weighted_sum = Zip::from(a.rows()).and(&b).par_fold(
    || 0,
    |sum, row, factor| sum + row.sum() * factor,
    |sum, other_sum| sum + other_sum,
);

assert_eq!(weighted_sum, a.len());

The par_for_each method for Zip.

This is a shorthand for using .into_par_iter().for_each() on Zip.

Requires crate feature rayon.

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.

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.

Parallel version of fold.

Splits the producer in multiple tasks which each accumulate a single value using the fold closure. Those tasks are executed in parallel and their results are then combined to a single value using the reduce closure.

The identity closure provides the initial values for each of the tasks and for the final reduction.

This is a shorthand for calling self.into_par_iter().fold(...).reduce(...).

Note that it is often more efficient to parallelize not per-element but rather based on larger chunks of an array like generalized rows and operating on each chunk using a sequential variant of the accumulation. For example, sum each row sequentially and in parallel, taking advantage of locality and vectorization within each task, and then reduce their sums to the sum of the matrix.

Also note that the splitting of the producer into multiple tasks is not deterministic which needs to be considered when the accuracy of such an operation is analyzed.

§Examples

use ndarray::{Array, Zip};

let a = Array::<usize, _>::ones((128, 1024));
let b = Array::<usize, _>::ones(128);

let weighted_sum = Zip::from(a.rows()).and(&b).par_fold(
    || 0,
    |sum, row, factor| sum + row.sum() * factor,
    |sum, other_sum| sum + other_sum,
);

assert_eq!(weighted_sum, a.len());

The par_for_each method for Zip.

This is a shorthand for using .into_par_iter().for_each() on Zip.

Requires crate feature rayon.