Struct Zip

pub struct Zip<A: Expression, B: Expression> { /* private fields */ }

Expression that gives tuples (x, y) of the elements from each expression.

Trait Implementations

impl<A: Clone + Expression, B: Clone + Expression> Clone for Zip<A, B>

fn clone(&self) -> Zip<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Expression + Debug, B: Expression + Debug> Debug for Zip<A, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Shape, R: Shape, A, B> Expression for Zip<A, B>

where A: Expression<Shape = S>, B: Expression<Shape = R>,

const IS_REPEATABLE: bool

True if the expression can be restarted from the beginning after the last element.

type Shape = <<<S as Shape>::Reverse as Shape>::Merge<<R as Shape>::Reverse> as Shape>::Reverse

Array shape type.

fn shape(&self) -> &Self::Shape

Returns the array shape.

fn cloned<'a, T: 'a + Clone>(self) -> Cloned<Self>

where Self: Expression<Item = &'a T> + Sized,

Creates an expression which clones all of its elements.

fn copied<'a, T: 'a + Copy>(self) -> Copied<Self>

where Self: Expression<Item = &'a T> + Sized,

Creates an expression which copies all of its elements.

fn dim(&self, index: usize) -> usize

Returns the number of elements in the specified dimension.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an expression which gives tuples of the current count and the element.

fn eval(self) -> <Self::Shape as Shape>::Owned<Self::Item>

where Self: Sized,

Evaluates the expression into a new array.

fn eval_into<S: Shape, A: Allocator>( self, tensor: &mut Tensor<Self::Item, S, A>, ) -> &mut Tensor<Self::Item, S, A>

where Self: Sized,

Evaluates the expression with broadcasting and appends to the given array along the first dimension.

fn fold<T, F: FnMut(T, Self::Item) -> T>(self, init: T, f: F) -> T

where Self: Sized,

Folds all elements into an accumulator by applying an operation, and returns the result.

fn for_each<F: FnMut(Self::Item)>(self, f: F)

where Self: Sized,

Calls a closure on each element of the expression.

fn is_empty(&self) -> bool

Returns true if the array contains no elements.

fn len(&self) -> usize

Returns the number of elements in the array.

fn map<T, F: FnMut(Self::Item) -> T>(self, f: F) -> Map<Self, F>

where Self: Sized,

Creates an expression that calls a closure on each element.

fn rank(&self) -> usize

Returns the array rank, i.e. the number of dimensions.

fn zip<I: IntoExpression>(self, other: I) -> Zip<Self, I::IntoExpr>

where Self: Sized,

Creates an expression that gives tuples (x, y) of the elements from each expression.

impl<A: Expression, B: Expression> IntoIterator for Zip<A, B>

type Item = (<A as IntoIterator>::Item, <B as IntoIterator>::Item)

The type of the elements being iterated over.

type IntoIter = Iter<Zip<A, B>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.