Struct TensorSpan 

pub struct TensorSpan<'a, T, const MAX_RANK: usize = DEFAULT_MAX_RANK> { /* private fields */ }

A mutable view into a Tensor.

Implementations

impl<'a, T, const MAX_RANK: usize> TensorSpan<'a, T, MAX_RANK>

pub unsafe fn from_raw_parts( data: *mut T, shape: &[usize], strides_bytes: &[isize], ) -> Self

Create a mutable view from a raw pointer, shape, and byte strides.

Safety

• data must be valid for reads and writes over the region described by shape and strides_bytes.
• The pointed-to memory must outlive 'a.
• shape.len() must be <= MAX_RANK.
• shape.len() must equal strides_bytes.len().
• No other references to the memory may exist for the duration of 'a.

Panics

Panics if shape.len() > MAX_RANK or shape.len() != strides_bytes.len().

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

Returns the shape of the view.

pub fn ndim(&self) -> usize

Returns the number of dimensions.

pub fn rank(&self) -> usize

Returns the number of dimensions (alias for ndim()).

pub fn numel(&self) -> usize

Returns the total number of logical elements (computed from shape).

pub fn is_empty(&self) -> bool

Returns true if the view has no elements.

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

Returns the stride in bytes for the given dimension.

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

Returns a pointer to the first element.

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

Returns a mutable pointer to the first element.

pub fn has_contiguous_rows(&self) -> bool

Check if the view has contiguous rows.

pub fn is_contiguous(&self) -> bool

Check if the entire view is contiguous in memory.

pub fn as_view(&self) -> TensorView<'_, T, MAX_RANK>

Reborrow as immutable view.

pub fn try_flat<I: VectorIndex>(&self, index: I) -> Result<&T, TensorError>

Try to get an element by flat logical row-major index.

pub fn try_flat_mut<I: VectorIndex>( &mut self, index: I, ) -> Result<&mut T, TensorError>

Try to get a mutable element by flat logical row-major index.

pub fn try_coords<C: TensorCoordinates>( &self, coords: C, ) -> Result<&T, TensorError>

Try to get an element by exact coordinates.

pub fn try_coords_mut<C: TensorCoordinates>( &mut self, coords: C, ) -> Result<&mut T, TensorError>

Try to get a mutable element by exact coordinates.

pub fn try_scalar(&self) -> Result<&T, TensorError>

Try to access the scalar value of a rank-0 tensor span.

pub fn try_scalar_mut(&mut self) -> Result<&mut T, TensorError>

Try to access the mutable scalar value of a rank-0 tensor span.

pub fn slice_leading<I: VectorIndex>( &self, index: I, ) -> Result<TensorView<'_, T, MAX_RANK>, TensorError>

Slice the leading axis by one index, reducing rank by one.

pub fn slice_leading_mut<I: VectorIndex>( &mut self, index: I, ) -> Result<TensorSpan<'_, T, MAX_RANK>, TensorError>

Slice the leading axis mutably by one index, reducing rank by one.

pub fn slice( &self, spec: impl SliceSpec, ) -> Result<TensorView<'_, T, MAX_RANK>, TensorError>

Slice the span along multiple dimensions.

Accepts tuples of Rust range types or &[SliceRange].

pub fn slice_mut( &mut self, spec: impl SliceSpec, ) -> Result<TensorSpan<'_, T, MAX_RANK>, TensorError>

Slice the span mutably along multiple dimensions.

Accepts tuples of Rust range types or &[SliceRange].

impl<'a, T: StorageElement, const MAX_RANK: usize> TensorSpan<'a, T, MAX_RANK>

pub fn storage_len(&self) -> usize

Number of storage values (for sub-byte types, less than numel).

pub fn as_contiguous_slice(&self) -> Option<&[T]>

Convert to slice (only valid for contiguous views).

pub fn as_contiguous_slice_mut(&mut self) -> Option<&mut [T]>

Convert to mutable slice (only valid for contiguous views).

impl<'a, T: StorageElement, const MAX_RANK: usize> TensorSpan<'a, T, MAX_RANK>

