Struct Vector 

#[repr(transparent)]
pub struct Vector<T, Arch>
where
    Arch: SimdArch + SimdKernel<T>,
    T: NumericElement,
{
    pub raw: <Arch as SimdKernel<T>>::Vector,
    /* private fields */
}

A monomorphized vector register type wrapping the architecture-native raw register.

Fields

raw: <Arch as SimdKernel<T>>::Vector

The underlying raw vector register.

Implementations

impl<T, Arch> Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

pub const fn new(raw: <Arch as SimdKernel<T>>::Vector) -> Vector<T, Arch>

Create a new Vector wrapping a raw vector register.

pub fn zero() -> Vector<T, Arch>

Construct a Vector with all lanes set to zero.

pub fn try_zero() -> Result<Vector<T, Arch>, SimdError>

Try to construct a Vector with all lanes set to zero.

pub fn splat(val: T) -> Vector<T, Arch>

Construct a Vector by broadcasting a scalar value to all lanes.

pub fn try_splat(val: T) -> Result<Vector<T, Arch>, SimdError>

Try to construct a Vector by broadcasting a scalar value to all lanes.

pub unsafe fn load_aligned(ptr: *const T) -> Vector<T, Arch>

Load a Vector from an aligned pointer.

Safety

The host must support Arch’s target features, and ptr must be valid for reads and aligned to Arch::LANE_COUNT * size_of::<T>() bytes.

pub unsafe fn load_unaligned(ptr: *const T) -> Vector<T, Arch>

Load a Vector from an unaligned pointer.

Safety

The host must support Arch’s target features, and ptr must be valid for reads.

pub unsafe fn store_aligned(self, ptr: *mut T)

Store the Vector elements to an aligned pointer.

Safety

The host must support Arch’s target features, and ptr must be valid for writes and aligned to Arch::LANE_COUNT * size_of::<T>() bytes.

pub unsafe fn store_unaligned(self, ptr: *mut T)

Store the Vector elements to an unaligned pointer.

Safety

The host must support Arch’s target features, and ptr must be valid for writes.

pub unsafe fn masked_load_unaligned( ptr: *const T, mask: Mask<T, Arch>, src: Vector<T, Arch>, ) -> Vector<T, Arch>

Masked load from an unaligned pointer: active lanes loaded from ptr, inactive lanes from src.

Safety

The host must support Arch’s target features, and ptr must be valid for reads of Arch::LANE_COUNT elements.

pub unsafe fn masked_store_unaligned(self, ptr: *mut T, mask: Mask<T, Arch>)

Masked store to an unaligned pointer: active lanes written to ptr, inactive lanes left unchanged.

Safety

The host must support Arch’s target features, and ptr must be valid for writes of Arch::LANE_COUNT elements.

pub fn load_unaligned_from_slice( data: &[T], ) -> Result<Vector<T, Arch>, SimdError>

Load one vector from the start of a slice using the unaligned kernel load.

Returns SimdError::InsufficientInputLength when data has fewer elements than Arch::LANE_COUNT.

pub fn load_aligned_from_slice(data: &[T]) -> Result<Vector<T, Arch>, SimdError>

Load one vector from the start of a slice using the aligned kernel load.

Returns SimdError::InsufficientInputLength when data has fewer elements than Arch::LANE_COUNT, and SimdError::UnalignedAddress when the slice start is not aligned to the vector byte width.

pub fn store_unaligned_to_slice(self, out: &mut [T]) -> Result<(), SimdError>

Store this vector to the start of a slice using the unaligned kernel store.

Returns SimdError::InsufficientOutputLength when out has fewer elements than Arch::LANE_COUNT.

pub fn store_aligned_to_slice(self, out: &mut [T]) -> Result<(), SimdError>

Store this vector to the start of a slice using the aligned kernel store.

Returns SimdError::InsufficientOutputLength when out has fewer elements than Arch::LANE_COUNT, and SimdError::UnalignedAddress when the slice start is not aligned to the vector byte width.

pub fn masked_load_from_slice( data: &[T], mask: Mask<T, Arch>, src: Vector<T, Arch>, ) -> Result<Vector<T, Arch>, SimdError>

Safe masked load from a slice.

