Struct StridedView 

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

Dynamic-rank immutable strided view with lazy element operations.

This is the Julia-equivalent StridedView type with:

• Dynamic rank (dims/strides are heap-allocated)
• 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)

Implementations

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

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

Create a new immutable strided view from a borrowed slice.

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

Create a view without bounds checking.

Safety

The caller must ensure all index combinations stay within bounds.

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

Returns the shape (dimension sizes) of this view.

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

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

pub fn offset(&self) -> isize

Returns the byte offset into the backing data.

pub fn ndim(&self) -> usize

Returns the number of dimensions (rank).

pub fn len(&self) -> usize

Returns the total number of elements.

pub fn is_empty(&self) -> bool

Returns true if any dimension is zero.

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

Returns a reference to the backing data slice.

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

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

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

Permute dimensions.

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

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

For each pair (a, b):

• New stride = strides[a] + strides[b]
• New dim = min(dims[a], dims[b])
• The higher-numbered axis is removed
• Pairs use original axis numbering

Example

A[i,i,j] shape=[n,n,m] strides=[s0,s1,s2] -> shape=[n,m] strides=[s0+s1, s2]

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

Broadcast this view to a target shape.

Size-1 dimensions are expanded (stride set to 0) to match target.

impl<'a, T: Copy + ElementOpApply, Op: ComposableElementOp<T>> StridedView<'a, T, Op>

Composition methods: require T: ElementOpApply and Op: ComposableElementOp<T>.

pub fn transpose_2d(&self) -> Result<StridedView<'a, T, Op::ComposeTranspose>>

Transpose a 2D view: reverses dimensions and composes the Transpose element op.

Julia equivalent: Base.transpose(a::AbstractStridedView{<:Any, 2})

pub fn adjoint_2d(&self) -> Result<StridedView<'a, T, Op::ComposeAdjoint>>

Adjoint (conjugate transpose) of a 2D view.

Julia equivalent: Base.adjoint(a::AbstractStridedView{<:Any, 2})

pub fn conj(&self) -> StridedView<'a, T, Op::ComposeConj>

Complex conjugate (compose Conj without changing dims/strides).

Julia equivalent: Base.conj(a::AbstractStridedView)

impl<'a, T: Copy, Op: ElementOp<T>> StridedView<'a, T, Op>

Element access: requires Op: ElementOp<T>.

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

Get an element with the element operation applied.

pub unsafe fn get_unchecked(&self, indices: &[usize]) -> T

Get an element without bounds checking.

Safety

Caller must ensure indices are within bounds.

Trait Implementations

impl<T, Op> Clone for StridedView<'_, T, Op>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Op> Debug for StridedView<'_, T, Op>

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

Formats the value using the given formatter.

impl<T: Send, Op: Send> Send for StridedView<'_, T, Op>

impl<T: Sync, Op: Sync> Sync for StridedView<'_, T, Op>