pub fn transpose(&self) -> Result<TensorSpan<'a, T, MAX_RANK>, TensorError>

Transpose (reverse all dimensions, no data copy).

Returns an error for sub-byte types with ndim >= 2.

pub fn reshape( &self, new_shape: &[usize], ) -> Result<TensorSpan<'a, T, MAX_RANK>, TensorError>

Reshape the span (must have same total elements, contiguous only).

Returns an error for sub-byte types.

pub fn flatten(&self) -> Result<TensorSpan<'a, T, MAX_RANK>, TensorError>

Flatten to 1D (requires contiguous layout).

pub fn squeeze(&self) -> TensorSpan<'a, T, MAX_RANK>

Remove dimensions of size 1.

impl<'a, T: Clone + StorageElement, const MAX_RANK: usize> TensorSpan<'a, T, MAX_RANK>

pub fn to_owned(&self) -> Result<Tensor<T, Global, MAX_RANK>, TensorError>

Copy the span contents to a new owned Tensor.

impl<'a, T, const MAX_RANK: usize> TensorSpan<'a, T, MAX_RANK>

pub fn axis_spans<I: VectorIndex>( &mut self, axis: I, ) -> Result<AxisIteratorMut<'a, T, MAX_RANK>, TensorError>

Iterate mutably along the given axis, yielding sub-tensor spans with rank-1.

impl<'a, T: FloatConvertible, const MAX_RANK: usize> TensorSpan<'a, T, MAX_RANK>

pub fn iter(&self) -> TensorViewIterator<'_, T, MAX_RANK>

Returns a lazy iterator over all logical scalars in row-major order.

Yields (position, DimRef) pairs. Use .iter().dims() for just dimensions. For sub-byte types, the innermost dimension is expanded.

pub fn iter_mut(&mut self) -> TensorSpanIterator<'_, T, MAX_RANK>

Returns a mutable iterator over all logical scalars in row-major order.

Yields (position, DimMut) pairs. Use .iter_mut().dims() for just dimensions.

Trait Implementations

impl<'a, I0: VectorIndex, I1: VectorIndex, T, const MAX_RANK: usize> Index<(I0, I1)> for TensorSpan<'a, T, MAX_RANK>

type Output = T

The returned type after indexing.

