Struct ViewMut 

pub struct ViewMut<'a, T, S: Shape = DynRank, L: Layout = Dense> { /* private fields */ }

Mutable multidimensional array view.

Implementations

impl<'a, T, S: Shape, L: Layout> ViewMut<'a, T, S, L>

pub fn into_at(self, index: usize) -> ViewMut<'a, T, S::Tail, L>

Converts the array view into a new array view indexing the first dimension.

Panics

Panics if the index is out of bounds, or if the rank is not at least 1.

pub fn into_axis_at<A: Axis>( self, axis: A, index: usize, ) -> ViewMut<'a, T, A::Remove<S>, Split<A, S, L>>

Converts the array view into a new array view indexing the specified dimension.

If the dimension to be indexed is know at compile time, the resulting array shape will maintain constant-sized dimensions. Furthermore, if it is the first dimension the resulting array view has the same layout as the input.

Panics

Panics if the dimension or the index is out of bounds.

pub fn into_col(self, index: usize) -> ViewMut<'a, T, (S::Head,), Strided>

Converts the array view into a new array view for the specified column.

Panics

Panics if the rank is not equal to 2, or if the index is out of bounds.

pub fn into_diag(self, index: isize) -> ViewMut<'a, T, (Dyn,), Strided>

Converts the array view into a new array view for the given diagonal, where index > 0 is above and index < 0 is below the main diagonal.

Panics

Panics if the rank is not equal to 2, or if the absolute index is larger than the number of columns or rows.

pub fn into_dyn(self) -> ViewMut<'a, T, DynRank, L>

Converts the array view into an array view with dynamic rank.

pub fn into_flat(self) -> ViewMut<'a, T, (Dyn,), L>

Converts the array view into a one-dimensional array view.

Panics

Panics if the array layout is not uniformly strided.

pub fn into_mapping<R: Shape, K: Layout>(self) -> ViewMut<'a, T, R, K>

Converts the array view into a remapped array view.

Panics

Panics if the shape is not matching static rank or constant-sized dimensions, or if the memory layout is not compatible with the new array layout.

pub fn into_permuted<I: IntoShape<IntoShape: Permutation>>( self, perm: I, ) -> ViewMut<'a, T, <I::IntoShape as Permutation>::Shape<S>, <I::IntoShape as Permutation>::Layout<L>>

Converts the array view into a new array view with the dimensions permuted.

If the permutation is an identity permutation and known at compile time, the resulting array view has the same layout as the input. For example, permuting with (Const::<0>, Const::<1>) will maintain the layout while permuting with [0, 1] gives strided layout.

Panics

Panics if the permutation is not valid.

pub fn into_reordered( self, ) -> ViewMut<'a, T, S::Reverse, <S::Tail as Shape>::Layout<L>>

👎Deprecated

Converts the array view into a reordered array view.

This method is deprecated, use into_transposed instead.

pub fn into_row( self, index: usize, ) -> ViewMut<'a, T, (<S::Tail as Shape>::Head,), L>

Converts the array view into a new array view for the specified row.

Panics

Panics if the rank is not equal to 2, or if the index is out of bounds.

pub fn into_shape<I: IntoShape>( self, shape: I, ) -> ViewMut<'a, T, I::IntoShape, L>

Converts the array view into a reshaped array view.

At most one dimension can have dynamic size usize::MAX, and is then inferred from the other dimensions and the array length.

Examples

use mdarray::view;

let v = view![[1, 2, 3], [4, 5, 6]];

assert_eq!(v.into_shape([!0, 2]), view![[1, 2], [3, 4], [5, 6]]);

Panics

Panics if the array length is changed, or if the memory layout is not compatible.

pub fn into_split_at( self, mid: usize, ) -> (ViewMut<'a, T, Resize<Const<0>, S>, L>, ViewMut<'a, T, Resize<Const<0>, S>, L>)

Divides the array view into two at an index along the first dimension.

Panics

Panics if the split point is larger than the number of elements in that dimension, or if the rank is not at least 1.

pub fn into_split_axis_at<A: Axis>( self, axis: A, mid: usize, ) -> (ViewMut<'a, T, Resize<A, S>, Split<A, S, L>>, ViewMut<'a, T, Resize<A, S>, Split<A, S, L>>)

Divides the array view into two at an index along the specified dimension.

If the dimension to be divided is know at compile time, the resulting array shape will maintain constant-sized dimensions. Furthermore, if it is the first dimension the resulting array views have the same layout as the input.

Panics

Panics if the split point is larger than the number of elements in that dimension, or if the dimension is out of bounds.

pub fn into_transposed( self, ) -> ViewMut<'a, T, S::Reverse, <S::Tail as Shape>::Layout<L>>

Converts the array view into a transposed array view, where the dimensions are reversed.

