Struct DynLayout 

pub struct DynLayout { /* private fields */ }

Defines the valid indices for an N-dimensional array and how to map them to offsets in a linear buffer, where N can be varied at runtime.

The layout specifies the size of each dimension of the tensor (the shape) and the stride (gap) between offsets in each dimension.

Implementations

impl DynLayout

pub fn make_contiguous(&mut self)

Trait Implementations

impl<T: AsRef<[usize]>> AsIndex<DynLayout> for T

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

Convert self into an index for use the layout L.

impl Clone for DynLayout

fn clone(&self) -> DynLayout

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynLayout

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

Formats the value using the given formatter.

impl<L: Layout> From<&L> for DynLayout

fn from(layout: &L) -> 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 Layout for DynLayout

fn len(&self) -> usize

Return the number of elements in the tensor shape described by this layout.

fn ndim(&self) -> usize

Return the number of dimensions.

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

Return the sizes of each dimension.

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

Returns the size of the dimension dim.

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

Return the stride (offset between elements) in the tensor’s element array.

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

Return the stride for a specific dimension.

type Index<'a> = &'a [usize]

Type used to represent indices.

type Indices = DynIndices

Iterator over indices in this tensor.

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

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

fn is_empty(&self) -> bool

Returns true if the array has no elements.

fn indices(&self) -> DynIndices

Return an iterator over all valid indices in this tensor.

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

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

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 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 MutLayout for DynLayout

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

Create a new contiguous layout with a given shape.

fn from_shape_and_strides( shape: &[usize], strides: &[usize], 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]) -> DynLayout

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

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

fn transposed(&self) -> DynLayout

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 PartialEq for DynLayout

fn eq(&self, other: &DynLayout) -> 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 ResizeLayout for DynLayout

fn insert_axis(&mut self, index: usize)

Insert a size-one axis at the given index in the shape. This will have the same stride as the dimension that follows it.

fn remove_axis_of_any_size(&mut self, index: usize)

Remove an axis that may have any size.

fn merge_axes(&mut self)

Merge consecutive axes where possible.

fn remove_axis(&mut self, index: usize)

Remove a size-1 axis at the given index.

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 StructuralPartialEq for DynLayout

impl TrustedLayout for DynLayout