Struct Slice 

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

Multidimensional array slice.

Implementations

impl<T, S: Shape, L: Layout> 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.

impl<T, L: Layout> Slice<T, DynRank, L>

pub fn dims(&self) -> &[usize]

Returns the number of elements in each dimension.

impl<T, S: Shape> Slice<T, S, Strided>

pub fn strides(&self) -> &[isize]

Returns the distance between elements in each dimension.

impl<T, X: Dim, L: Layout> Slice<T, (X,), L>

pub fn array<A: DimIndex>( &self, a: A, ) -> Array<T, <(A,) as ViewIndex>::Shape<(X,)>>

where T: Clone, (A,): ViewIndex<Shape<(X,)>: ConstShape>,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn tensor<A: DimIndex>( &self, a: A, ) -> Tensor<T, <(A,) as ViewIndex>::Shape<(X,)>>

where T: Clone,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn view<A: DimIndex>( &self, a: A, ) -> View<'_, T, <(A,) as ViewIndex>::Shape<(X,)>, <(A,) as ViewIndex>::Layout<L>>

Returns an array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

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

Returns a mutable array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<T, X: Dim, Y: Dim, L: Layout> Slice<T, (X, Y), L>

pub fn array<A: DimIndex, B: DimIndex>( &self, a: A, b: B, ) -> Array<T, <(A, B) as ViewIndex>::Shape<(X, Y)>>

where T: Clone, (A, B): ViewIndex<Shape<(X, Y)>: ConstShape>,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn tensor<A: DimIndex, B: DimIndex>( &self, a: A, b: B, ) -> Tensor<T, <(A, B) as ViewIndex>::Shape<(X, Y)>>

where T: Clone,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

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

Returns an array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

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

Returns a mutable array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<T, X: Dim, Y: Dim, Z: Dim, L: Layout> Slice<T, (X, Y, Z), L>

pub fn array<A: DimIndex, B: DimIndex, C: DimIndex>( &self, a: A, b: B, c: C, ) -> Array<T, <(A, B, C) as ViewIndex>::Shape<(X, Y, Z)>>

where T: Clone, (A, B, C): ViewIndex<Shape<(X, Y, Z)>: ConstShape>,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn tensor<A: DimIndex, B: DimIndex, C: DimIndex>( &self, a: A, b: B, c: C, ) -> Tensor<T, <(A, B, C) as ViewIndex>::Shape<(X, Y, Z)>>

where T: Clone,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

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

Returns an array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

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

Returns a mutable array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<T, X: Dim, Y: Dim, Z: Dim, W: Dim, L: Layout> Slice<T, (X, Y, Z, W), L>

pub fn array<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex>( &self, a: A, b: B, c: C, d: D, ) -> Array<T, <(A, B, C, D) as ViewIndex>::Shape<(X, Y, Z, W)>>

where T: Clone, (A, B, C, D): ViewIndex<Shape<(X, Y, Z, W)>: ConstShape>,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn tensor<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex>( &self, a: A, b: B, c: C, d: D, ) -> Tensor<T, <(A, B, C, D) as ViewIndex>::Shape<(X, Y, Z, W)>>

where T: Clone,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

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

Returns an array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

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

Returns a mutable array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

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

pub fn array<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex, E: DimIndex>( &self, a: A, b: B, c: C, d: D, e: E, ) -> Array<T, <(A, B, C, D, E) as ViewIndex>::Shape<(X, Y, Z, W, U)>>

where T: Clone, (A, B, C, D, E): ViewIndex<Shape<(X, Y, Z, W, U)>: ConstShape>,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn tensor<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex, E: DimIndex>( &self, a: A, b: B, c: C, d: D, e: E, ) -> Tensor<T, <(A, B, C, D, E) as ViewIndex>::Shape<(X, Y, Z, W, U)>>

where T: Clone,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

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

Returns an array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

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

Returns a mutable array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

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

pub fn array<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, ) -> Array<T, <(A, B, C, D, E, F) as ViewIndex>::Shape<(X, Y, Z, W, U, V)>>

where T: Clone, (A, B, C, D, E, F): ViewIndex<Shape<(X, Y, Z, W, U, V)>: ConstShape>,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn tensor<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, ) -> Tensor<T, <(A, B, C, D, E, F) as ViewIndex>::Shape<(X, Y, Z, W, U, V)>>

where T: Clone,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn 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, ) -> View<'_, 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>>

Returns an array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

pub fn view_mut<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex, E: DimIndex, F: DimIndex>( &mut self, a: A, b: B, c: C, d: D, e: E, f: F, ) -> ViewMut<'_, 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>>

Returns a mutable array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

Trait Implementations

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

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<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 Slice<T, S, L>

type Output<F: FnMut(&'a T) -> U> = Map<<&'a Slice<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 Slice<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 Slice<T, S, L>

type Output<F: FnMut(&'a mut T) -> U> = Map<<&'a mut Slice<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 Slice<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, const X: usize, const Y: usize, const Z: usize, const W: usize, const U: usize, const V: usize> AsMut<[[[[[[T; V]; U]; W]; Z]; Y]; X]> for Slice<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>, Const<V>)>

fn as_mut(&mut self) -> &mut [[[[[[T; V]; U]; W]; Z]; Y]; X]

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

impl<T, const X: usize, const Y: usize, const Z: usize, const W: usize, const U: usize> AsMut<[[[[[T; U]; W]; Z]; Y]; X]> for Slice<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>)>

fn as_mut(&mut self) -> &mut [[[[[T; U]; W]; Z]; Y]; X]

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