pub unsafe fn new_unchecked(ptr: *mut T, mapping: L::Mapping<S>) -> Self

Creates an array view from a raw pointer and layout.

Safety

The pointer must be non-null and a valid array view for the given layout.

impl<'a, T, X: Dim, L: Layout> ViewMut<'a, T, (X,), L>

pub fn into_view<A: DimIndex>( self, a: A, ) -> ViewMut<'a, T, <(A,) as ViewIndex>::Shape<(X,)>, <(A,) as ViewIndex>::Layout<L>>

Converts the array view into a new array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<'a, T, X: Dim, Y: Dim, L: Layout> ViewMut<'a, T, (X, Y), L>

pub fn into_view<A: DimIndex, B: DimIndex>( self, a: A, b: B, ) -> ViewMut<'a, T, <(A, B) as ViewIndex>::Shape<(X, Y)>, <(A, B) as ViewIndex>::Layout<L>>

Converts the array view into a new array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<'a, T, X: Dim, Y: Dim, Z: Dim, L: Layout> ViewMut<'a, T, (X, Y, Z), L>

pub fn into_view<A: DimIndex, B: DimIndex, C: DimIndex>( self, a: A, b: B, c: C, ) -> ViewMut<'a, T, <(A, B, C) as ViewIndex>::Shape<(X, Y, Z)>, <(A, B, C) as ViewIndex>::Layout<L>>

Converts the array view into a new array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<'a, T, X: Dim, Y: Dim, Z: Dim, W: Dim, L: Layout> ViewMut<'a, T, (X, Y, Z, W), L>

pub fn into_view<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex>( self, a: A, b: B, c: C, d: D, ) -> ViewMut<'a, T, <(A, B, C, D) as ViewIndex>::Shape<(X, Y, Z, W)>, <(A, B, C, D) as ViewIndex>::Layout<L>>

Converts the array view into a new array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<'a, T, X: Dim, Y: Dim, Z: Dim, W: Dim, U: Dim, L: Layout> ViewMut<'a, T, (X, Y, Z, W, U), L>

pub fn into_view<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex, E: DimIndex>( self, a: A, b: B, c: C, d: D, e: E, ) -> ViewMut<'a, T, <(A, B, C, D, E) as ViewIndex>::Shape<(X, Y, Z, W, U)>, <(A, B, C, D, E) as ViewIndex>::Layout<L>>

Converts the array view into a new array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<'a, T, X: Dim, Y: Dim, Z: Dim, W: Dim, U: Dim, V: Dim, L: Layout> ViewMut<'a, T, (X, Y, Z, W, U, V), L>

pub fn into_view<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex, E: DimIndex, F: DimIndex>( self, a: A, b: B, c: C, d: D, e: E, f: F, ) -> ViewMut<'a, T, <(A, B, C, D, E, F) as ViewIndex>::Shape<(X, Y, Z, W, U, V)>, <(A, B, C, D, E, F) as ViewIndex>::Layout<L>>

Converts the array view into a new array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

Methods from Deref<Target = Slice<T, S, L>>

pub fn as_mut_ptr(&mut self) -> *mut T

Returns a mutable pointer to the array buffer.

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to the array buffer.

pub fn assign<I: IntoExpression<Item: IntoCloned<T>>>(&mut self, expr: I)

Assigns an expression to the array slice with broadcasting, cloning elements if needed.

Panics

Panics if the expression cannot be broadcast to the shape of the array slice.

pub fn at(&self, index: usize) -> View<'_, T, S::Tail, L>

Returns an array view after indexing the first dimension.

Panics

Panics if the index is out of bounds, or if the rank is not at least 1.

pub fn at_mut(&mut self, index: usize) -> ViewMut<'_, T, S::Tail, L>

Returns a mutable array view after indexing the first dimension.

Panics

Panics if the index is out of bounds, or if the rank is not at least 1.

pub fn axis_at<A: Axis>( &self, axis: A, index: usize, ) -> View<'_, T, A::Remove<S>, Split<A, S, L>>

Returns an array view after indexing the specified dimension.

If the dimension to be indexed is know at compile time, the resulting array shape will maintain constant-sized dimensions. Furthermore, if it is the first dimension the resulting array view has the same layout as the input.

Panics

Panics if the dimension or the index is out of bounds.

pub fn axis_at_mut<A: Axis>( &mut self, axis: A, index: usize, ) -> ViewMut<'_, T, A::Remove<S>, Split<A, S, L>>

Returns a mutable array view after indexing the specified dimension.

If the dimension to be indexed is know at compile time, the resulting array shape will maintain constant-sized dimensions. Furthermore, if it is the first dimension the resulting array view has the same layout as the input.

Panics

Panics if the dimension or the index is out of bounds.

pub fn axis_expr<A: Axis>(&self, axis: A) -> AxisExpr<'_, T, S, L, A>

