Struct Fill

pub struct Fill<T> { /* private fields */ }

Expression that repeats an element by cloning.

Trait Implementations

impl<T, U, I: Apply<U>> Add<I> for Fill<T>

where T: Add<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the + operator.

fn add(self, rhs: I) -> Self::Output

Performs the + operation.

impl<T, U, I: Apply<U>> BitAnd<I> for Fill<T>

where T: BitAnd<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the & operator.

fn bitand(self, rhs: I) -> Self::Output

Performs the & operation.

impl<T, U, I: Apply<U>> BitOr<I> for Fill<T>

where T: BitOr<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the | operator.

fn bitor(self, rhs: I) -> Self::Output

Performs the | operation.

impl<T, U, I: Apply<U>> BitXor<I> for Fill<T>

where T: BitXor<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: I) -> Self::Output

Performs the ^ operation.

impl<T: Clone> Clone for Fill<T>

fn clone(&self) -> Fill<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Fill<T>

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

Formats the value using the given formatter.

impl<T, U, I: Apply<U>> Div<I> for Fill<T>

where T: Div<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the / operator.

fn div(self, rhs: I) -> Self::Output

Performs the / operation.

impl<T: Clone> Expression for Fill<T>

const IS_REPEATABLE: bool = true

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

type Shape = ()

Array shape type.

fn shape(&self) -> &()

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<T: Clone> IntoIterator for Fill<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = Iter<Fill<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<Self>

Creates an iterator from a value.

impl<T, U, I: Apply<U>> Mul<I> for Fill<T>

where T: Mul<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the * operator.

fn mul(self, rhs: I) -> Self::Output

Performs the * operation.

impl<T, U> Neg for Fill<T>

where T: Neg<Output = U> + Clone,

type Output = <Fill<T> as Apply<U>>::Output<fn(T) -> U>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, U> Not for Fill<T>

where T: Not<Output = U> + Clone,

type Output = <Fill<T> as Apply<U>>::Output<fn(T) -> U>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, U, I: Apply<U>> Rem<I> for Fill<T>

where T: Rem<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the % operator.

fn rem(self, rhs: I) -> Self::Output

Performs the % operation.

impl<T, U, I: Apply<U>> Shl<I> for Fill<T>

where T: Shl<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the << operator.

fn shl(self, rhs: I) -> Self::Output

Performs the << operation.

impl<T, U, I: Apply<U>> Shr<I> for Fill<T>

where T: Shr<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the >> operator.

fn shr(self, rhs: I) -> Self::Output

Performs the >> operation.

impl<T, U, I: Apply<U>> Sub<I> for Fill<T>

where T: Sub<I::Item, Output = U> + Clone,

type Output = <I as Apply<U>>::ZippedWith<Fill<T>, fn((<I as IntoIterator>::Item, T)) -> U>

The resulting type after applying the - operator.

fn sub(self, rhs: I) -> Self::Output

Performs the - operation.