Struct AlignedVec 

pub struct AlignedVec<T>
where
    T: Copy + Default,
{ /* private fields */ }

64-byte aligned vector for SIMD operations (spec §5.2)

Provides memory-aligned storage for efficient SIMD access. Alignment is guaranteed at 64 bytes for AVX-512 compatibility.

Memory Layout

• Data is stored in a Vec with additional alignment tracking
• Capacity is rounded up to 64-byte boundaries
• Provides raw pointers for FFI/SIMD operations

Example

use aprender::native::AlignedVec;

let vec = AlignedVec::from_slice(&[1.0_f32, 2.0, 3.0, 4.0]);
assert!(vec.is_aligned());
assert_eq!(vec.len(), 4);

// Access as slice
assert_eq!(vec.as_slice(), &[1.0, 2.0, 3.0, 4.0]);

Implementations

impl<T> AlignedVec<T>

where T: Copy + Default,

pub fn with_capacity(capacity: usize) -> AlignedVec<T>

Create with capacity rounded up to 64-byte boundary

pub fn from_slice(slice: &[T]) -> AlignedVec<T>

Create from a slice, copying data into aligned storage

pub fn zeros(len: usize) -> AlignedVec<T>

Create filled with zeros

pub const fn len(&self) -> usize

Logical length

pub const fn is_empty(&self) -> bool

Check if empty

pub const fn capacity(&self) -> usize

Aligned capacity

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

Get raw pointer (guaranteed 64-byte aligned for f32/f64)

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

Get mutable raw pointer

pub fn as_slice(&self) -> &[T]

Get as slice

pub fn as_mut_slice(&mut self) -> &mut [T]

Get as mutable slice

pub fn is_aligned(&self) -> bool

Check alignment (for debugging)

Note: Standard Rust Vec does not guarantee 64-byte alignment. This function checks if the data pointer happens to be aligned. For true SIMD-aligned allocations, use a specialized allocator.

pub fn size_bytes(&self) -> usize

Size in bytes (actual data, not capacity)

pub fn push(&mut self, value: T)

Push a value (may reallocate if at capacity)

pub fn clear(&mut self)

Clear the vector (keeps capacity)

pub fn get(&self, index: usize) -> Option<&T>

Get element by index

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Get mutable element by index

pub fn set(&mut self, index: usize, value: T) -> bool

Set element by index

Trait Implementations

impl<T> Clone for AlignedVec<T>

where T: Clone + Copy + Default,

fn clone(&self) -> AlignedVec<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for AlignedVec<T>

where T: Debug + Copy + Default,

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

Formats the value using the given formatter.

impl<T> Default for AlignedVec<T>

where T: Copy + Default,

fn default() -> AlignedVec<T>

Returns the “default value” for a type.

impl<T> FromIterator<T> for AlignedVec<T>

where T: Copy + Default,

fn from_iter<I>(iter: I) -> AlignedVec<T>

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<T> Index<usize> for AlignedVec<T>

where T: Copy + Default,

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &<AlignedVec<T> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for AlignedVec<T>

where T: Copy + Default,

fn index_mut( &mut self, index: usize, ) -> &mut <AlignedVec<T> as Index<usize>>::Output

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

impl<T> PartialEq for AlignedVec<T>

where T: Copy + Default + PartialEq,

fn eq(&self, other: &AlignedVec<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.