Returns an expression that gives array views iterating over the specified dimension.

If the dimension to be iterated over is know at compile time, the resulting array shape will maintain constant-sized dimensions. Furthermore, if it is the first dimension the resulting array views have the same layout as the input.

Panics

Panics if the dimension is out of bounds.

pub fn axis_expr_mut<A: Axis>(&mut self, axis: A) -> AxisExprMut<'_, T, S, L, A>

Returns a mutable expression that gives array views iterating over the specified dimension.

If the dimension to be iterated over is know at compile time, the resulting array shape will maintain constant-sized dimensions. Furthermore, if it is the first dimension the resulting array views have the same layout as the input.

Panics

Panics if the dimension is out of bounds.

pub fn col(&self, index: usize) -> View<'_, T, (S::Head,), Strided>

Returns an array view for the specified column.

Panics

Panics if the rank is not equal to 2, or if the index is out of bounds.

pub fn col_mut(&mut self, index: usize) -> ViewMut<'_, T, (S::Head,), Strided>

Returns a mutable array view for the specified column.

Panics

Panics if the rank is not equal to 2, or if the index is out of bounds.

pub fn cols(&self) -> Lanes<'_, T, S, L, Cols>

Returns an expression that gives column views iterating over the other dimensions.

Panics

Panics if the rank is not at least 2.

pub fn cols_mut(&mut self) -> LanesMut<'_, T, S, L, Cols>

Returns a mutable expression that gives column views iterating over the other dimensions.

Panics

Panics if the rank is not at least 2.

pub fn contains(&self, x: &T) -> bool

where T: PartialEq,

Returns true if the array slice contains an element with the given value.

pub fn diag(&self, index: isize) -> View<'_, T, (Dyn,), Strided>

Returns an array view for the given diagonal of the array slice, where index > 0 is above and index < 0 is below the main diagonal.

Panics

Panics if the rank is not equal to 2, or if the absolute index is larger than the number of columns or rows.

pub fn diag_mut(&mut self, index: isize) -> ViewMut<'_, T, (Dyn,), Strided>

Returns a mutable array view for the given diagonal of the array slice, where index > 0 is above and index < 0 is below the main diagonal.

Panics

Panics if the rank is not equal to 2, or if the absolute index is larger than the number of columns or rows.

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

Returns the number of elements in the specified dimension.

Panics

Panics if the dimension is out of bounds.

pub fn expr(&self) -> View<'_, T, S, L>

Returns an expression over the array slice.

pub fn expr_mut(&mut self) -> ViewMut<'_, T, S, L>

Returns a mutable expression over the array slice.

pub fn fill(&mut self, value: T)

where T: Clone,

Fills the array slice with elements by cloning value.

pub fn fill_with<F: FnMut() -> T>(&mut self, f: F)

Fills the array slice with elements returned by calling a closure repeatedly.

pub fn flatten(&self) -> View<'_, T, (Dyn,), L>

Returns a one-dimensional array view of the array slice.

Panics

Panics if the array layout is not uniformly strided.

pub fn flatten_mut(&mut self) -> ViewMut<'_, T, (Dyn,), L>

Returns a mutable one-dimensional array view over the array slice.

Panics

Panics if the array layout is not uniformly strided.

pub unsafe fn get_unchecked<I: SliceIndex<T, S, L>>( &self, index: I, ) -> &I::Output

Returns a reference to an element or a subslice, without doing bounds checking.

Safety

The index must be within bounds of the array slice.

pub unsafe fn get_unchecked_mut<I: SliceIndex<T, S, L>>( &mut self, index: I, ) -> &mut I::Output

Returns a mutable reference to an element or a subslice, without doing bounds checking.

Safety

The index must be within bounds of the array slice.

pub fn is_contiguous(&self) -> bool

Returns true if the array strides are consistent with contiguous memory layout.

pub fn is_empty(&self) -> bool

Returns true if the array contains no elements.

pub fn iter(&self) -> Iter<View<'_, T, S, L>>

Returns an iterator over the array slice.

pub fn iter_mut(&mut self) -> Iter<ViewMut<'_, T, S, L>>

Returns a mutable iterator over the array slice.

pub fn lanes<A: Axis>(&self, axis: A) -> Lanes<'_, T, S, L, A>

Returns an expression that gives array views over the specified dimension, iterating over the other dimensions.

If the dimension to give array views over is know at compile time, the resulting shape will maintain a constant-sized dimension. Furthermore, if it is the last dimension the resulting array views have the same layout as the input.

Panics

Panics if the dimension is out of bounds.

pub fn lanes_mut<A: Axis>(&mut self, axis: A) -> LanesMut<'_, T, S, L, A>

Returns a mutable expression that gives array views over the specified dimension, iterating over the other dimensions.

