Struct 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 as_dyn(&self) -> DynLayout

Convert this layout to one with a dynamic rank.

Trait Implementations

impl AsIndex<NdLayout<1>> for usize

fn as_index(&self) -> [usize; 1]

Convert self into an index for use the layout L.

impl<const N: usize> AsIndex<NdLayout<N>> for [usize; N]

fn as_index(&self) -> [usize; N]

Convert self into an index for use the layout L.

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

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

Returns a duplicate 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> 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 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 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, dims: [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], ) -> Result<(Range<usize>, NdLayout<M>), SliceError>

Slice the layout and return a static-rank layout.

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

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 index_axis( &self, axis: usize, index: usize, ) -> (Range<usize>, <Self as RemoveDim>::Output)

where Self: RemoveDim,

Slice a layout by selecting a single entry from a given axis.

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>, ) -> Result<(Range<usize>, Self), SliceError>

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>

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