Struct StridedView

Source

pub struct StridedView<'a, T, Op = Identity> { /* private fields */ }

Expand description

Dynamic-rank immutable strided view with lazy element operations.

This is the Julia-equivalent StridedView type with:

Dynamic rank, with metadata stored inline for up to INLINE_RANK dimensions (StridedView::new copies the caller’s layout, so the view borrows only the element data)
Lazy element operations via the Op type parameter
Zero-copy transformations (permute, transpose, adjoint, conj)

§Type Parameters

'a: Lifetime of the underlying data
T: Element type
Op: Element operation applied lazily on access (default: Identity)

§Size

The inline metadata makes the view 184 bytes on 64-bit targets for usize/isize strides.

§Auto traits

The view borrows its elements, so it is Send only when T: Sync (a shared slice is). A view of non-Sync data is not Send:

use std::cell::Cell;
use strided_view::StridedView;

fn assert_send<T: Send>() {}
assert_send::<StridedView<'static, Cell<i32>>>();

Implementations§

Source §

impl<'a, T, Op> StridedView<'a, T, Op>

Source

pub fn new( data: &'a [T], dims: &[usize], strides: &[isize], offset: isize, ) -> Result<StridedView<'a, T, Op>, StridedError>

Create an immutable strided view, copying the caller’s metadata inline.

The layout is copied into the view’s inline storage, so it does not need to outlive the view and no heap allocation happens at rank <= INLINE_RANK. The view’s lifetime is tied to data only.

§Examples

use strided_view::StridedView;

let data = [1.0f64, 2.0, 3.0, 4.0, 5.0, 6.0];
let view = StridedView::<f64>::new(&data, &[2, 3], &[1, 2], 0).unwrap();
assert_eq!(view.dims(), &[2, 3]);
assert_eq!(view.get(&[1, 2]), 6.0);

Source

pub unsafe fn new_unchecked( data: &'a [T], dims: &[usize], strides: &[isize], offset: isize, ) -> StridedView<'a, T, Op>

Create a view without bounds checking, copying the caller’s metadata.

§Safety

The caller must ensure all index combinations stay within bounds.

§Examples

use strided_view::StridedView;

let data = [1.0f64, 2.0, 3.0, 4.0];
let view = unsafe { StridedView::<f64>::new_unchecked(&data, &[2, 2], &[1, 2], 0) };
assert_eq!(view.ndim(), 2);

Source

pub fn dims(&self) -> &[usize]

Returns the shape (dimension sizes) of this view.

Source

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

Returns the strides (in units of T) for each dimension.

Source

pub fn offset(&self) -> isize

Returns the byte offset into the backing data.

Source

pub fn ndim(&self) -> usize

Returns the number of dimensions (rank).

Source

pub fn len(&self) -> usize

Returns the total number of elements.

Source

pub fn is_empty(&self) -> bool

Returns true if any dimension is zero.

Source

pub fn data(&self) -> &'a [T]

Returns a reference to the backing data slice.

Source

pub fn ptr(&self) -> *const T

Raw const pointer to element at the view’s base offset.

Source

pub fn permute( &self, perm: &[usize], ) -> Result<StridedView<'a, T, Op>, StridedError>

Permute dimensions.

Source

pub fn diagonal_view( &self, axis_pairs: &[(usize, usize)], ) -> Result<StridedView<'a, T, Op>, StridedError>

Create a diagonal view by fusing repeated axis pairs via stride trick (zero-copy).

Each pair (a, b) ties axes a and b to one index. Pairs that share an axis chain into one class ([(0, 1), (1, 2)] and [(0, 1), (0, 2)] both tie axes 0, 1 and 2), and each class becomes one axis:

New stride = the sum of the strides of the axes in the class
New dim = the minimum of their dims
The class sits at its lowest-numbered axis; the others are removed
Pairs use original axis numbering; their order does not matter, and repeating a pair has no further effect

§Errors

Returns StridedError::InvalidAxis when a pair names an axis outside the rank or names the same axis twice, and StridedError::OffsetOverflow when a fused stride does not fit isize or the fused layout reaches past the backing allocation.