Struct Simd 

pub struct Simd<T, const N: usize>(pub [T; N]);

A fixed-length vector of N lanes of element type T.

All operations are lane-wise and implemented as plain loops over the underlying [T; N], so the compiler can auto-vectorize them for any element type and lane count. The lane count N is arbitrary (powers of two that fill whole SIMD registers are the sweet spot, but not required).

The type carries no enforced alignment beyond the element’s natural alignment; for enforced alignment use the aligned sibling types, which share this type’s full operation surface. The field is public for zero-friction interoperability with array code.

Tuple Fields

0: [T; N]

Implementations

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

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

Loads a vector from the first N elements of src.

Panics

Panics if src.len() < N.

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

Stores all lanes to the first N elements of dst.

Panics

Panics if dst.len() < N.

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

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

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

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

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

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

where T: Mul<Output = T> + Add<Output = T> + Copy,

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.

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.

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

where T: Float + Copy,

pub fn abs(self) -> Self

Lane-wise Float::abs.

pub fn sqrt(self) -> Self

Lane-wise Float::sqrt.

pub fn recip(self) -> Self

Lane-wise Float::recip.

pub fn floor(self) -> Self

Lane-wise Float::floor.

pub fn ceil(self) -> Self

Lane-wise Float::ceil.

pub fn round(self) -> Self

Lane-wise Float::round.

pub fn trunc(self) -> Self

Lane-wise Float::trunc.

pub fn fract(self) -> Self

Lane-wise Float::fract.

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

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

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

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

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

Lane-wise Float::copysign.

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

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.

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

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.

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

where T: PartialOrd + Copy,

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

Lane-wise self < rhs.

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

Lane-wise self <= rhs.

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

Lane-wise self > rhs.

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

Lane-wise self >= rhs.

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

where T: PartialEq + Copy,

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

Lane-wise self == rhs.

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

Lane-wise self != rhs.

impl<const N: usize> Simd<bool, N>

pub fn select<T: Copy>( self, if_true: Simd<T, N>, if_false: Simd<T, N>, ) -> Simd<T, N>

Lane-wise select: picks lanes of if_true where the mask is true and lanes of if_false where it is false.

pub fn any_true(self) -> bool

Returns true if any lane is true.

pub fn all_true(self) -> bool

Returns true if all lanes are true.

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

where T: Zero + Add<Output = T> + Copy,

pub fn reduce_sum(self) -> T

Sums all lanes, accumulating in lane order.

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

Sums the first n lanes.

Panics

Panics if n > N.

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

where T: One + Mul<Output = T> + Copy,

pub fn reduce_product(self) -> T

Multiplies all lanes, accumulating in lane order.

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

Multiplies the first n lanes.

Panics

Panics if n > N.

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

pub fn from_fn<F>(f: F) -> Self

where F: FnMut(usize) -> T,

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

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)).

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

Returns the underlying array by reference.

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

Returns the underlying array by mutable reference.

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

Returns the underlying array by value.

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

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

Returns a vector with all lanes set to val.

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

Sets all lanes to val.

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.

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).

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

pub fn zero() -> Self

Returns a vector with all lanes set to zero.

impl<T: One + Copy, const N: usize> Simd<T, N>

pub fn one() -> Self

Returns a vector with all lanes set to one.

Trait Implementations

impl<T, const N: usize> Add for Simd<T, N>

where T: Num + Copy,

type Output = Simd<T, N>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T, const N: usize> Add<T> for Simd<T, N>

where T: Num + Copy,

type Output = Simd<T, N>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self

Performs the + operation.

impl<T, const N: usize> AddAssign for Simd<T, N>

where T: NumAssignOps + Copy,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T, const N: usize> AddAssign<T> for Simd<T, N>

where T: NumAssignOps + Copy,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T, const N: usize> BitAnd for Simd<T, N>

where T: BitAnd<Output = T> + Copy,

type Output = Simd<T, N>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self

Performs the & operation.

impl<T, const N: usize> BitAndAssign for Simd<T, N>

where T: BitAndAssign + Copy,

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T, const N: usize> BitOr for Simd<T, N>

where T: BitOr<Output = T> + Copy,

type Output = Simd<T, N>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl<T, const N: usize> BitOrAssign for Simd<T, N>

