Struct AlignedVec 

pub struct AlignedVec<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: Copy + Default> AlignedVec<T>

pub fn with_capacity(capacity: usize) -> Self

Create with capacity rounded up to 64-byte boundary

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

Create from a slice, copying data into aligned storage

pub fn zeros(len: usize) -> Self

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 + Copy + Default> Clone for AlignedVec<T>

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 + Copy + Default> Debug for AlignedVec<T>

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

Formats the value using the given formatter.

impl<T: Copy + Default> Default for AlignedVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Copy + Default> FromIterator<T> for AlignedVec<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Copy + Default> Index<usize> for AlignedVec<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Copy + Default> IndexMut<usize> for AlignedVec<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

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

impl<T: Copy + Default + PartialEq> PartialEq for AlignedVec<T>

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.