Struct mdarray::SpanBase

pub struct SpanBase<T, L: Copy> { /* private fields */ }

Multidimensional array span with static rank and element order.

Implementations

impl<T, L: Copy> SpanBase<T, 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 layout(&self) -> L

Returns the array layout.

pub fn to_view(&self) -> SubGrid<'_, T, L>

Returns an array view of the entire array span.

pub fn to_view_mut(&mut self) -> SubGridMut<'_, T, L>

Returns a mutable array view of the entire array span.

impl<T, D: Dim, F: Format> SpanBase<T, Layout<D, F>>

pub fn axis_iter<const DIM: usize>(
    &self
) -> AxisIter<'_, T, Layout<D::Lower, <Const<DIM> as Axis<D>>::Remove<F>>>where
    Const<DIM>: Axis<D>,

Returns an iterator that gives array views over the specified dimension.

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

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

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

pub fn axis_iter_mut<const DIM: usize>(
    &mut self
) -> AxisIterMut<'_, T, Layout<D::Lower, <Const<DIM> as Axis<D>>::Remove<F>>>where
    Const<DIM>: Axis<D>,

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

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

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

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

pub fn clone_from_span(&mut self, src: &SpanBase<T, Layout<D, impl Format>>)where
    T: Clone,

Clones an array span into the array span.

Panics

Panics if the two spans have different shapes.

pub fn fill(&mut self, value: impl Borrow<T>)where
    T: Clone,

Fills the array span with elements by cloning value.

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

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

pub fn flatten(&self) -> SubGrid<'_, T, Layout<Rank<1, D::Order>, F::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
) -> SubGridMut<'_, T, Layout<Rank<1, D::Order>, F::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>(&self, index: I) -> &I::Outputwhere
    I: SpanIndex<T, Layout<D, F>>,

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>(&mut self, index: I) -> &mut I::Outputwhere
    I: SpanIndex<T, Layout<D, F>>,

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 grid<P: Params, I>(&self, index: I) -> DenseGrid<T, P::Dim>where
    T: Clone,
    I: ViewIndex<D, F, Params = P>,

Copies the specified subarray into a new array.

Panics

Panics if the subarray is out of bounds.

pub fn inner_iter(
    &self
) -> AxisIter<'_, T, Layout<D::Lower, <D::Lower as Dim>::Format<F::NonUnitStrided>>>

Returns an iterator that gives array views over the inner dimension.

Iterating over the inner dimension maintains the uniform stride property but not unit inner stride, so that the resulting array views have flat or strided format.

Panics

Panics if the rank is not at least 1.

pub fn inner_iter_mut(
    &mut self
) -> AxisIterMut<'_, T, Layout<D::Lower, <D::Lower as Dim>::Format<F::NonUnitStrided>>>

Returns a mutable iterator that gives array views over the inner dimension.

Iterating over the inner dimension maintains the uniform stride property but not unit inner stride, so that the resulting array views have flat or strided format.

Panics

Panics if the rank is not at least 1.

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) -> F::Iter<'_, T>where
    F: Uniform,

Returns an iterator over the array span, which must support linear indexing.

pub fn iter_mut(&mut self) -> F::IterMut<'_, T>where
    F: Uniform,

Returns a mutable iterator over the array span, which must support linear indexing.

pub fn len(&self) -> usize

Returns the number of elements in the array.

pub fn outer_iter(
    &self
) -> AxisIter<'_, T, Layout<D::Lower, <D::Lower as Dim>::Format<F>>>

Returns an iterator that gives array views over the outer dimension.

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

Panics

Panics if the rank is not at least 1.

pub fn outer_iter_mut(
    &mut self
) -> AxisIterMut<'_, T, Layout<D::Lower, <D::Lower as Dim>::Format<F>>>

Returns a mutable iterator that gives array views over the outer dimension.

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

Panics

Panics if the rank is not at least 1.

pub fn reformat<G: Format>(&self) -> SubGrid<'_, T, Layout<D, G>>

Returns a reformatted array view of the array span.

Panics

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

