Struct Span

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

Multidimensional array span.

Implementations

impl<T, S: Shape, L: Layout> Span<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 span with broadcasting, cloning elements if needed.

Panics

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

pub fn axis_expr<const N: usize>(&self) -> AxisExpr<'_, T, S, L, Inner<N>>

where Inner<N>: Axis,

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

When iterating over the outermost dimension, both the unit inner stride and the uniform stride properties are maintained, and the resulting array views have the same layout.

When iterating over the innermost dimension, the uniform stride property is maintained but not unit inner stride, and the resulting array views have flat or strided layout.

When iterating over the other dimensions, the unit inner stride propery is maintained but not uniform stride, and the resulting array views have general or strided layout.

Panics

Panics if the dimension is out of bounds.

pub fn axis_expr_mut<const N: usize>( &mut self, ) -> AxisExprMut<'_, T, S, L, Inner<N>>

where Inner<N>: Axis,

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

When iterating over the outermost dimension, both the unit inner stride and the uniform stride properties are maintained, and the resulting array views have the same layout.

When iterating over the innermost dimension, the uniform stride property is maintained but not unit inner stride, and the resulting array views have flat or strided layout.

When iterating over the other dimensions, the unit inner stride propery is maintained but not uniform stride, and the resulting array views have general or strided layout.

Panics

Panics if the dimension is out of bounds.

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

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

Panics

Panics if the rank is not at least 1.

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

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

Panics

Panics if the rank is not at least 1.

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

where T: PartialEq,

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

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 dims(&self) -> S::Dims

Returns the number of elements in each dimension.

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

Returns an expression over the array span.

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

Returns a mutable expression over the array span.

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

where T: Clone,

Fills the array span with elements by cloning value.

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

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

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

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

Panics

Panics if the array layout is not uniformly strided.

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

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

Panics

Panics if the array layout is not uniformly strided.

pub unsafe fn get_unchecked<I: SpanIndex<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 span.

pub unsafe fn get_unchecked_mut<I: SpanIndex<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 span.

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 is_uniformly_strided(&self) -> bool

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

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

Returns an iterator over the array span.

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

Returns a mutable iterator over the array span.

pub fn lanes<const N: usize>(&self) -> Lanes<'_, T, S, L, Inner<N>>

where Inner<N>: Axis,

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

If the innermost dimension is specified, the resulting array views have dense or flat layout. For other dimensions, the resulting array views have flat layout.

Panics

Panics if the dimension is out of bounds.

pub fn lanes_mut<const N: usize>(&mut self) -> LanesMut<'_, T, S, L, Inner<N>>

where Inner<N>: Axis,

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

If the innermost dimension is specified, the resulting array views have dense or flat layout. For other dimensions, the resulting array views have flat layout.

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, Outer>

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

Iterating over the outermost dimension maintains both the unit inner stride and the uniform stride properties, and the resulting array views have the same layout.

Panics

Panics if the rank is not at least 1.

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

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

Iterating over the outermost dimension maintains both the unit inner stride and the uniform stride properties, and the resulting array views have the same layout.

Panics

Panics if the rank is not at least 1.

pub fn rank(&self) -> usize

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

pub fn remap<M: Layout>(&self) -> Expr<'_, T, S, M>

Returns a remapped array view of the array span.

Panics

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

pub fn remap_mut<M: Layout>(&mut self) -> ExprMut<'_, T, S, M>

Returns a mutable remapped array view of the array span.

Panics

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

pub fn reshape<I: IntoShape>( &self, shape: I, ) -> Expr<'_, T, I::IntoShape, <I::IntoShape as Shape>::Layout<L::Uniform, L>>

Returns a reshaped array view of the array span, with similar layout.

Panics

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

pub fn reshape_mut<I: IntoShape>( &mut self, shape: I, ) -> ExprMut<'_, T, I::IntoShape, <I::IntoShape as Shape>::Layout<L::Uniform, L>>

Returns a mutable reshaped array view of the array span, with similar layout.

Panics

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

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

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

Panics

Panics if the rank is not at least 2.

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

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

Panics