fn index(&self, index: (I0, I1)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, T, const MAX_RANK: usize> Index<(I0, I1, I2)> for TensorSpan<'a, T, MAX_RANK>

type Output = T

The returned type after indexing.

fn index(&self, index: (I0, I1, I2)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, T, const MAX_RANK: usize> Index<(I0, I1, I2, I3)> for TensorSpan<'a, T, MAX_RANK>

type Output = T

The returned type after indexing.

fn index(&self, index: (I0, I1, I2, I3)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, I4: VectorIndex, T, const MAX_RANK: usize> Index<(I0, I1, I2, I3, I4)> for TensorSpan<'a, T, MAX_RANK>

type Output = T

The returned type after indexing.

fn index(&self, index: (I0, I1, I2, I3, I4)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, I4: VectorIndex, I5: VectorIndex, T, const MAX_RANK: usize> Index<(I0, I1, I2, I3, I4, I5)> for TensorSpan<'a, T, MAX_RANK>

type Output = T

The returned type after indexing.

fn index(&self, index: (I0, I1, I2, I3, I4, I5)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, I4: VectorIndex, I5: VectorIndex, I6: VectorIndex, T, const MAX_RANK: usize> Index<(I0, I1, I2, I3, I4, I5, I6)> for TensorSpan<'a, T, MAX_RANK>

type Output = T

The returned type after indexing.

fn index(&self, index: (I0, I1, I2, I3, I4, I5, I6)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, I4: VectorIndex, I5: VectorIndex, I6: VectorIndex, I7: VectorIndex, T, const MAX_RANK: usize> Index<(I0, I1, I2, I3, I4, I5, I6, I7)> for TensorSpan<'a, T, MAX_RANK>

type Output = T

The returned type after indexing.

fn index(&self, index: (I0, I1, I2, I3, I4, I5, I6, I7)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, I: VectorIndex, T, const MAX_RANK: usize> Index<I> for TensorSpan<'a, T, MAX_RANK>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, I0: VectorIndex, I1: VectorIndex, T, const MAX_RANK: usize> IndexMut<(I0, I1)> for TensorSpan<'a, T, MAX_RANK>

fn index_mut(&mut self, index: (I0, I1)) -> &mut Self::Output

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

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, T, const MAX_RANK: usize> IndexMut<(I0, I1, I2)> for TensorSpan<'a, T, MAX_RANK>

fn index_mut(&mut self, index: (I0, I1, I2)) -> &mut Self::Output

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

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, T, const MAX_RANK: usize> IndexMut<(I0, I1, I2, I3)> for TensorSpan<'a, T, MAX_RANK>

fn index_mut(&mut self, index: (I0, I1, I2, I3)) -> &mut Self::Output

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

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, I4: VectorIndex, T, const MAX_RANK: usize> IndexMut<(I0, I1, I2, I3, I4)> for TensorSpan<'a, T, MAX_RANK>

fn index_mut(&mut self, index: (I0, I1, I2, I3, I4)) -> &mut Self::Output

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

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, I4: VectorIndex, I5: VectorIndex, T, const MAX_RANK: usize> IndexMut<(I0, I1, I2, I3, I4, I5)> for TensorSpan<'a, T, MAX_RANK>

fn index_mut(&mut self, index: (I0, I1, I2, I3, I4, I5)) -> &mut Self::Output

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

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, I4: VectorIndex, I5: VectorIndex, I6: VectorIndex, T, const MAX_RANK: usize> IndexMut<(I0, I1, I2, I3, I4, I5, I6)> for TensorSpan<'a, T, MAX_RANK>

fn index_mut( &mut self, index: (I0, I1, I2, I3, I4, I5, I6), ) -> &mut Self::Output

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

impl<'a, I0: VectorIndex, I1: VectorIndex, I2: VectorIndex, I3: VectorIndex, I4: VectorIndex, I5: VectorIndex, I6: VectorIndex, I7: VectorIndex, T, const MAX_RANK: usize> IndexMut<(I0, I1, I2, I3, I4, I5, I6, I7)> for TensorSpan<'a, T, MAX_RANK>

fn index_mut( &mut self, index: (I0, I1, I2, I3, I4, I5, I6, I7), ) -> &mut Self::Output

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

impl<'a, I: VectorIndex, T, const MAX_RANK: usize> IndexMut<I> for TensorSpan<'a, T, MAX_RANK>

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

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

impl<'a, T: FloatConvertible, const MAX_RANK: usize> IntoIterator for &'a TensorSpan<'a, T, MAX_RANK>

type Item = ([usize; MAX_RANK], DimRef<'a, T>)

The type of the elements being iterated over.

type IntoIter = TensorViewIterator<'a, T, MAX_RANK>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: FloatConvertible, const MAX_RANK: usize> IntoIterator for &'a mut TensorSpan<'a, T, MAX_RANK>

type Item = ([usize; MAX_RANK], DimMut<'a, T>)

The type of the elements being iterated over.

type IntoIter = TensorSpanIterator<'a, T, MAX_RANK>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: FloatConvertible, const MAX_RANK: usize> PartialEq for TensorSpan<'a, T, MAX_RANK>

where T::DimScalar: PartialEq,

fn eq(&self, other: &Self) -> 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: StorageElement, const R: usize> TensorMut<T, R> for TensorSpan<'a, T, R>

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

impl<'a, T: StorageElement, const R: usize> TensorRef<T, R> for TensorSpan<'a, T, R>

fn shape(&self) -> &[usize]

fn ndim(&self) -> usize

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

fn as_ptr(&self) -> *const T

fn view(&self) -> TensorView<'_, T, R>

Borrow as an immutable TensorView.

fn numel(&self) -> usize

Total number of logical elements (product of shape dimensions).

fn rank(&self) -> usize

fn is_empty(&self) -> bool

fn has_contiguous_rows(&self) -> bool

fn is_contiguous(&self) -> bool