Struct Aligned16

Source

#[repr(align(16))]
pub struct Aligned16<T, const N: usize>(pub [T; N]);

Expand description

A fixed-length vector of N lanes of element type T over [T; N] with enforced 16-byte alignment; see the module docs.

Tuple Fields§

§0: [T; N]

Implementations§

Source §

impl<T, const N: usize> Aligned16<T, N>

Source

pub fn to_simd(self) -> Simd<T, N>

Returns the equivalent plain (naturally aligned) vector.

Source §

impl<T: Copy, const N: usize> Aligned16<T, N>

Source

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

Loads a vector from the first N elements of src.

§Panics

Panics if src.len() < N.

Source

pub fn store_slice(&self, dst: &mut [T])

Stores all lanes to the first N elements of dst.

§Panics

Panics if dst.len() < N.

Source

pub fn store_slice_partial(&self, dst: &mut [T])

Stores at most the first min(dst.len(), N) lanes to dst.

Source §

impl<T: Zero + Copy, const N: usize> Aligned16<T, N>

Source

pub fn from_slice_pad(src: &[T]) -> Self

Loads a vector from src, zero-filling lanes past src.len().

Source §

impl<T, const N: usize> Aligned16<T, N>
where T: Mul<Output = T> + Add<Output = T> + Copy,

Source

pub fn mul_add(self, b: Self, c: Self) -> Self

Lane-wise multiply-add: self * b + c, evaluated as a separate multiply and add (two roundings per lane).

This is the fallback on targets without hardware FMA (generic x86-64, x86-64-v2), where it avoids the slow software-fused libm fma calls; it also fuses into a single hardware FMA instruction when compiled with -C llvm-args=-fp-contract=fast. Enable the use_libm_fma feature to get the single-rounding fused form on such targets instead.

Source

pub fn fma_from(&mut self, b: Self, c: Self)

Lane-wise *self = b * c + *self, by the receiver.

Note that the operand order differs from mul_add: the accumulator is the receiver, matching self += b * c. The evaluation strategy is the same as mul_add’s.

Source §

pub fn min(self, other: Self) -> Self

Lane-wise minimum; NaN handling follows the element’s scalar Float::min.

Source

pub fn max(self, other: Self) -> Self

Lane-wise maximum; NaN handling follows the element’s scalar Float::max.

Source

pub fn copysign(self, sign: Self) -> Self

Lane-wise Float::copysign.

Source §

impl<const N: usize> Aligned16<f32, N>

Source

pub fn round_ties_even(self) -> Self

Lane-wise f32::round_ties_even.

Not available generically through num_traits::Float, so this is implemented only for the builtin float types.

Source §

impl<const N: usize> Aligned16<f64, N>

Source

pub fn round_ties_even(self) -> Self

Lane-wise f64::round_ties_even.

Not available generically through num_traits::Float, so this is implemented only for the builtin float types.

Source §

impl<T, const N: usize> Aligned16<T, N>
where T: PartialOrd + Copy,

Source

pub fn simd_lt(self, rhs: Self) -> Simd<bool, N>

Lane-wise self < rhs.

Source

pub fn simd_le(self, rhs: Self) -> Simd<bool, N>

Lane-wise self <= rhs.

Source

pub fn simd_gt(self, rhs: Self) -> Simd<bool, N>

Lane-wise self > rhs.

Source

pub fn simd_ge(self, rhs: Self) -> Simd<bool, N>

Lane-wise self >= rhs.

Source §

impl<T, const N: usize> Aligned16<T, N>
where T: PartialEq + Copy,

Source

pub fn simd_eq(self, rhs: Self) -> Simd<bool, N>

Lane-wise self == rhs.

Source

pub fn simd_ne(self, rhs: Self) -> Simd<bool, N>

Lane-wise self != rhs.

Source §

impl<T, const N: usize> Aligned16<T, N>
where T: Zero + Add<Output = T> + Copy,

Source

pub fn reduce_sum(self) -> T

Sums all lanes, accumulating in lane order.

Source

pub fn reduce_sum_n(self, n: usize) -> T

Sums the first n lanes.

§Panics

Panics if n > N.

Source §

impl<T, const N: usize> Aligned16<T, N>
where T: One + Mul<Output = T> + Copy,

Source

pub fn reduce_product(self) -> T

Multiplies all lanes, accumulating in lane order.

Source

pub fn reduce_product_n(self, n: usize) -> T

Multiplies the first n lanes.

§Panics

Panics if n > N.

Source §

impl<T, const N: usize> Aligned16<T, N>

Source

pub fn from_fn<F>(f: F) -> Self
where F: FnMut(usize) -> T,

Returns a vector whose lane i is f(i).

Source

pub fn map<F>(self, f: F) -> Self
where F: FnMut(T) -> T,

Applies f to each lane, returning a new vector.

This is the generic escape hatch for operations the crate does not provide (e.g. transcendental functions: v.map(f64::exp)).

Source

pub const fn as_array(&self) -> &[T; N]

Returns the underlying array by reference.

Source

pub fn as_array_mut(&mut self) -> &mut [T; N]

Returns the underlying array by mutable reference.

Source

pub fn to_array(self) -> [T; N]

Returns the underlying array by value.

Source §

impl<T: Copy, const N: usize> Aligned16<T, N>

Source

pub const fn splat(val: T) -> Self

Returns a vector with all lanes set to val.

Source

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

Sets all lanes to val.

Source

pub fn mask_select(self, mask: Simd<bool, N>, other: Self) -> Self

Per-lane select: keeps lanes of self where mask is true and lanes of other where it is false. This value-side form is available on every vector type; the mask-side select applies to plain vectors.

Source

pub unsafe fn uninit() -> Self

Returns an uninitialized vector, intended for scratch buffers whose lanes are fully written before being read.

§Safety

The caller must initialize all lanes before any read. The element type must additionally admit arbitrary bit patterns (true for floats and integers; not for types with niches such as references).

Source §