Struct Layout 

pub struct Layout { /* private fields */ }

Layout describes how to interpret a linear buffer as an N-dimensional tensor.

Stores shape, strides (in elements, can be negative for flipped dimensions), and a start offset for views/slices.

Implementations

impl Layout

pub fn contiguous(shape: Shape) -> Self

Create a new contiguous layout (row-major/C-order).

pub fn new(shape: Shape, strides: Vec<isize>, start_offset: usize) -> Self

Create a layout with explicit strides.

pub fn shape(&self) -> &Shape

The shape of the tensor.

pub fn strides(&self) -> &[isize]

The strides in elements (can be negative for flipped dimensions).

pub fn start_offset(&self) -> usize

The start offset for views/slices.

pub fn num_dims(&self) -> usize

Number of dimensions.

pub fn num_elements(&self) -> usize

Total number of elements.

pub fn is_contiguous(&self) -> bool

Check if this layout is contiguous (row-major, positive strides).

pub fn contiguous_offsets(&self) -> Option<(usize, usize)>

If contiguous, return (start, end) offsets for direct slice access.

pub fn transpose(&self, dim1: usize, dim2: usize) -> Self

Transpose: swap two dimensions (zero-copy, metadata only).

pub fn permute(&self, axes: &[usize]) -> Self

Permute: reorder dimensions according to axes (zero-copy, metadata only).

axes must be a permutation of 0..ndim.

pub fn flip(&self, axes: &[usize]) -> Self

Flip: reverse elements along specified axes (zero-copy, metadata only).

For each flipped axis, negates the stride and adjusts start_offset to point to the last element along that dimension.

pub fn narrow(&self, dim: usize, start: usize, len: usize) -> Self

Narrow/slice along a dimension (zero-copy, metadata only).

pub fn slice(&self, slices: &[Slice]) -> (Self, bool)

Apply slices to create a new layout.

Returns (new_layout, needs_copy):

• needs_copy = false: Can use zero-copy view with new layout
• needs_copy = true: Has negative steps requiring data reordering

pub fn reshape(&self, new_shape: Shape) -> Option<Self>

Reshape to a new shape. Only works if contiguous with zero offset.

Returns None if not contiguous or has non-zero offset (would require data copy).

pub fn index(&self, indices: &[usize]) -> usize

Compute linear index from multi-dimensional indices.

pub fn inner_stride(&self) -> usize

Get stride of the innermost (last) dimension. Returns 1 for contiguous tensors, larger values for transposed. Returns absolute value (ignores flip).

pub fn has_contiguous_inner(&self) -> bool

Check if innermost dimension is contiguous (|stride| == 1). This enables efficient vectorized inner loops.

pub fn as_2d_strides(&self) -> Option<(usize, usize, isize, isize)>

For 2D layouts, get (outer_size, inner_size, outer_stride, inner_stride). Returns None if not 2D.

pub fn has_positive_strides(&self) -> bool

Check if all strides are non-negative.

pub fn strided_blocks(&self) -> StridedBlocks<'_>

Compute strided blocks for efficient iteration.

Returns (block_len, num_blocks, block_stride) where:

• block_len: number of contiguous elements in each block
• num_blocks: total number of blocks
• block_stride: stride between consecutive blocks (0 if single block)

For contiguous tensors: single block covering all elements. For transposed/strided: multiple blocks of contiguous data.

Trait Implementations

impl Clone for Layout

fn clone(&self) -> Layout

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Layout

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

Formats the value using the given formatter.

impl PartialEq for Layout

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

impl StructuralPartialEq for Layout