Panics if the rank is not at least 2.

pub fn shape(&self) -> S

Returns the array shape.

pub fn split_at( &self, mid: usize, ) -> (Expr<'_, T, <Outer as Axis>::Replace<Dyn, S>, L>, Expr<'_, T, <Outer as Axis>::Replace<Dyn, S>, L>)

Divides an array span into two at an index along the outermost 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, ) -> (ExprMut<'_, T, <Outer as Axis>::Replace<Dyn, S>, L>, ExprMut<'_, T, <Outer as Axis>::Replace<Dyn, S>, L>)

Divides a mutable array span into two at an index along the outermost 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<const N: usize>( &self, mid: usize, ) -> (Expr<'_, T, <Inner<N> as Axis>::Replace<Dyn, S>, <Inner<N> as Axis>::Resize<S, L>>, Expr<'_, T, <Inner<N> as Axis>::Replace<Dyn, S>, <Inner<N> as Axis>::Resize<S, L>>)

where Inner<N>: Axis,

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

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<const N: usize>( &mut self, mid: usize, ) -> (ExprMut<'_, T, <Inner<N> as Axis>::Replace<Dyn, S>, <Inner<N> as Axis>::Resize<S, L>>, ExprMut<'_, T, <Inner<N> as Axis>::Replace<Dyn, S>, <Inner<N> as Axis>::Resize<S, L>>)

where Inner<N>: Axis,

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

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 strides(&self) -> S::Strides

Returns the distance between elements in each dimension.

pub fn to_grid(&self) -> Grid<T, S>

where T: Clone,

Copies the array span into a new array.

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

where T: Clone,

Copies the array span into a new vector.

impl<T, S: Shape> Span<T, S>

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice of all elements in the array, which must have dense layout.

pub fn as_slice(&self) -> &[T]

Returns a slice of all elements in the array, which must have dense layout.

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

pub fn col(&self, index: usize) -> Expr<'_, T, X, L::Uniform>

Returns an array view for the specified column.

Panics

Panics if the index is out of bounds.

pub fn col_mut(&mut self, index: usize) -> ExprMut<'_, T, X, L::Uniform>

Returns a mutable array view for the specified column.

Panics

Panics if the index is out of bounds.

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

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

Panics

Panics if the absolute index is larger than the number of columns or rows.

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

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

Panics

Panics if the absolute index is larger than the number of columns or rows.

pub fn row(&self, index: usize) -> Expr<'_, T, Y, Flat>

Returns an array view for the specified row.

Panics

Panics if the index is out of bounds.

pub fn row_mut(&mut self, index: usize) -> ExprMut<'_, T, Y, Flat>

Returns a mutable array view for the specified row.

Panics

Panics if the index is out of bounds.

impl<T, X: Dim, L: Layout> Span<T, X, L>

pub fn permute<const A: usize>( &self, ) -> Expr<'_, T, <(Const<A>,) as Permutation>::Shape<X>, <(Const<A>,) as Permutation>::Layout<L>>

where (Const<A>,): Permutation,

Returns an array view with the dimensions permuted.

pub fn permute_mut<const A: usize>( &mut self, ) -> ExprMut<'_, T, <(Const<A>,) as Permutation>::Shape<X>, <(Const<A>,) as Permutation>::Layout<L>>

where (Const<A>,): Permutation,

Returns a mutable array view with the dimensions permuted.

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

pub fn permute<const A: usize, const B: usize>( &self, ) -> Expr<'_, T, <(Const<A>, Const<B>) as Permutation>::Shape<(X, Y)>, <(Const<A>, Const<B>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>): Permutation,

Returns an array view with the dimensions permuted.

pub fn permute_mut<const A: usize, const B: usize>( &mut self, ) -> ExprMut<'_, T, <(Const<A>, Const<B>) as Permutation>::Shape<(X, Y)>, <(Const<A>, Const<B>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>): Permutation,

Returns a mutable array view with the dimensions permuted.

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

pub fn permute<const A: usize, const B: usize, const C: usize>( &self, ) -> Expr<'_, T, <(Const<A>, Const<B>, Const<C>) as Permutation>::Shape<(X, Y, Z)>, <(Const<A>, Const<B>, Const<C>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>, Const<C>): Permutation,