If the dimension to give array views over is know at compile time, the resulting shape will maintain a constant-sized dimension. Furthermore, if it is the last dimension the resulting array views have the same layout as the input.

Panics

Panics if the dimension is out of bounds.

pub fn len(&self) -> usize

Returns the number of elements in the array.

pub fn mapping(&self) -> &L::Mapping<S>

Returns the array layout mapping.

pub fn outer_expr(&self) -> AxisExpr<'_, T, S, L, Const<0>>

Returns an expression that gives array views iterating over the first dimension.

Iterating over the first dimension results in array views with the same layout as the input.

Panics

Panics if the rank is not at least 1.

pub fn outer_expr_mut(&mut self) -> AxisExprMut<'_, T, S, L, Const<0>>

Returns a mutable expression that gives array views iterating over the first dimension.

Iterating over the first dimension results in array views with the same layout as the input.

Panics

Panics if the rank is not at least 1.

pub fn permute<I: IntoShape<IntoShape: Permutation>>( &self, perm: I, ) -> View<'_, T, <I::IntoShape as Permutation>::Shape<S>, <I::IntoShape as Permutation>::Layout<L>>

Returns an array view with the dimensions permuted.

If the permutation is an identity permutation and known at compile time, the resulting array view has the same layout as the input. For example, permuting with (Const::<0>, Const::<1>) will maintain the layout while permuting with [0, 1] gives strided layout.

Panics

Panics if the permutation is not valid.

pub fn permute_mut<I: IntoShape<IntoShape: Permutation>>( &mut self, perm: I, ) -> ViewMut<'_, T, <I::IntoShape as Permutation>::Shape<S>, <I::IntoShape as Permutation>::Layout<L>>

Returns a mutable array view with the dimensions permuted.

If the permutation is an identity permutation and known at compile time, the resulting array view has the same layout as the input. For example, permuting with (Const::<0>, Const::<1>) will maintain the layout while permuting with [0, 1] gives strided layout.

Panics

Panics if the permutation is not valid.

pub fn rank(&self) -> usize

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

pub fn remap<R: Shape, K: Layout>(&self) -> View<'_, T, R, K>

Returns a remapped array view of the array slice.

Panics

Panics if the memory layout is not compatible with the new array layout.

pub fn remap_mut<R: Shape, K: Layout>(&mut self) -> ViewMut<'_, T, R, K>

Returns a mutable remapped array view of the array slice.

Panics

Panics if the memory layout is not compatible with the new array layout.

pub fn reorder(&self) -> View<'_, T, S::Reverse, <S::Tail as Shape>::Layout<L>>

👎Deprecated

Returns a reordered array view of the array slice.

This method is deprecated, use transpose instead.

pub fn reorder_mut( &mut self, ) -> ViewMut<'_, T, S::Reverse, <S::Tail as Shape>::Layout<L>>

👎Deprecated

Returns a mutable reordered array view of the array slice.

This method is deprecated, use transpose_mut instead.

pub fn reshape<I: IntoShape>(&self, shape: I) -> View<'_, T, I::IntoShape, L>

Returns a reshaped array view of the array slice.

At most one dimension can have dynamic size usize::MAX, and is then inferred from the other dimensions and the array length.

Examples

use mdarray::view;

let v = view![[1, 2, 3], [4, 5, 6]];

assert_eq!(v.reshape([!0, 2]), view![[1, 2], [3, 4], [5, 6]]);

Panics

Panics if the array length is changed, or if the memory layout is not compatible.

pub fn reshape_mut<I: IntoShape>( &mut self, shape: I, ) -> ViewMut<'_, T, I::IntoShape, L>

Returns a mutable reshaped array view of the array slice.

At most one dimension can have dynamic size usize::MAX, and is then inferred from the other dimensions and the array length.

See the reshape method above for examples.

Panics

Panics if the array length is changed, or if the memory layout is not compatible.

pub fn row(&self, index: usize) -> View<'_, T, (<S::Tail as Shape>::Head,), L>

Returns an array view for the specified row.

Panics

Panics if the rank is not equal to 2, or if the index is out of bounds.

pub fn row_mut( &mut self, index: usize, ) -> ViewMut<'_, T, (<S::Tail as Shape>::Head,), L>

Returns a mutable array view for the specified row.

Panics

Panics if the rank is not equal to 2, or if the index is out of bounds.

pub fn rows(&self) -> Lanes<'_, T, S, L, Rows>

Returns an expression that gives row views iterating over the other dimensions.

Panics

Panics if the rank is not at least 1.

pub fn rows_mut(&mut self) -> LanesMut<'_, T, S, L, Rows>

Returns a mutable expression that gives row views iterating over the other dimensions.

Panics

Panics if the rank is not at least 1.

pub fn shape(&self) -> &S

