Struct MemoryLayout 

pub struct MemoryLayout {
    pub shape: Vec<usize>,
    pub strides: Vec<isize>,
    pub element_size: usize,
    pub total_size: usize,
    pub order: LayoutOrder,
    pub is_contiguous: bool,
    pub alignment: usize,
}

Memory layout information for arrays

Fields

shape: Vec<usize>

Shape of the array

strides: Vec<isize>

Strides for each dimension (in bytes)

element_size: usize

Element size in bytes

total_size: usize

Total size in bytes

order: LayoutOrder

Layout order

is_contiguous: bool

Whether the layout is contiguous

alignment: usize

Memory alignment in bytes

Implementations

impl MemoryLayout

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

Create a new C-order (row-major) layout

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

Create a new F-order (column-major) layout

pub fn new_with_order( shape: &[usize], order: LayoutOrder, element_size: usize, alignment: usize, ) -> Self

Create a new layout with specified order and element size

pub fn from_array<S, D>(array: &ArrayBase<S, D>) -> Self

where S: RawData, D: Dimension,

Create layout from existing array

pub fn calculate_strides( shape: &[usize], order: LayoutOrder, element_size: usize, ) -> Vec<isize>

Calculate strides for given shape and order

pub fn is_c_contiguous(&self) -> bool

Check if layout is C-contiguous

pub fn is_f_contiguous(&self) -> bool

Check if layout is F-contiguous

pub fn to_order(&self, neworder: LayoutOrder) -> CoreResult<Self>

Convert to different layout order

pub fn linear_index(&self, indices: &[usize]) -> CoreResult<usize>

Get linear index for multi-dimensional indices

pub fn multi_indices(&self, linearidx: usize) -> CoreResult<Vec<usize>>

Get multi-dimensional indices for linear index

pub fn memory_offset(&self, indices: &[usize]) -> CoreResult<usize>

Calculate memory offset for given indices

pub fn ndim(&self) -> usize

Get the number of dimensions

pub fn size(&self) -> usize

Get the size (number of elements)

pub fn nbytes(&self) -> usize

Get the number of bytes

pub fn is_compatible_with(&self, other: &MemoryLayout) -> bool

Check if layout is compatible with another layout

pub fn transpose(&self, axes: Option<&[usize]>) -> CoreResult<Self>

Create a transposed layout

pub fn reshape(&self, newshape: &[usize]) -> CoreResult<Self>

Reshape the layout to new shape

pub fn new_withshape_and_strides( &self, newshape: &[usize], new_strides: Option<&[isize]>, ) -> CoreResult<Self>

Create a view with different shape (without copying data)

Trait Implementations

impl Clone for MemoryLayout

fn clone(&self) -> MemoryLayout

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryLayout

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

Formats the value using the given formatter.