Returns an array view with the dimensions permuted.

pub fn permute_mut<const A: usize, const B: usize, const C: usize>( &mut self, ) -> ExprMut<'_, T, <(Const<A>, Const<B>, Const<C>) as Permutation>::Shape<(X, Y, Z)>, <(Const<A>, Const<B>, Const<C>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>, Const<C>): Permutation,

Returns a mutable array view with the dimensions permuted.

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

pub fn permute<const A: usize, const B: usize, const C: usize, const D: usize>( &self, ) -> Expr<'_, T, <(Const<A>, Const<B>, Const<C>, Const<D>) as Permutation>::Shape<(X, Y, Z, W)>, <(Const<A>, Const<B>, Const<C>, Const<D>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>, Const<C>, Const<D>): Permutation,

Returns an array view with the dimensions permuted.

pub fn permute_mut<const A: usize, const B: usize, const C: usize, const D: usize>( &mut self, ) -> ExprMut<'_, T, <(Const<A>, Const<B>, Const<C>, Const<D>) as Permutation>::Shape<(X, Y, Z, W)>, <(Const<A>, Const<B>, Const<C>, Const<D>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>, Const<C>, Const<D>): Permutation,

Returns a mutable array view with the dimensions permuted.

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

pub fn permute<const A: usize, const B: usize, const C: usize, const D: usize, const E: usize>( &self, ) -> Expr<'_, T, <(Const<A>, Const<B>, Const<C>, Const<D>, Const<E>) as Permutation>::Shape<(X, Y, Z, W, U)>, <(Const<A>, Const<B>, Const<C>, Const<D>, Const<E>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>, Const<C>, Const<D>, Const<E>): Permutation,

Returns an array view with the dimensions permuted.

pub fn permute_mut<const A: usize, const B: usize, const C: usize, const D: usize, const E: usize>( &mut self, ) -> ExprMut<'_, T, <(Const<A>, Const<B>, Const<C>, Const<D>, Const<E>) as Permutation>::Shape<(X, Y, Z, W, U)>, <(Const<A>, Const<B>, Const<C>, Const<D>, Const<E>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>, Const<C>, Const<D>, Const<E>): Permutation,

Returns a mutable array view with the dimensions permuted.

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

pub fn permute<const A: usize, const B: usize, const C: usize, const D: usize, const E: usize, const F: usize>( &self, ) -> Expr<'_, T, <(Const<A>, Const<B>, Const<C>, Const<D>, Const<E>, Const<F>) as Permutation>::Shape<(X, Y, Z, W, U, V)>, <(Const<A>, Const<B>, Const<C>, Const<D>, Const<E>, Const<F>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>, Const<C>, Const<D>, Const<E>, Const<F>): Permutation,

Returns an array view with the dimensions permuted.

pub fn permute_mut<const A: usize, const B: usize, const C: usize, const D: usize, const E: usize, const F: usize>( &mut self, ) -> ExprMut<'_, T, <(Const<A>, Const<B>, Const<C>, Const<D>, Const<E>, Const<F>) as Permutation>::Shape<(X, Y, Z, W, U, V)>, <(Const<A>, Const<B>, Const<C>, Const<D>, Const<E>, Const<F>) as Permutation>::Layout<L>>

where (Const<A>, Const<B>, Const<C>, Const<D>, Const<E>, Const<F>): Permutation,

Returns a mutable array view with the dimensions permuted.

impl<T, X: Dim, L: Layout> Span<T, X, L>

pub fn grid<A: DimIndex>(&self, a: A) -> Grid<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, ) -> Expr<'_, T, <(A,) as ViewIndex>::Shape<X>, <(A,) as ViewIndex>::Layout<X, 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, ) -> ExprMut<'_, T, <(A,) as ViewIndex>::Shape<X>, <(A,) as ViewIndex>::Layout<X, 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> Span<T, (X, Y), L>