Returns the array shape.

pub fn split_at( &self, mid: usize, ) -> (View<'_, T, Resize<Const<0>, S>, L>, View<'_, T, Resize<Const<0>, S>, L>)

Divides an array slice into two at an index along the first dimension.

Panics

Panics if the split point is larger than the number of elements in that dimension, or if the rank is not at least 1.

pub fn split_at_mut( &mut self, mid: usize, ) -> (ViewMut<'_, T, Resize<Const<0>, S>, L>, ViewMut<'_, T, Resize<Const<0>, S>, L>)

Divides a mutable array slice into two at an index along the first dimension.

Panics

Panics if the split point is larger than the number of elements in that dimension, or if the rank is not at least 1.

pub fn split_axis_at<A: Axis>( &self, axis: A, mid: usize, ) -> (View<'_, T, Resize<A, S>, Split<A, S, L>>, View<'_, T, Resize<A, S>, Split<A, S, L>>)

Divides an array slice into two at an index along the specified dimension.

If the dimension to be divided is know at compile time, the resulting array shape will maintain constant-sized dimensions. Furthermore, if it is the first dimension the resulting array views have the same layout as the input.

Panics

Panics if the split point is larger than the number of elements in that dimension, or if the dimension is out of bounds.

pub fn split_axis_at_mut<A: Axis>( &mut self, axis: A, mid: usize, ) -> (ViewMut<'_, T, Resize<A, S>, Split<A, S, L>>, ViewMut<'_, T, Resize<A, S>, Split<A, S, L>>)

Divides a mutable array slice into two at an index along the specified dimension.

If the dimension to be divided is know at compile time, the resulting array shape will maintain constant-sized dimensions. Furthermore, if it is the first dimension the resulting array views have the same layout as the input.

Panics

Panics if the split point is larger than the number of elements in that dimension, or if the dimension is out of bounds.

pub fn stride(&self, index: usize) -> isize

Returns the distance between elements in the specified dimension.

Panics

Panics if the dimension is out of bounds.

pub fn swap<I, J>(&mut self, a: I, b: J)

where I: SliceIndex<T, S, L, Output = T>, J: SliceIndex<T, S, L, Output = T>,

Swaps two elements in the array slice.

Panics

Panics if a or b are out of bounds.

pub fn swap_axis<A: Axis>(&mut self, axis: A, a: usize, b: usize)

Swaps the elements in two subarrays after indexing the specified dimension.

Panics

Panics if a or b are out of bounds.

pub fn to_array(&self) -> Array<T, S>

where T: Clone, S: ConstShape,

Copies the array slice into a new array.

pub fn to_tensor(&self) -> Tensor<T, S>

where T: Clone,

Copies the array slice into a new array.

pub fn to_vec(&self) -> Vec<T>

where T: Clone,

Copies the array slice into a new vector.

pub fn transpose( &self, ) -> View<'_, T, S::Reverse, <S::Tail as Shape>::Layout<L>>

Returns a transposed array view of the array slice, where the dimensions are reversed.

pub fn transpose_mut( &mut self, ) -> ViewMut<'_, T, S::Reverse, <S::Tail as Shape>::Layout<L>>

Returns a mutable transposed array view of the array slice, where the dimensions are reversed.

Trait Implementations

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> Add<I> for &'a ViewMut<'_, T, S, L>

where &'a T: Add<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> AddAssign<I> for ViewMut<'_, T, S, L>

where T: AddAssign<I::Item>,

fn add_assign(&mut self, rhs: I)

Performs the += operation.

impl<'a, T, U, S: Shape, L: Layout> Apply<U> for &'a ViewMut<'_, T, S, L>

