Struct VectorSpan 

pub struct VectorSpan<'a, T: StorageElement> { /* private fields */ }

Mutable, possibly strided, non-owning view into a vector.

Implementations

impl<'a, T: StorageElement> VectorSpan<'a, T>

pub unsafe fn from_raw_parts( data: *mut T, dims: usize, stride_bytes: isize, ) -> Self

Create a mutable view from a raw pointer, dimension count, and byte stride.

Safety

• data must be valid for reads and writes of dims elements at the given stride.
• The pointed-to memory must outlive 'a.
• stride_bytes must be non-zero for non-empty views.
• No other references to the memory may exist for the duration of 'a.

pub fn dims(&self) -> usize

Number of logical dimensions.

pub fn size(&self) -> usize

Number of logical dimensions (alias for dims).

pub fn is_empty(&self) -> bool

Returns true if empty.

pub fn stride_bytes(&self) -> isize

Stride in bytes.

pub fn is_contiguous(&self) -> bool

Returns true if contiguous.

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

Get the underlying pointer.

pub fn as_mut_ptr(&mut self) -> *mut T

Get the mutable underlying pointer.

pub fn as_view(&self) -> VectorView<'_, T>

Reborrow as an immutable view, sharing the same data pointer and stride.

pub fn try_get<I: VectorIndex>( &self, idx: I, ) -> Result<T::DimScalar, TensorError>

where T: FloatConvertible,

Try to get element at index.

pub fn try_set<I: VectorIndex>( &mut self, idx: I, val: T::DimScalar, ) -> Result<(), TensorError>

where T: FloatConvertible,

Try to set the element at idx.

Accepts the native DimScalar type. For sub-byte types, uses value_index for stride-based pointer walks to avoid buffer overwrite.

pub fn fill(&mut self, val: T)

Fill all elements with a value, respecting the stride between elements.

Iterates over storage values (not logical dimensions) to avoid buffer overwrite for sub-byte types.

pub fn as_contiguous_slice(&self) -> Option<&[T]>

Get a contiguous slice, if this span is contiguous.

pub fn as_contiguous_slice_mut(&mut self) -> Option<&mut [T]>

Get a mutable contiguous slice, if this span is contiguous.

pub fn iter(&self) -> VectorViewIterator<'_, T>

where T: FloatConvertible,

Returns an iterator over logical dimension values, yielding DimRef proxies.

pub fn iter_mut(&mut self) -> VectorSpanIterator<'_, T>

where T: FloatConvertible,

Returns a mutable iterator over logical dimension values, yielding DimMut proxies.

impl<'a, T: FloatConvertible> VectorSpan<'a, T>

where T::DimScalar: NumberLike,

pub fn allclose(&self, other: &Self, atol: f64, rtol: f64) -> bool

Check if all elements are within tolerance of other.

Uses the formula |a - b| <= atol + rtol * |b| per element. Returns false if dimensions differ.

Trait Implementations

impl<'a, T: FloatConvertible> Debug for VectorSpan<'a, T>

where T::DimScalar: Debug,

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

Formats the value using the given formatter.

impl<'a, I: VectorIndex, T: StorageElement> Index<I> for VectorSpan<'a, T>

type Output = T

The returned type after indexing.

fn index(&self, idx: I) -> &T

Performs the indexing (container[index]) operation.

impl<'a, I: VectorIndex, T: StorageElement> IndexMut<I> for VectorSpan<'a, T>

fn index_mut(&mut self, idx: I) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<'a, T: FloatConvertible> IntoIterator for &'a VectorSpan<'a, T>

type Item = DimRef<'a, T>

The type of the elements being iterated over.

type IntoIter = VectorViewIterator<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: FloatConvertible> IntoIterator for &'a mut VectorSpan<'a, T>

type Item = DimMut<'a, T>

The type of the elements being iterated over.

type IntoIter = VectorSpanIterator<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: FloatConvertible> PartialEq for VectorSpan<'a, T>

where T::DimScalar: PartialEq,

fn eq(&self, other: &Self) -> 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<'a, T: StorageElement + Send> Send for VectorSpan<'a, T>

impl<'a, T: StorageElement + Sync> Sync for VectorSpan<'a, T>