pub fn grid<A: DimIndex, B: DimIndex>( &self, a: A, b: B, ) -> Grid<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, ) -> Expr<'_, T, <(A, B) as ViewIndex>::Shape<(X, Y)>, <(A, B) as ViewIndex>::Layout<(X, Y), 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, ) -> ExprMut<'_, T, <(A, B) as ViewIndex>::Shape<(X, Y)>, <(A, B) as ViewIndex>::Layout<(X, Y), 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> Span<T, (X, Y, Z), L>

pub fn grid<A: DimIndex, B: DimIndex, C: DimIndex>( &self, a: A, b: B, c: C, ) -> Grid<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, ) -> Expr<'_, T, <(A, B, C) as ViewIndex>::Shape<(X, Y, Z)>, <(A, B, C) as ViewIndex>::Layout<(X, Y, Z), 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, ) -> ExprMut<'_, T, <(A, B, C) as ViewIndex>::Shape<(X, Y, Z)>, <(A, B, C) as ViewIndex>::Layout<(X, Y, Z), 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> Span<T, (X, Y, Z, W), L>

pub fn grid<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex>( &self, a: A, b: B, c: C, d: D, ) -> Grid<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, ) -> Expr<'_, T, <(A, B, C, D) as ViewIndex>::Shape<(X, Y, Z, W)>, <(A, B, C, D) as ViewIndex>::Layout<(X, Y, Z, W), 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, ) -> ExprMut<'_, T, <(A, B, C, D) as ViewIndex>::Shape<(X, Y, Z, W)>, <(A, B, C, D) as ViewIndex>::Layout<(X, Y, Z, W), 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> Span<T, (X, Y, Z, W, U), L>

pub fn grid<A: DimIndex, B: DimIndex, C: DimIndex, D: DimIndex, E: DimIndex>( &self, a: A, b: B, c: C, d: D, e: E, ) -> Grid<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, ) -> Expr<'_, T, <(A, B, C, D, E) as ViewIndex>::Shape<(X, Y, Z, W, U)>, <(A, B, C, D, E) as ViewIndex>::Layout<(X, Y, Z, W, U), 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, ) -> ExprMut<'_, T, <(A, B, C, D, E) as ViewIndex>::Shape<(X, Y, Z, W, U)>, <(A, B, C, D, E) as ViewIndex>::Layout<(X, Y, Z, W, U), 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> Span<T, (X, Y, Z, W, U, V), L>

pub fn grid<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, ) -> Grid<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, ) -> Expr<'_, 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<(X, Y, Z, W, U, V), 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, ) -> ExprMut<'_, 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<(X, Y, Z, W, U, V), 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 Span<T, S, L>

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

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

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

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

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

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; X]; Y]; Z]; W]; U]> for Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>)>

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

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; X]; Y]; Z]; W]> for Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>)>

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

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; X]; Y]; Z]> for Span<T, (Const<X>, Const<Y>, Const<Z>)>

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

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

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

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

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

impl<T, S: Shape> AsMut<[T]> for Span<T, S>

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 Span<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<T, const X: usize, const Y: usize> AsMut<Span<T, (Const<X>, Const<Y>)>> for [[T; X]; Y]

fn as_mut(&mut self) -> &mut Span<T, (Const<X>, Const<Y>)>

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<Span<T, (Const<X>, Const<Y>, Const<Z>)>> for [[[T; X]; Y]; Z]

fn as_mut(&mut self) -> &mut Span<T, (Const<X>, Const<Y>, Const<Z>)>

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<Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>)>> for [[[[T; X]; Y]; Z]; W]

fn as_mut(&mut self) -> &mut Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>)>

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<Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>)>> for [[[[[T; X]; Y]; Z]; W]; U]

fn as_mut( &mut self, ) -> &mut Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>)>

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> AsMut<Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>, Const<V>)>> for [[[[[[T; X]; Y]; Z]; W]; U]; V]

fn as_mut( &mut self, ) -> &mut Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>, Const<V>)>

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

impl<T, const X: usize> AsMut<Span<T, Const<X>>> for [T; X]

fn as_mut(&mut self) -> &mut Span<T, Const<X>>

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

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