Active lanes (according to mask) must reside within the bounds of data. Inactive lanes are populated from the corresponding lanes of src.

pub fn masked_store_to_slice( self, data: &mut [T], mask: Mask<T, Arch>, ) -> Result<(), SimdError>

Safe masked store to a slice.

Active lanes (according to mask) must reside within the bounds of data. Inactive lanes in the slice are left unchanged.

pub fn sum_reduce(self) -> T

Horizontal sum reduction of all lanes in the Vector.

pub fn popcount(self) -> Vector<T, Arch>

Elementwise population count (number of set bits).

pub fn horizontal_bitwise_and(self) -> T

Horizontal bitwise AND reduction across all lanes.

pub fn horizontal_bitwise_or(self) -> T

Horizontal bitwise OR reduction across all lanes.

pub fn horizontal_bitwise_xor(self) -> T

Horizontal bitwise XOR reduction across all lanes.

pub fn abs(self) -> Vector<T, Arch>

Elementwise absolute value.

pub fn min(self, other: Vector<T, Arch>) -> Vector<T, Arch>

Elementwise minimum of self and other.

pub fn max(self, other: Vector<T, Arch>) -> Vector<T, Arch>

Elementwise maximum of self and other.

pub fn sqrt(self) -> Vector<T, Arch>

Elementwise square root.

pub fn cmp_eq(self, other: Vector<T, Arch>) -> Vector<T, Arch>

Elementwise equal comparison (self == other).

pub fn cmp_ne(self, other: Vector<T, Arch>) -> Vector<T, Arch>

Elementwise not-equal comparison (self != other).

pub fn cmp_lt(self, other: Vector<T, Arch>) -> Vector<T, Arch>

Elementwise less-than comparison (self < other).

pub fn cmp_le(self, other: Vector<T, Arch>) -> Vector<T, Arch>

Elementwise less-than-or-equal comparison (self <= other).

pub fn cmp_gt(self, other: Vector<T, Arch>) -> Vector<T, Arch>

Elementwise greater-than comparison (self > other).

pub fn cmp_ge(self, other: Vector<T, Arch>) -> Vector<T, Arch>

Elementwise greater-than-or-equal comparison (self >= other).

pub fn blend( self, true_val: Vector<T, Arch>, false_val: Vector<T, Arch>, ) -> Vector<T, Arch>

Conditional blend: select lanes from true_val where the mask lane in self is active (sign bit set), and from false_val otherwise.

pub fn from_array<const N: usize>(arr: [T; N]) -> Vector<T, Arch>

Create a Vector from an array of size N, where N must equal Arch::LANE_COUNT.

pub fn try_from_array<const N: usize>( arr: [T; N], ) -> Result<Vector<T, Arch>, SimdError>

Try to create a Vector from an array of size N, where N must equal Arch::LANE_COUNT.

pub fn to_array<const N: usize>(self) -> [T; N]

Convert the vector to an array of size N, where N must equal Arch::LANE_COUNT.

pub fn to_bitmask(self) -> BitMask<64>

Convert this vector mask representation (sign bits) into a portable BitMask.

pub fn cmp_eq_mask(self, other: Vector<T, Arch>) -> Mask<T, Arch>

Elementwise equal comparison returning a native Mask.

pub fn cmp_ne_mask(self, other: Vector<T, Arch>) -> Mask<T, Arch>

Elementwise not-equal comparison returning a native Mask.

pub fn cmp_lt_mask(self, other: Vector<T, Arch>) -> Mask<T, Arch>

Elementwise less-than comparison returning a native Mask.

pub fn cmp_le_mask(self, other: Vector<T, Arch>) -> Mask<T, Arch>

Elementwise less-than-or-equal comparison returning a native Mask.

pub fn cmp_gt_mask(self, other: Vector<T, Arch>) -> Mask<T, Arch>

Elementwise greater-than comparison returning a native Mask.

pub fn cmp_ge_mask(self, other: Vector<T, Arch>) -> Mask<T, Arch>

Elementwise greater-than-or-equal comparison returning a native Mask.

pub fn cast<U>(self) -> Vector<U, Arch>

where Arch: SimdKernel<U>, U: NumericElement + CastFrom<T>,

Cast the vector elements to another scalar type U where the lane counts match.