type Output<F: FnMut(&'a T) -> U> = Map<<&'a ViewMut<'_, T, S, L> as IntoExpression>::IntoExpr, F>

The resulting type after applying a closure.

type ZippedWith<I: IntoExpression, F: FnMut((&'a T, I::Item)) -> U> = Map<Zip<<&'a ViewMut<'_, T, S, L> as IntoExpression>::IntoExpr, <I as IntoExpression>::IntoExpr>, F>

The resulting type after zipping elements and applying a closure.

fn apply<F: FnMut(&'a T) -> U>(self, f: F) -> Self::Output<F>

Returns the array or an expression with the given closure applied to each element.

fn zip_with<I: IntoExpression, F>(self, expr: I, f: F) -> Self::ZippedWith<I, F>

where F: FnMut((&'a T, I::Item)) -> U,

Returns the array or an expression with the given closure applied to zipped element pairs.

impl<'a, T, U, S: Shape, L: Layout> Apply<U> for &'a mut ViewMut<'_, T, S, L>

type Output<F: FnMut(&'a mut T) -> U> = Map<<&'a mut ViewMut<'_, T, S, L> as IntoExpression>::IntoExpr, F>

The resulting type after applying a closure.

type ZippedWith<I: IntoExpression, F: FnMut((&'a mut T, I::Item)) -> U> = Map<Zip<<&'a mut ViewMut<'_, T, S, L> as IntoExpression>::IntoExpr, <I as IntoExpression>::IntoExpr>, F>

The resulting type after zipping elements and applying a closure.

fn apply<F: FnMut(&'a mut T) -> U>(self, f: F) -> Self::Output<F>

Returns the array or an expression with the given closure applied to each element.

fn zip_with<I: IntoExpression, F>(self, expr: I, f: F) -> Self::ZippedWith<I, F>

where F: FnMut((&'a mut T, I::Item)) -> U,

Returns the array or an expression with the given closure applied to zipped element pairs.

impl<T, U: ?Sized, S: Shape, L: Layout> AsMut<U> for ViewMut<'_, T, S, L>

where Slice<T, S, L>: AsMut<U>,

fn as_mut(&mut self) -> &mut U

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, U: ?Sized, S: Shape, L: Layout> AsRef<U> for ViewMut<'_, T, S, L>

where Slice<T, S, L>: AsRef<U>,

fn as_ref(&self) -> &U

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> BitAnd<I> for &'a ViewMut<'_, T, S, L>

where &'a T: BitAnd<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> BitAndAssign<I> for ViewMut<'_, T, S, L>

where T: BitAndAssign<I::Item>,

fn bitand_assign(&mut self, rhs: I)

Performs the &= operation.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> BitOr<I> for &'a ViewMut<'_, T, S, L>

where &'a T: BitOr<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> BitOrAssign<I> for ViewMut<'_, T, S, L>

where T: BitOrAssign<I::Item>,

fn bitor_assign(&mut self, rhs: I)

Performs the |= operation.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> BitXor<I> for &'a ViewMut<'_, T, S, L>

where &'a T: BitXor<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> BitXorAssign<I> for ViewMut<'_, T, S, L>

where T: BitXorAssign<I::Item>,

fn bitxor_assign(&mut self, rhs: I)

Performs the ^= operation.

impl<T, S: Shape, L: Layout> Borrow<Slice<T, S, L>> for ViewMut<'_, T, S, L>

fn borrow(&self) -> &Slice<T, S, L>

Immutably borrows from an owned value.

impl<T, S: Shape, L: Layout> BorrowMut<Slice<T, S, L>> for ViewMut<'_, T, S, L>

fn borrow_mut(&mut self) -> &mut Slice<T, S, L>

Mutably borrows from an owned value.

impl<T: Debug, S: Shape, L: Layout> Debug for ViewMut<'_, T, S, L>

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

Formats the value using the given formatter.

impl<T, S: Shape, L: Layout> Deref for ViewMut<'_, T, S, L>

type Target = Slice<T, S, L>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S: Shape, L: Layout> DerefMut for ViewMut<'_, T, S, L>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> Div<I> for &'a ViewMut<'_, T, S, L>

where &'a T: Div<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> DivAssign<I> for ViewMut<'_, T, S, L>

where T: DivAssign<I::Item>,

fn div_assign(&mut self, rhs: I)

Performs the /= operation.

impl<'a, T, S: Shape, L: Layout> Expression for ViewMut<'a, T, S, L>

const IS_REPEATABLE: bool = false

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

type Shape = S

Array shape type.

fn shape(&self) -> &S

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 eq<I: IntoExpression>(self, other: I) -> bool

where Self: Expression<Item: PartialEq<I::Item>> + Sized,

Determines if the elements of the expression are equal to those of another.

fn eq_by<I: IntoExpression, F>(self, other: I, eq: F) -> bool

where Self: Sized, F: FnMut(Self::Item, I::Item) -> bool,

Determines if the elements of the expression are equal to those of another with respect to the specified equality function.

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 ne<I: IntoExpression>(self, other: I) -> bool

where Self: Expression<Item: PartialEq<I::Item>> + Sized,

Determines if the elements of the expression are not equal to those of another.

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, T, X: Dim + From<Const<A>>, Y: Dim + From<Const<B>>, Z: Dim + From<Const<C>>, W: Dim + From<Const<D>>, U: Dim + From<Const<E>>, V: Dim + From<Const<F>>, const A: usize, const B: usize, const C: usize, const D: usize, const E: usize, const F: usize> From<&'a mut [[[[[[T; F]; E]; D]; C]; B]; A]> for ViewMut<'a, T, (X, Y, Z, W, U, V)>

fn from(value: &'a mut [[[[[[T; F]; E]; D]; C]; B]; A]) -> Self

Converts to this type from the input type.

impl<'a, T, X: Dim + From<Const<A>>, Y: Dim + From<Const<B>>, Z: Dim + From<Const<C>>, W: Dim + From<Const<D>>, U: Dim + From<Const<E>>, const A: usize, const B: usize, const C: usize, const D: usize, const E: usize> From<&'a mut [[[[[T; E]; D]; C]; B]; A]> for ViewMut<'a, T, (X, Y, Z, W, U)>

fn from(value: &'a mut [[[[[T; E]; D]; C]; B]; A]) -> Self

Converts to this type from the input type.

impl<'a, T, X: Dim + From<Const<A>>, Y: Dim + From<Const<B>>, Z: Dim + From<Const<C>>, W: Dim + From<Const<D>>, const A: usize, const B: usize, const C: usize, const D: usize> From<&'a mut [[[[T; D]; C]; B]; A]> for ViewMut<'a, T, (X, Y, Z, W)>

fn from(value: &'a mut [[[[T; D]; C]; B]; A]) -> Self

Converts to this type from the input type.

impl<'a, T, X: Dim + From<Const<A>>, Y: Dim + From<Const<B>>, Z: Dim + From<Const<C>>, const A: usize, const B: usize, const C: usize> From<&'a mut [[[T; C]; B]; A]> for ViewMut<'a, T, (X, Y, Z)>

fn from(value: &'a mut [[[T; C]; B]; A]) -> Self

Converts to this type from the input type.

impl<'a, T, X: Dim + From<Const<A>>, Y: Dim + From<Const<B>>, const A: usize, const B: usize> From<&'a mut [[T; B]; A]> for ViewMut<'a, T, (X, Y)>

fn from(value: &'a mut [[T; B]; A]) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a mut [T]> for ViewMut<'a, T, (Dyn,)>

fn from(value: &'a mut [T]) -> Self

Converts to this type from the input type.

impl<'a, T, X: Dim + From<Const<A>>, const A: usize> From<&'a mut [T; A]> for ViewMut<'a, T, (X,)>

fn from(value: &'a mut [T; A]) -> Self

Converts to this type from the input type.

impl<'a, T, S: Shape, L: Layout, I> From<&'a mut I> for ViewMut<'a, T, S, L>

where &'a mut I: IntoExpression<IntoExpr = ViewMut<'a, T, S, L>>,

fn from(value: &'a mut I) -> Self

Converts to this type from the input type.

impl<'a, T, D: Dim> From<ViewMut<'a, T, (D,)>> for &'a mut [T]

fn from(value: ViewMut<'_, T, (D,)>) -> Self

Converts to this type from the input type.

impl<T: Hash, S: Shape, L: Layout> Hash for ViewMut<'_, T, S, L>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, S: Shape, L: Layout, I: SliceIndex<T, S, L>> Index<I> for ViewMut<'_, T, S, L>

type Output = <I as SliceIndex<T, S, L>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &I::Output

Performs the indexing (container[index]) operation.

impl<T, S: Shape, L: Layout, I: SliceIndex<T, S, L>> IndexMut<I> for ViewMut<'_, T, S, L>

fn index_mut(&mut self, index: I) -> &mut I::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T, S: Shape, L: Layout> IntoExpression for &'a ViewMut<'_, T, S, L>

type Shape = S

Array shape type.

type IntoExpr = View<'a, T, S, L>

Which kind of expression are we turning this into?

fn into_expr(self) -> Self::IntoExpr

Creates an expression from a value.

impl<'a, T, S: Shape, L: Layout> IntoExpression for &'a mut ViewMut<'_, T, S, L>

type Shape = S

Array shape type.

type IntoExpr = ViewMut<'a, T, S, L>

Which kind of expression are we turning this into?

fn into_expr(self) -> Self::IntoExpr

Creates an expression from a value.

impl<'a, T, S: Shape, L: Layout> IntoIterator for &'a ViewMut<'_, T, S, L>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<View<'a, T, S, L>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, S: Shape, L: Layout> IntoIterator for &'a mut ViewMut<'_, T, S, L>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = Iter<ViewMut<'a, T, S, L>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, S: Shape, L: Layout> IntoIterator for ViewMut<'a, T, S, L>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = Iter<ViewMut<'a, T, S, L>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<Self>

Creates an iterator from a value.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> Mul<I> for &'a ViewMut<'_, T, S, L>

where &'a T: Mul<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> MulAssign<I> for ViewMut<'_, T, S, L>

where T: MulAssign<I::Item>,

fn mul_assign(&mut self, rhs: I)

Performs the *= operation.

impl<'a, T, U, S: Shape, L: Layout> Neg for &'a ViewMut<'_, T, S, L>

where &'a T: Neg<Output = U>,

type Output = <&'a ViewMut<'_, T, S, L> as Apply<U>>::Output<fn(&'a T) -> U>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, T, U, S: Shape, L: Layout> Not for &'a ViewMut<'_, T, S, L>

where &'a T: Not<Output = U>,

type Output = <&'a ViewMut<'_, T, S, L> as Apply<U>>::Output<fn(&'a T) -> U>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, U, S: Shape, R: Shape, L: Layout, K: Layout, I: ?Sized> PartialEq<I> for ViewMut<'_, T, S, L>

where for<'a> &'a I: IntoExpression<IntoExpr = View<'a, U, R, K>>, T: PartialEq<U>,

fn eq(&self, other: &I) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> Rem<I> for &'a ViewMut<'_, T, S, L>

where &'a T: Rem<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> RemAssign<I> for ViewMut<'_, T, S, L>

where T: RemAssign<I::Item>,

fn rem_assign(&mut self, rhs: I)

Performs the %= operation.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> Shl<I> for &'a ViewMut<'_, T, S, L>

where &'a T: Shl<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> ShlAssign<I> for ViewMut<'_, T, S, L>

where T: ShlAssign<I::Item>,

fn shl_assign(&mut self, rhs: I)

Performs the <<= operation.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> Shr<I> for &'a ViewMut<'_, T, S, L>

where &'a T: Shr<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> ShrAssign<I> for ViewMut<'_, T, S, L>

where T: ShrAssign<I::Item>,

fn shr_assign(&mut self, rhs: I)

Performs the >>= operation.

impl<'a, T, U, S: Shape, L: Layout, I: Apply<U>> Sub<I> for &'a ViewMut<'_, T, S, L>

where &'a T: Sub<I::Item, Output = U>,

type Output = <I as Apply<U>>::ZippedWith<&'a ViewMut<'_, T, S, L>, fn((<I as IntoIterator>::Item, &'a T)) -> U>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, S: Shape, L: Layout, I: IntoExpression> SubAssign<I> for ViewMut<'_, T, S, L>

where T: SubAssign<I::Item>,

fn sub_assign(&mut self, rhs: I)

Performs the -= operation.

impl<'a, T, X: Dim, const A: usize> TryFrom<ViewMut<'a, T, (X,)>> for &'a mut [T; A]

type Error = ViewMut<'a, T, (X,)>

The type returned in the event of a conversion error.

fn try_from(value: ViewMut<'a, T, (X,)>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, X: Dim, Y: Dim, const A: usize, const B: usize> TryFrom<ViewMut<'a, T, (X, Y)>> for &'a mut [[T; B]; A]

type Error = ViewMut<'a, T, (X, Y)>

The type returned in the event of a conversion error.

fn try_from(value: ViewMut<'a, T, (X, Y)>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, X: Dim, Y: Dim, Z: Dim, const A: usize, const B: usize, const C: usize> TryFrom<ViewMut<'a, T, (X, Y, Z)>> for &'a mut [[[T; C]; B]; A]

type Error = ViewMut<'a, T, (X, Y, Z)>

The type returned in the event of a conversion error.

fn try_from(value: ViewMut<'a, T, (X, Y, Z)>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, X: Dim, Y: Dim, Z: Dim, W: Dim, const A: usize, const B: usize, const C: usize, const D: usize> TryFrom<ViewMut<'a, T, (X, Y, Z, W)>> for &'a mut [[[[T; D]; C]; B]; A]

type Error = ViewMut<'a, T, (X, Y, Z, W)>

The type returned in the event of a conversion error.

fn try_from(value: ViewMut<'a, T, (X, Y, Z, W)>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, X: Dim, Y: Dim, Z: Dim, W: Dim, U: Dim, const A: usize, const B: usize, const C: usize, const D: usize, const E: usize> TryFrom<ViewMut<'a, T, (X, Y, Z, W, U)>> for &'a mut [[[[[T; E]; D]; C]; B]; A]

type Error = ViewMut<'a, T, (X, Y, Z, W, U)>

The type returned in the event of a conversion error.

fn try_from(value: ViewMut<'a, T, (X, Y, Z, W, U)>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, X: Dim, Y: Dim, Z: Dim, W: Dim, U: Dim, V: Dim, const A: usize, const B: usize, const C: usize, const D: usize, const E: usize, const F: usize> TryFrom<ViewMut<'a, T, (X, Y, Z, W, U, V)>> for &'a mut [[[[[[T; F]; E]; D]; C]; B]; A]

type Error = ViewMut<'a, T, (X, Y, Z, W, U, V)>

The type returned in the event of a conversion error.

fn try_from( value: ViewMut<'a, T, (X, Y, Z, W, U, V)>, ) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Eq, S: Shape, L: Layout> Eq for ViewMut<'_, T, S, L>

impl<T: Send, S: Shape, L: Layout> Send for ViewMut<'_, T, S, L>

impl<T: Sync, S: Shape, L: Layout> Sync for ViewMut<'_, T, S, L>