pub fn reformat_mut<G: Format>(&mut self) -> SubGridMut<'_, T, Layout<D, G>>

Returns a mutable reformatted array view of the array span.

Panics

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

pub fn reshape<S: Shape>(
    &self,
    shape: S
) -> SubGrid<'_, T, Layout<S::Dim<D::Order>, <S::Dim<D::Order> as Dim>::Format<F>>>

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<S: Shape>(
    &mut self,
    shape: S
) -> SubGridMut<'_, T, Layout<S::Dim<D::Order>, <S::Dim<D::Order> as Dim>::Format<F>>>

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 shape(&self) -> D::Shape

Returns the shape of the array.

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

Returns the number of elements in the specified dimension.

pub fn split_at(
    &self,
    mid: usize
) -> (SubGrid<'_, T, Layout<D, F>>, SubGrid<'_, T, Layout<D, F>>)

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

Panics

Panics if the split point is larger than the number of elements in that dimension.

pub fn split_at_mut(
    &mut self,
    mid: usize
) -> (SubGridMut<'_, T, Layout<D, F>>, SubGridMut<'_, T, Layout<D, F>>)

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

Panics

Panics if the split point is larger than the number of elements in that dimension.

pub fn split_axis_at<const DIM: usize>(
    &self,
    mid: usize
) -> (SubGrid<'_, T, Layout<D, <Const<DIM> as Axis<D>>::Split<F>>>, SubGrid<'_, T, Layout<D, <Const<DIM> as Axis<D>>::Split<F>>>)where
    Const<DIM>: Axis<D>,

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.

pub fn split_axis_at_mut<const DIM: usize>(
    &mut self,
    mid: usize
) -> (SubGridMut<'_, T, Layout<D, <Const<DIM> as Axis<D>>::Split<F>>>, SubGridMut<'_, T, Layout<D, <Const<DIM> as Axis<D>>::Split<F>>>)where
    Const<DIM>: Axis<D>,

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.

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

Returns the distance between elements in the specified dimension.

pub fn strides(&self) -> D::Strides

Returns the distance between elements in each dimension.

pub fn to_grid(&self) -> DenseGrid<T, D>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.

pub fn view<I>(
    &self,
    index: I
) -> SubGrid<'_, T, Layout<<I::Params as Params>::Dim, <I::Params as Params>::Format>>where
    I: ViewIndex<D, F>,

Returns an array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

pub fn view_mut<I>(
    &mut self,
    index: I
) -> SubGridMut<'_, T, Layout<<I::Params as Params>::Dim, <I::Params as Params>::Format>>where
    I: ViewIndex<D, F>,

Returns a mutable array view for the specified subarray.

Panics

Panics if the subarray is out of bounds.

impl<T, D: Dim> SpanBase<T, Layout<D, Dense>>

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

Returns a mutable slice of all elements in the array.

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

Returns a slice of all elements in the array.

Trait Implementations

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> Add<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Add<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the + operator.

fn add(self, rhs: &GridBase<B>) -> Self::Output

Performs the + operation.

impl<T: Default, U, D: Dim, F: Format, A> Add<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: Add<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the + operator.

