Struct rten_tensor::NdLayout

pub struct NdLayout<const N: usize> { /* private fields */ }

Defines the valid indices for an N-dimensional array and how to map them to offsets in a linear buffer, where N is known at compile time.

Implementations

impl<const N: usize> NdLayout<N>

pub fn from_dyn(l: DynLayout) -> Self

Convert a layout with dynamic rank to a layout with a static rank.

Panics if l does not have N dimensions.

pub fn as_dyn(&self) -> DynLayout

Convert this layout to one with a dynamic rank.

pub fn index_valid(&self, index: [usize; N]) -> bool

Return true if all components of index are in-bounds.

pub fn contiguous_strides(shape: [usize; N]) -> [usize; N]

Return the strides that a contiguous layout with a given shape would have.

pub fn from_shape(shape: [usize; N]) -> Self

Create a layout with a given shape and a contiguous layout.

pub fn try_from_shape_and_strides( shape: [usize; N], strides: [usize; N], overlap: OverlapPolicy, ) -> Result<NdLayout<N>, FromDataError>

Create a layout with given shape and strides, intended for use with data storage of length data_len.

overlap determines whether this method will fail if the layout may have internal overlap.

pub fn broadcast<const M: usize>(&self, to_shape: [usize; M]) -> NdLayout<M>

Construct a layout which broadcasts elements to to_shape by setting the stride to 0 in broadcasted dimensions.

pub fn permuted(&self, dims: [usize; N]) -> Self

Swap strides of this layout to put axes in the given order.

Values in dims must be < N.

pub fn transposed(&self) -> Self

Reverse the order of dimensions in this layout.

pub fn slice<const M: usize>( &self, range: &[SliceItem], ) -> (Range<usize>, NdLayout<M>)

Compute the new layout and offset of the first element for a slice into an existing tensor view.

Returns a tuple of (offset_range, layout) for the sliced view.

pub fn resize_dim(&mut self, dim: usize, new_size: usize)

Trait Implementations

impl<const N: usize> Clone for NdLayout<N>

fn clone(&self) -> NdLayout<N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for NdLayout<N>

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

Formats the value using the given formatter.

impl<const N: usize> From<&NdLayout<N>> for DynLayout

fn from(value: &NdLayout<N>) -> DynLayout

Converts to this type from the input type.

impl<const N: usize> From<NdLayout<N>> for DynLayout

fn from(value: NdLayout<N>) -> DynLayout

Converts to this type from the input type.

impl<const N: usize> Layout for NdLayout<N>

type Index<'a> = [usize; N]

Type used to represent indices.

type Indices = NdIndices<N>

Iterator over indices in this tensor.

fn ndim(&self) -> usize

Return the number of dimensions.

fn len(&self) -> usize

Returns the number of elements in the array.

fn try_offset(&self, index: [usize; N]) -> Option<usize>

Map an index to a storage offset, or return None if the index is out of bounds along any dimension.

fn offset_unchecked(&self, index: [usize; N]) -> usize

Map an index to a storage offset, without checking if it is valid for the tensor’s shape.

fn shape(&self) -> Self::Index<'_>

Returns an array of the sizes of each dimension.

fn strides(&self) -> Self::Index<'_>

Returns an array of the strides of each dimension.

fn indices(&self) -> Self::Indices

Return an iterator over all valid indices in this tensor.

fn offset(&self, index: Self::Index<'_>) -> usize

Map an index to a storage offset.

fn is_contiguous(&self) -> bool

Return true if this layout describes a contiguous tensor, where the logical order of elements matches the order in which they are stored.

fn is_broadcast(&self) -> bool

Return true if iterating over elements in this layout will visit elements multiple times.

fn is_empty(&self) -> bool

Returns true if the array has no elements.

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

Returns the size of the dimension dim.

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

Returns the offset between adjacent indices along dimension dim.

fn can_broadcast_to(&self, target_shape: &[usize]) -> bool

Return true if this layout’s shape can be broadcast to the given shape.

fn can_broadcast_with(&self, shape: &[usize]) -> bool

Return true if the tensor/view can be broadcast with another tensor or view with a given shape as part of a binary operation.

fn min_data_len(&self) -> usize

Return the minimum length required for the element data buffer used with this layout.

impl MatrixLayout for NdLayout<2>

fn rows(&self) -> usize

fn cols(&self) -> usize

fn row_stride(&self) -> usize

fn col_stride(&self) -> usize

impl<const N: usize> MutLayout for NdLayout<N>

fn from_shape(shape: [usize; N]) -> Self

Create a new contiguous layout with a given shape.

fn from_shape_and_strides( shape: Self::Index<'_>, strides: Self::Index<'_>, overlap: OverlapPolicy, ) -> Result<Self, FromDataError>

Create a layout with custom strides.

fn move_axis(&mut self, from: usize, to: usize)

Move the axis at position from to to by swapping their strides.

fn permuted(&self, order: [usize; N]) -> NdLayout<N>

Return a layout with the axes permuted according to the given order.

fn resize_dim(&mut self, dim: usize, size: usize)

fn transposed(&self) -> NdLayout<N>

Reverse the order of dimensions. This is equivalent to self.permuted([N-1, N-2, ... 0]).

fn slice<const M: usize>( &self, range: &[SliceItem], ) -> (Range<usize>, NdLayout<M>)

Slice the layout.

fn slice_dyn(&self, range: &[SliceItem]) -> (Range<usize>, DynLayout)

Slice the layout and return a dynamic rank layout.

fn squeezed(&self) -> DynLayout

Return a layout with all size-one dimensions removed.

fn split( &self, axis: usize, mid: usize, ) -> ((Range<usize>, Self), (Range<usize>, Self))

Split the layout along the given axis into two.

fn try_slice<R: IntoSliceItems>( &self, range: R, ) -> Result<(Range<usize>, DynLayout), SliceError>

Attempt to slice the layout or return an error if the range is invalid for the layout’s shape.

fn reshaped_for_view<S: IntoLayout>( &self, shape: S, ) -> Result<S::Layout, ReshapeError>

Return a new layout formed by reshaping this one to shape.

fn reshaped_for_copy<S: IntoLayout>( &self, shape: S, ) -> Result<S::Layout, ReshapeError>

Return a new layout formed by reshaping this one to shape.

fn slice_axis(&self, axis: usize, range: Range<usize>) -> (Range<usize>, Self)

Slice the layout along a given axis.

impl<const N: usize> PartialEq for NdLayout<N>

fn eq(&self, other: &NdLayout<N>) -> 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, const N: usize> TryFrom<&'a DynLayout> for NdLayout<N>

fn try_from(value: &'a DynLayout) -> Result<NdLayout<N>, DimensionError>

Convert a dynamic layout into a static layout with N dims. Fails if value.ndim() != N.

type Error = DimensionError

The type returned in the event of a conversion error.

impl<const N: usize> Copy for NdLayout<N>

impl<const N: usize> StructuralPartialEq for NdLayout<N>