impl<T, const X: usize, const Y: usize, const Z: usize, const W: usize> AsMut<[[[[T; W]; Z]; Y]; X]> for Slice<T, (Const<X>, Const<Y>, Const<Z>, Const<W>)>

fn as_mut(&mut self) -> &mut [[[[T; W]; Z]; Y]; X]

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

impl<T, const X: usize, const Y: usize, const Z: usize> AsMut<[[[T; Z]; Y]; X]> for Slice<T, (Const<X>, Const<Y>, Const<Z>)>

fn as_mut(&mut self) -> &mut [[[T; Z]; Y]; X]

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

impl<T, const X: usize, const Y: usize> AsMut<[[T; Y]; X]> for Slice<T, (Const<X>, Const<Y>)>

fn as_mut(&mut self) -> &mut [[T; Y]; X]

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

impl<T, D: Dim> AsMut<[T]> for Slice<T, (D,)>

fn as_mut(&mut self) -> &mut [T]

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

impl<T, const X: usize> AsMut<[T; X]> for Slice<T, (Const<X>,)>

fn as_mut(&mut self) -> &mut [T; X]

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

impl<B: Buffer> AsMut<Slice<<B as Buffer>::Item, <B as Buffer>::Shape>> for IntoExpr<B>

fn as_mut(&mut self) -> &mut Slice<B::Item, B::Shape>

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

impl<T, S: Shape, L: Layout> AsMut<Slice<T, S, L>> for Slice<T, S, L>

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

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

impl<T, const X: usize, const Y: usize, const Z: usize, const W: usize, const U: usize, const V: usize> AsRef<[[[[[[T; V]; U]; W]; Z]; Y]; X]> for Slice<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>, Const<V>)>

fn as_ref(&self) -> &[[[[[[T; V]; U]; W]; Z]; Y]; X]

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

impl<T, const X: usize, const Y: usize, const Z: usize, const W: usize, const U: usize> AsRef<[[[[[T; U]; W]; Z]; Y]; X]> for Slice<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>)>

fn as_ref(&self) -> &[[[[[T; U]; W]; Z]; Y]; X]

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

impl<T, const X: usize, const Y: usize, const Z: usize, const W: usize> AsRef<[[[[T; W]; Z]; Y]; X]> for Slice<T, (Const<X>, Const<Y>, Const<Z>, Const<W>)>

fn as_ref(&self) -> &[[[[T; W]; Z]; Y]; X]

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

impl<T, const X: usize, const Y: usize, const Z: usize> AsRef<[[[T; Z]; Y]; X]> for Slice<T, (Const<X>, Const<Y>, Const<Z>)>

fn as_ref(&self) -> &[[[T; Z]; Y]; X]

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

impl<T, const X: usize, const Y: usize> AsRef<[[T; Y]; X]> for Slice<T, (Const<X>, Const<Y>)>

fn as_ref(&self) -> &[[T; Y]; X]

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

impl<T, D: Dim> AsRef<[T]> for Slice<T, (D,)>

fn as_ref(&self) -> &[T]

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

impl<T, const X: usize> AsRef<[T; X]> for Slice<T, (Const<X>,)>

fn as_ref(&self) -> &[T; X]

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

impl<B: Buffer> AsRef<Slice<<B as Buffer>::Item, <B as Buffer>::Shape>> for IntoExpr<B>

fn as_ref(&self) -> &Slice<B::Item, B::Shape>

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

impl<T, S: Shape, L: Layout> AsRef<Slice<T, S, L>> for Slice<T, S, L>

fn as_ref(&self) -> &Self

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 Slice<T, S, L>

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<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 Slice<T, S, L>

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<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 Slice<T, S, L>

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<T, S, L>

where T: BitXorAssign<I::Item>,

fn bitxor_assign(&mut self, rhs: I)

Performs the ^= operation.

impl<T, S: ConstShape> Borrow<Slice<T, S>> for Array<T, S>

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

Immutably borrows from an owned value.

impl<T, S: Shape, A: Allocator> Borrow<Slice<T, S>> for Tensor<T, S, A>

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

Immutably borrows from an owned value.

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

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

Immutably borrows from an owned value.

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: ConstShape> BorrowMut<Slice<T, S>> for Array<T, S>

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

Mutably borrows from an owned value.

impl<T, S: Shape, A: Allocator> BorrowMut<Slice<T, S>> for Tensor<T, S, A>

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

Mutably 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 Slice<T, S, L>

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

Formats the value using the given formatter.

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

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<T, S, L>

where T: DivAssign<I::Item>,

fn div_assign(&mut self, rhs: I)

Performs the /= operation.

impl<T: Hash, S: Shape, L: Layout> Hash for Slice<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 Slice<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 Slice<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 Slice<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 Slice<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 Slice<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 Slice<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, U, S: Shape, L: Layout, I: Apply<U>> Mul<I> for &'a Slice<T, S, L>

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<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 Slice<T, S, L>

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

type Output = <&'a Slice<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 Slice<T, S, L>

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

type Output = <&'a Slice<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 Slice<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 Slice<T, S, L>

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<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 Slice<T, S, L>

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<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 Slice<T, S, L>

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<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 Slice<T, S, L>

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

type Output = <I as Apply<U>>::ZippedWith<&'a Slice<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 Slice<T, S, L>

where T: SubAssign<I::Item>,

fn sub_assign(&mut self, rhs: I)

Performs the -= operation.

impl<T: Clone, S: Shape> ToOwned for Slice<T, S>

type Owned = <S as Shape>::Owned<T>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl<T: Eq, S: Shape, L: Layout> Eq for Slice<T, S, L>