fn add(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the + operation.

impl<T: Copy, U, V, D: Dim, F: Format> Add<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: Add<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the + operator.

fn add(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the + operation.

impl<T, U, V, D: Dim, F: Format, G: Format> Add<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Add<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the + operator.

fn add(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the + operation.

impl<T, U: Copy, V, D: Dim, F: Format> Add<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Add<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the + operator.

fn add(self, rhs: Fill<U>) -> Self::Output

Performs the + operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> Add<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Add<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the + operator.

fn add(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the + operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> AddAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: AddAssign<&'a B::Item>,

fn add_assign(&mut self, rhs: &GridBase<B>)

Performs the += operation.

impl<T, U, D: Dim, F: Format, G: Format> AddAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: AddAssign<&'a U>,

fn add_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the += operation.

impl<T, U: Copy, D: Dim, F: Format> AddAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: AddAssign<U>,

fn add_assign(&mut self, rhs: Fill<U>)

Performs the += operation.

impl<T, D: Dim> AsMut<[T]> for SpanBase<T, Layout<D, Dense>>

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

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

impl<T, D: Dim> AsRef<[T]> for SpanBase<T, Layout<D, Dense>>

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

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

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> BitAnd<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: BitAnd<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &GridBase<B>) -> Self::Output

Performs the & operation.

impl<T: Default, U, D: Dim, F: Format, A> BitAnd<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: BitAnd<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the & operation.

impl<T: Copy, U, V, D: Dim, F: Format> BitAnd<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: BitAnd<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the & operation.

impl<T, U, V, D: Dim, F: Format, G: Format> BitAnd<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: BitAnd<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the & operator.

fn bitand(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the & operation.

impl<T, U: Copy, V, D: Dim, F: Format> BitAnd<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: BitAnd<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Fill<U>) -> Self::Output

Performs the & operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> BitAnd<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: BitAnd<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the & operator.

fn bitand(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the & operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> BitAndAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: BitAndAssign<&'a B::Item>,

fn bitand_assign(&mut self, rhs: &GridBase<B>)

Performs the &= operation.

impl<T, U, D: Dim, F: Format, G: Format> BitAndAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: BitAndAssign<&'a U>,

fn bitand_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the &= operation.

impl<T, U: Copy, D: Dim, F: Format> BitAndAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: BitAndAssign<U>,

fn bitand_assign(&mut self, rhs: Fill<U>)

Performs the &= operation.

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> BitOr<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: BitOr<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &GridBase<B>) -> Self::Output

Performs the | operation.

impl<T: Default, U, D: Dim, F: Format, A> BitOr<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: BitOr<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the | operation.

impl<T: Copy, U, V, D: Dim, F: Format> BitOr<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: BitOr<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the | operation.

impl<T, U, V, D: Dim, F: Format, G: Format> BitOr<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: BitOr<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the | operator.

fn bitor(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the | operation.

impl<T, U: Copy, V, D: Dim, F: Format> BitOr<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: BitOr<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Fill<U>) -> Self::Output

Performs the | operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> BitOr<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: BitOr<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the | operator.

fn bitor(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the | operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> BitOrAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: BitOrAssign<&'a B::Item>,

fn bitor_assign(&mut self, rhs: &GridBase<B>)

Performs the |= operation.

impl<T, U, D: Dim, F: Format, G: Format> BitOrAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: BitOrAssign<&'a U>,

fn bitor_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the |= operation.

impl<T, U: Copy, D: Dim, F: Format> BitOrAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: BitOrAssign<U>,

fn bitor_assign(&mut self, rhs: Fill<U>)

Performs the |= operation.

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> BitXor<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: BitXor<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &GridBase<B>) -> Self::Output

Performs the ^ operation.

impl<T: Default, U, D: Dim, F: Format, A> BitXor<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: BitXor<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the ^ operation.

impl<T: Copy, U, V, D: Dim, F: Format> BitXor<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: BitXor<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the ^ operation.

impl<T, U, V, D: Dim, F: Format, G: Format> BitXor<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: BitXor<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the ^ operation.

impl<T, U: Copy, V, D: Dim, F: Format> BitXor<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: BitXor<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Fill<U>) -> Self::Output

Performs the ^ operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> BitXor<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: BitXor<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the ^ operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> BitXorAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: BitXorAssign<&'a B::Item>,

fn bitxor_assign(&mut self, rhs: &GridBase<B>)

Performs the ^= operation.

impl<T, U, D: Dim, F: Format, G: Format> BitXorAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: BitXorAssign<&'a U>,

fn bitxor_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the ^= operation.

impl<T, U: Copy, D: Dim, F: Format> BitXorAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: BitXorAssign<U>,

fn bitxor_assign(&mut self, rhs: Fill<U>)

Performs the ^= operation.

impl<T, D: Dim, A: Allocator> Borrow<SpanBase<T, Layout<D, Dense>>> for DenseGrid<T, D, A>

fn borrow(&self) -> &SpanBase<T, Layout<D, Dense>>

Immutably borrows from an owned value.

impl<T, D: Dim, A: Allocator> BorrowMut<SpanBase<T, Layout<D, Dense>>> for DenseGrid<T, D, A>

fn borrow_mut(&mut self) -> &mut SpanBase<T, Layout<D, Dense>>

Mutably borrows from an owned value.

impl<T: Debug, D: Dim, F: Format> Debug for SpanBase<T, Layout<D, F>>

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

Formats the value using the given formatter.

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> Div<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Div<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the / operator.

fn div(self, rhs: &GridBase<B>) -> Self::Output

Performs the / operation.

impl<T: Default, U, D: Dim, F: Format, A> Div<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: Div<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the / operator.

fn div(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the / operation.

impl<T: Copy, U, V, D: Dim, F: Format> Div<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: Div<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the / operator.

fn div(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the / operation.

impl<T, U, V, D: Dim, F: Format, G: Format> Div<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Div<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the / operator.

fn div(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the / operation.

impl<T, U: Copy, V, D: Dim, F: Format> Div<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Div<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the / operator.

fn div(self, rhs: Fill<U>) -> Self::Output

Performs the / operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> Div<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Div<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the / operator.

fn div(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the / operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> DivAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: DivAssign<&'a B::Item>,

fn div_assign(&mut self, rhs: &GridBase<B>)

Performs the /= operation.

impl<T, U, D: Dim, F: Format, G: Format> DivAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: DivAssign<&'a U>,

fn div_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the /= operation.

impl<T, U: Copy, D: Dim, F: Format> DivAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: DivAssign<U>,

fn div_assign(&mut self, rhs: Fill<U>)

Performs the /= operation.

impl<T: Hash, D: Dim, F: Format> Hash for SpanBase<T, Layout<D, F>>

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, L: Copy, I: SpanIndex<T, L>> Index<I> for SpanBase<T, L>

type Output = <I as SpanIndex<T, L>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, L: Copy, I: SpanIndex<T, L>> IndexMut<I> for SpanBase<T, L>

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

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

impl<'a, T, D: Dim, F: Uniform> IntoIterator for &'a SpanBase<T, Layout<D, F>>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = <F as Format>::Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, D: Dim, F: Uniform> IntoIterator for &'a mut SpanBase<T, Layout<D, F>>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = <F as Format>::IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> Mul<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Mul<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the * operator.

fn mul(self, rhs: &GridBase<B>) -> Self::Output

Performs the * operation.

impl<T: Default, U, D: Dim, F: Format, A> Mul<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: Mul<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the * operation.

impl<T: Copy, U, V, D: Dim, F: Format> Mul<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: Mul<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the * operation.

impl<T, U, V, D: Dim, F: Format, G: Format> Mul<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Mul<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the * operation.

impl<T, U: Copy, V, D: Dim, F: Format> Mul<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Mul<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the * operator.

fn mul(self, rhs: Fill<U>) -> Self::Output

Performs the * operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> Mul<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Mul<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the * operator.

fn mul(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the * operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> MulAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: MulAssign<&'a B::Item>,

fn mul_assign(&mut self, rhs: &GridBase<B>)

Performs the *= operation.

impl<T, U, D: Dim, F: Format, G: Format> MulAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: MulAssign<&'a U>,

fn mul_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the *= operation.

impl<T, U: Copy, D: Dim, F: Format> MulAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: MulAssign<U>,

fn mul_assign(&mut self, rhs: Fill<U>)

Performs the *= operation.

impl<T, D: Dim, F: Format> Neg for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Neg<Output = T>,

type Output = GridBase<DenseBuffer<T, D, Global>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, D: Dim, F: Format> Not for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Not<Output = T>,

type Output = GridBase<DenseBuffer<T, D, Global>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: Ord, F: Format, O: Order> Ord for SpanBase<T, Layout<Rank<1, O>, F>>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> PartialEq<GridBase<B>> for SpanBase<T, Layout<D, F>>where
    T: PartialEq<B::Item>,

fn eq(&self, other: &GridBase<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T, U, D: Dim, F: Format, G: Format> PartialEq<SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    T: PartialEq<U>,

fn eq(&self, other: &SpanBase<U, Layout<D, G>>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T, F: Format, O: Order, B: Buffer<Layout = Layout<Rank<1, O>, impl Format>>> PartialOrd<GridBase<B>> for SpanBase<T, Layout<Rank<1, O>, F>>where
    T: PartialOrd<B::Item>,

fn partial_cmp(&self, other: &GridBase<B>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U, F: Format, G: Format, O: Order> PartialOrd<SpanBase<U, Layout<Rank<1, O>, G>>> for SpanBase<T, Layout<Rank<1, O>, F>>where
    T: PartialOrd<U>,

fn partial_cmp(
    &self,
    other: &SpanBase<U, Layout<Rank<1, O>, G>>
) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> Rem<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Rem<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the % operator.

fn rem(self, rhs: &GridBase<B>) -> Self::Output

Performs the % operation.

impl<T: Default, U, D: Dim, F: Format, A> Rem<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: Rem<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the % operator.

fn rem(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the % operation.

impl<T: Copy, U, V, D: Dim, F: Format> Rem<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: Rem<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the % operator.

fn rem(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the % operation.

impl<T, U, V, D: Dim, F: Format, G: Format> Rem<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Rem<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the % operator.

fn rem(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the % operation.

impl<T, U: Copy, V, D: Dim, F: Format> Rem<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Rem<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the % operator.

fn rem(self, rhs: Fill<U>) -> Self::Output

Performs the % operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> Rem<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Rem<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the % operator.

fn rem(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the % operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> RemAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: RemAssign<&'a B::Item>,

fn rem_assign(&mut self, rhs: &GridBase<B>)

Performs the %= operation.

impl<T, U, D: Dim, F: Format, G: Format> RemAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: RemAssign<&'a U>,

fn rem_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the %= operation.

impl<T, U: Copy, D: Dim, F: Format> RemAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: RemAssign<U>,

fn rem_assign(&mut self, rhs: Fill<U>)

Performs the %= operation.

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> Shl<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Shl<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the << operator.

fn shl(self, rhs: &GridBase<B>) -> Self::Output

Performs the << operation.

impl<T: Default, U, D: Dim, F: Format, A> Shl<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: Shl<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the << operator.

fn shl(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the << operation.

impl<T: Copy, U, V, D: Dim, F: Format> Shl<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: Shl<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the << operator.

fn shl(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the << operation.

impl<T, U, V, D: Dim, F: Format, G: Format> Shl<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Shl<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the << operator.

fn shl(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the << operation.

impl<T, U: Copy, V, D: Dim, F: Format> Shl<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Shl<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the << operator.

fn shl(self, rhs: Fill<U>) -> Self::Output

Performs the << operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> Shl<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Shl<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the << operator.

fn shl(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the << operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> ShlAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: ShlAssign<&'a B::Item>,

fn shl_assign(&mut self, rhs: &GridBase<B>)

Performs the <<= operation.

impl<T, U, D: Dim, F: Format, G: Format> ShlAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: ShlAssign<&'a U>,

fn shl_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the <<= operation.

impl<T, U: Copy, D: Dim, F: Format> ShlAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: ShlAssign<U>,

fn shl_assign(&mut self, rhs: Fill<U>)

Performs the <<= operation.

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> Shr<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Shr<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the >> operator.

fn shr(self, rhs: &GridBase<B>) -> Self::Output

Performs the >> operation.

impl<T: Default, U, D: Dim, F: Format, A> Shr<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: Shr<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the >> operator.

fn shr(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the >> operation.

impl<T: Copy, U, V, D: Dim, F: Format> Shr<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: Shr<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the >> operator.

fn shr(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the >> operation.

impl<T, U, V, D: Dim, F: Format, G: Format> Shr<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Shr<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the >> operator.

fn shr(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the >> operation.

impl<T, U: Copy, V, D: Dim, F: Format> Shr<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Shr<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Fill<U>) -> Self::Output

Performs the >> operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> Shr<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Shr<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the >> operator.

fn shr(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the >> operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> ShrAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: ShrAssign<&'a B::Item>,

fn shr_assign(&mut self, rhs: &GridBase<B>)

Performs the >>= operation.

impl<T, U, D: Dim, F: Format, G: Format> ShrAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: ShrAssign<&'a U>,

fn shr_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the >>= operation.

impl<T, U: Copy, D: Dim, F: Format> ShrAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: ShrAssign<U>,

fn shr_assign(&mut self, rhs: Fill<U>)

Performs the >>= operation.

impl<T, U, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> Sub<&GridBase<B>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Sub<&'b B::Item, Output = U>,

type Output = GridBase<DenseBuffer<U, D, Global>>

The resulting type after applying the - operator.

fn sub(self, rhs: &GridBase<B>) -> Self::Output

Performs the - operation.

impl<T: Default, U, D: Dim, F: Format, A> Sub<&SpanBase<U, Layout<D, F>>> for DenseGrid<T, D, A>where
    for<'a> T: Sub<&'a U, Output = T>,
    A: Allocator,

type Output = GridBase<DenseBuffer<T, D, A>>

The resulting type after applying the - operator.

fn sub(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self

Performs the - operation.

impl<T: Copy, U, V, D: Dim, F: Format> Sub<&SpanBase<U, Layout<D, F>>> for Fill<T>where
    for<'a> T: Sub<&'a U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the - operator.

fn sub(self, rhs: &SpanBase<U, Layout<D, F>>) -> Self::Output

Performs the - operation.

impl<T, U, V, D: Dim, F: Format, G: Format> Sub<&SpanBase<U, Layout<D, G>>> for &SpanBase<T, Layout<D, F>>where
    for<'a, 'b> &'a T: Sub<&'b U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the - operator.

fn sub(self, rhs: &SpanBase<U, Layout<D, G>>) -> Self::Output

Performs the - operation.

impl<T, U: Copy, V, D: Dim, F: Format> Sub<Fill<U>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Sub<U, Output = V>,

type Output = GridBase<DenseBuffer<V, D, Global>>

The resulting type after applying the - operator.

fn sub(self, rhs: Fill<U>) -> Self::Output

Performs the - operation.

impl<T, U: Default, D: Dim, F: Format, A: Allocator> Sub<GridBase<DenseBuffer<U, D, A>>> for &SpanBase<T, Layout<D, F>>where
    for<'a> &'a T: Sub<U, Output = U>,

type Output = GridBase<DenseBuffer<U, D, A>>

The resulting type after applying the - operator.

fn sub(self, rhs: DenseGrid<U, D, A>) -> Self::Output

Performs the - operation.

impl<T, D: Dim, F: Format, B: Buffer<Layout = Layout<D, impl Format>>> SubAssign<&GridBase<B>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: SubAssign<&'a B::Item>,

fn sub_assign(&mut self, rhs: &GridBase<B>)

Performs the -= operation.

impl<T, U, D: Dim, F: Format, G: Format> SubAssign<&SpanBase<U, Layout<D, G>>> for SpanBase<T, Layout<D, F>>where
    for<'a> T: SubAssign<&'a U>,

fn sub_assign(&mut self, rhs: &SpanBase<U, Layout<D, G>>)

Performs the -= operation.

impl<T, U: Copy, D: Dim, F: Format> SubAssign<Fill<U>> for SpanBase<T, Layout<D, F>>where
    T: SubAssign<U>,

fn sub_assign(&mut self, rhs: Fill<U>)

Performs the -= operation.

impl<T: Clone, D: Dim> ToOwned for SpanBase<T, Layout<D, Dense>>

type Owned = GridBase<DenseBuffer<T, D, Global>>

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, L: Copy> Eq for SpanBase<T, L>where
    Self: PartialEq,

impl<T: Send, L: Copy> Send for SpanBase<T, L>

impl<T: Sync, L: Copy> Sync for SpanBase<T, L>