pub fn extract<const I: usize>(self) -> T

Extract a single lane element by index at compile-time.

pub fn insert<const I: usize>(self, val: T) -> Vector<T, Arch>

Insert a value into a single lane by index at compile-time.

pub fn from_view_chunk<Align, Mode, Ref>( view: &SimdView<'_, T, Arch, Align, Mode, Ref>, chunk_idx: usize, ) -> Vector<T, Arch>

where Align: Alignment, Mode: ExecutionMode, Ref: Deref<Target = [T]>,

Load a Vector from a chunk index of a SimdView.

pub fn store_to_view_chunk<'a, Align, Mode>( self, view: &mut SimdView<'a, T, Arch, Align, Mode, &'a mut [T]>, chunk_idx: usize, )

where Align: Alignment, Mode: ExecutionMode,

Store this Vector into a mutable chunk of a mutable SimdView.

Trait Implementations

impl<T, Arch> Add for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the + operator.

fn add(self, rhs: Vector<T, Arch>) -> Vector<T, Arch>

Performs the + operation.

impl<'a, T, Arch> Add<&'a Vector<T, Arch>> for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the + operator.

fn add( self, rhs: &'a Vector<T, Arch>, ) -> <Vector<T, Arch> as Add<&'a Vector<T, Arch>>>::Output

Performs the + operation.

impl<'a, 'b, T, Arch> Add<&'b Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the + operator.

fn add( self, rhs: &'b Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as Add<&'b Vector<T, Arch>>>::Output

Performs the + operation.

impl<'a, T, Arch> Add<Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the + operator.

fn add( self, rhs: Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as Add<Vector<T, Arch>>>::Output

Performs the + operation.

impl<T, Arch> AddAssign for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

fn add_assign(&mut self, rhs: Vector<T, Arch>)

Performs the += operation.

impl<T, Arch> BitAnd for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the & operator.

fn bitand(self, rhs: Vector<T, Arch>) -> Vector<T, Arch>

Performs the & operation.

impl<'a, T, Arch> BitAnd<&'a Vector<T, Arch>> for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the & operator.

fn bitand( self, rhs: &'a Vector<T, Arch>, ) -> <Vector<T, Arch> as BitAnd<&'a Vector<T, Arch>>>::Output

Performs the & operation.

impl<'a, 'b, T, Arch> BitAnd<&'b Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the & operator.

fn bitand( self, rhs: &'b Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as BitAnd<&'b Vector<T, Arch>>>::Output

Performs the & operation.

impl<'a, T, Arch> BitAnd<Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the & operator.

fn bitand( self, rhs: Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as BitAnd<Vector<T, Arch>>>::Output

Performs the & operation.

impl<T, Arch> BitAndAssign for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

fn bitand_assign(&mut self, rhs: Vector<T, Arch>)

Performs the &= operation.

impl<T, Arch> BitOr for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the | operator.

fn bitor(self, rhs: Vector<T, Arch>) -> Vector<T, Arch>

Performs the | operation.

impl<'a, T, Arch> BitOr<&'a Vector<T, Arch>> for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the | operator.

fn bitor( self, rhs: &'a Vector<T, Arch>, ) -> <Vector<T, Arch> as BitOr<&'a Vector<T, Arch>>>::Output

Performs the | operation.

impl<'a, 'b, T, Arch> BitOr<&'b Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the | operator.

fn bitor( self, rhs: &'b Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as BitOr<&'b Vector<T, Arch>>>::Output

Performs the | operation.

impl<'a, T, Arch> BitOr<Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the | operator.

fn bitor( self, rhs: Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as BitOr<Vector<T, Arch>>>::Output

Performs the | operation.

impl<T, Arch> BitOrAssign for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

fn bitor_assign(&mut self, rhs: Vector<T, Arch>)

Performs the |= operation.

impl<T, Arch> BitXor for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Vector<T, Arch>) -> Vector<T, Arch>

Performs the ^ operation.

impl<'a, T, Arch> BitXor<&'a Vector<T, Arch>> for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: &'a Vector<T, Arch>, ) -> <Vector<T, Arch> as BitXor<&'a Vector<T, Arch>>>::Output

Performs the ^ operation.

impl<'a, 'b, T, Arch> BitXor<&'b Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: &'b Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as BitXor<&'b Vector<T, Arch>>>::Output

Performs the ^ operation.

impl<'a, T, Arch> BitXor<Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as BitXor<Vector<T, Arch>>>::Output

Performs the ^ operation.

impl<T, Arch> BitXorAssign for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

fn bitxor_assign(&mut self, rhs: Vector<T, Arch>)

Performs the ^= operation.

impl<T, Arch> Clone for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

fn clone(&self) -> Vector<T, Arch>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Arch> Copy for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

impl<T, Arch> Debug for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement + Debug,

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

Formats the value using the given formatter.

impl<T, Arch> Div for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the / operator.

fn div(self, rhs: Vector<T, Arch>) -> Vector<T, Arch>

Performs the / operation.

impl<'a, T, Arch> Div<&'a Vector<T, Arch>> for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the / operator.

fn div( self, rhs: &'a Vector<T, Arch>, ) -> <Vector<T, Arch> as Div<&'a Vector<T, Arch>>>::Output

Performs the / operation.

impl<'a, 'b, T, Arch> Div<&'b Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the / operator.

fn div( self, rhs: &'b Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as Div<&'b Vector<T, Arch>>>::Output

Performs the / operation.

impl<'a, T, Arch> Div<Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the / operator.

fn div( self, rhs: Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as Div<Vector<T, Arch>>>::Output

Performs the / operation.

impl<T, Arch> DivAssign for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

fn div_assign(&mut self, rhs: Vector<T, Arch>)

Performs the /= operation.

impl<T, Arch> Eq for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement + Eq,

impl<T, Arch> Mul for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<T, Arch>) -> Vector<T, Arch>

Performs the * operation.

impl<'a, T, Arch> Mul<&'a Vector<T, Arch>> for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a Vector<T, Arch>, ) -> <Vector<T, Arch> as Mul<&'a Vector<T, Arch>>>::Output

Performs the * operation.

impl<'a, 'b, T, Arch> Mul<&'b Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the * operator.

fn mul( self, rhs: &'b Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as Mul<&'b Vector<T, Arch>>>::Output

Performs the * operation.

impl<'a, T, Arch> Mul<Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the * operator.

fn mul( self, rhs: Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as Mul<Vector<T, Arch>>>::Output

Performs the * operation.

impl<T, Arch> MulAssign for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

fn mul_assign(&mut self, rhs: Vector<T, Arch>)

Performs the *= operation.

impl<T, Arch> Neg for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the - operator.

fn neg(self) -> Vector<T, Arch>

Performs the unary - operation.

impl<T, Arch> Neg for &Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the - operator.

fn neg(self) -> <&Vector<T, Arch> as Neg>::Output

Performs the unary - operation.

impl<T, Arch> Not for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the ! operator.

fn not(self) -> Vector<T, Arch>

Performs the unary ! operation.

impl<T, Arch> Not for &Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the ! operator.

fn not(self) -> <&Vector<T, Arch> as Not>::Output

Performs the unary ! operation.

impl<T, Arch> PartialEq for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement + PartialEq,

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

Equality operator ==.

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

Inequality operator !=.

impl<T, Arch> Sub for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector<T, Arch>) -> Vector<T, Arch>

Performs the - operation.

impl<'a, T, Arch> Sub<&'a Vector<T, Arch>> for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a Vector<T, Arch>, ) -> <Vector<T, Arch> as Sub<&'a Vector<T, Arch>>>::Output

Performs the - operation.

impl<'a, 'b, T, Arch> Sub<&'b Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the - operator.

fn sub( self, rhs: &'b Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as Sub<&'b Vector<T, Arch>>>::Output

Performs the - operation.

impl<'a, T, Arch> Sub<Vector<T, Arch>> for &'a Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

type Output = Vector<T, Arch>

The resulting type after applying the - operator.

fn sub( self, rhs: Vector<T, Arch>, ) -> <&'a Vector<T, Arch> as Sub<Vector<T, Arch>>>::Output

Performs the - operation.

impl<T, Arch> SubAssign for Vector<T, Arch>

where Arch: SimdArch + SimdKernel<T>, T: NumericElement,

fn sub_assign(&mut self, rhs: Vector<T, Arch>)

Performs the -= operation.