where T: BitOrAssign + Copy,

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T, const N: usize> BitXor for Simd<T, N>

where T: BitXor<Output = T> + Copy,

type Output = Simd<T, N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self

Performs the ^ operation.

impl<T, const N: usize> BitXorAssign for Simd<T, N>

where T: BitXorAssign + Copy,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T: Clone, const N: usize> Clone for Simd<T, N>

fn clone(&self) -> Simd<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy, const N: usize> Copy for Simd<T, N>

impl<T: Debug, const N: usize> Debug for Simd<T, N>

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

Formats the value using the given formatter.

impl<T: Default, const N: usize> Default for Simd<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const N: usize> Div for Simd<T, N>

where T: Num + Copy,

type Output = Simd<T, N>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl<T, const N: usize> Div<T> for Simd<T, N>

where T: Num + Copy,

type Output = Simd<T, N>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self

Performs the / operation.

impl<T, const N: usize> DivAssign for Simd<T, N>

where T: NumAssignOps + Copy,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T, const N: usize> DivAssign<T> for Simd<T, N>

where T: NumAssignOps + Copy,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Eq, const N: usize> Eq for Simd<T, N>

impl<T, const N: usize> From<Aligned4<T, N>> for Simd<T, N>

fn from(v: Aligned4<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Aligned8<T, N>> for Simd<T, N>

fn from(v: Aligned8<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Aligned16<T, N>> for Simd<T, N>

fn from(v: Aligned16<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Aligned32<T, N>> for Simd<T, N>

fn from(v: Aligned32<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Aligned64<T, N>> for Simd<T, N>

fn from(v: Aligned64<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Simd<T, N>> for Aligned4<T, N>

fn from(v: Simd<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Simd<T, N>> for Aligned8<T, N>

fn from(v: Simd<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Simd<T, N>> for Aligned16<T, N>

fn from(v: Simd<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Simd<T, N>> for Aligned32<T, N>

fn from(v: Simd<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Simd<T, N>> for Aligned64<T, N>

fn from(v: Simd<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for Simd<T, N>

fn from(array: [T; N]) -> Self

Converts to this type from the input type.

impl<T: Hash, const N: usize> Hash for Simd<T, N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const N: usize> Index<usize> for Simd<T, N>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for Simd<T, N>

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

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

impl<T, const N: usize> Mul for Simd<T, N>

where T: Num + Copy,

type Output = Simd<T, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<T, const N: usize> Mul<T> for Simd<T, N>

where T: Num + Copy,

type Output = Simd<T, N>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self

Performs the * operation.

impl<T, const N: usize> MulAssign for Simd<T, N>

where T: NumAssignOps + Copy,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T, const N: usize> MulAssign<T> for Simd<T, N>

where T: NumAssignOps + Copy,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, const N: usize> Neg for Simd<T, N>

where T: Neg<Output = T> + Copy,

type Output = Simd<T, N>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T, const N: usize> Not for Simd<T, N>

where T: Not<Output = T> + Copy,

type Output = Simd<T, N>

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl<T: Num + Copy, const N: usize> One for Simd<T, N>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T: PartialEq, const N: usize> PartialEq for Simd<T, N>

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

Equality operator ==.

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

Inequality operator !=.

impl<T, const N: usize> Shl<usize> for Simd<T, N>

where T: Shl<usize, Output = T> + Copy,

type Output = Simd<T, N>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self

Performs the << operation.

impl<T, const N: usize> Shr<usize> for Simd<T, N>

where T: Shr<usize, Output = T> + Copy,

type Output = Simd<T, N>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self

Performs the >> operation.

impl<T: PartialEq, const N: usize> StructuralPartialEq for Simd<T, N>

impl<T, const N: usize> Sub for Simd<T, N>

where T: Num + Copy,

type Output = Simd<T, N>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<T, const N: usize> Sub<T> for Simd<T, N>

where T: Num + Copy,

type Output = Simd<T, N>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self

Performs the - operation.

impl<T, const N: usize> SubAssign for Simd<T, N>

where T: NumAssignOps + Copy,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T, const N: usize> SubAssign<T> for Simd<T, N>

where T: NumAssignOps + Copy,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: Num + Copy, const N: usize> Zero for Simd<T, N>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.