fn as_mut(&mut self) -> &mut Span<T, S, L>

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; X]; Y]; Z]; W]; U]; V]> for Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>, Const<V>)>

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

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; X]; Y]; Z]; W]; U]> for Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>)>

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

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; X]; Y]; Z]; W]> for Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>)>

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

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; X]; Y]; Z]> for Span<T, (Const<X>, Const<Y>, Const<Z>)>

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

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

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

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

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

impl<T, S: Shape> AsRef<[T]> for Span<T, S>

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 Span<T, Const<X>>

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

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

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

fn as_ref(&self) -> &Span<T, (Const<X>, Const<Y>)>

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<Span<T, (Const<X>, Const<Y>, Const<Z>)>> for [[[T; X]; Y]; Z]

fn as_ref(&self) -> &Span<T, (Const<X>, Const<Y>, Const<Z>)>

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<Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>)>> for [[[[T; X]; Y]; Z]; W]

fn as_ref(&self) -> &Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>)>

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<Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>)>> for [[[[[T; X]; Y]; Z]; W]; U]

fn as_ref(&self) -> &Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>)>

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, const V: usize> AsRef<Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>, Const<V>)>> for [[[[[[T; X]; Y]; Z]; W]; U]; V]

fn as_ref( &self, ) -> &Span<T, (Const<X>, Const<Y>, Const<Z>, Const<W>, Const<U>, Const<V>)>

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

impl<T, const X: usize> AsRef<Span<T, Const<X>>> for [T; X]

fn as_ref(&self) -> &Span<T, Const<X>>

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

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

fn as_ref(&self) -> &Span<T, S, L>

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

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

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

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

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

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

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

where T: BitXorAssign<I::Item>,

fn bitxor_assign(&mut self, rhs: I)

Performs the ^= operation.

impl<B: Buffer> Borrow<Span<<B as Buffer>::Item, <B as Buffer>::Shape>> for IntoExpr<B>

fn borrow(&self) -> &Span<B::Item, B::Shape>

Immutably borrows from an owned value.

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

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

Immutably borrows from an owned value.

impl<T, S: Shape, A: Allocator> Borrow<Span<T, S>> for Grid<T, S, A>

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

Immutably borrows from an owned value.

impl<T, S: Shape, L: Layout> Borrow<Span<T, S, L>> for Expr<'_, T, S, L>

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

Immutably borrows from an owned value.

impl<T, S: Shape, L: Layout> Borrow<Span<T, S, L>> for ExprMut<'_, T, S, L>

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

Immutably borrows from an owned value.

impl<B: Buffer> BorrowMut<Span<<B as Buffer>::Item, <B as Buffer>::Shape>> for IntoExpr<B>

fn borrow_mut(&mut self) -> &mut Span<B::Item, B::Shape>

Mutably borrows from an owned value.

impl<T, S: ConstShape> BorrowMut<Span<T, S>> for Array<T, S>

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

Mutably borrows from an owned value.

impl<T, S: Shape, A: Allocator> BorrowMut<Span<T, S>> for Grid<T, S, A>

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

Mutably borrows from an owned value.

impl<T, S: Shape, L: Layout> BorrowMut<Span<T, S, L>> for ExprMut<'_, T, S, L>

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

Mutably borrows from an owned value.

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

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

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

type Output = <I as SpanIndex<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: SpanIndex<T, S, L>> IndexMut<I> for Span<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 Span<T, S, L>

type Shape = S

Array shape type.

type IntoExpr = Expr<'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 Span<T, S, L>

type Shape = S

Array shape type.

type IntoExpr = ExprMut<'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 Span<T, S, L>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<Expr<'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 Span<T, S, L>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = Iter<ExprMut<'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 Span<T, S, L>

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

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

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

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

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

type Output = <&'a Span<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<U, V, S: Shape, T: Shape, L: Layout, M: Layout, I: ?Sized> PartialEq<I> for Span<U, S, L>

where for<'a> &'a I: IntoExpression<IntoExpr = Expr<'a, V, T, M>>, U: PartialEq<V>,

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

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

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

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

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

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

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

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

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

type Owned = Grid<T, S>

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