Struct Vector 

pub struct Vector<R: Register>(/* private fields */);

SIMD Vector type.

This wraps a low-level register type and provides a vector-like interface, including operator overloading and element-wise operations.

Implementations

impl<R: Register> Vector<R>

pub const fn splat_const(value: R::Element) -> Self

👎Deprecated

Splat a value in a const context.

This is temporarily marked as deprecated until we can figure out a better way. Only use within a const {} block.

Trait Implementations

impl<R: NumericRegister + Register> Add for Vector<R>

type Output = Vector<R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: NumericRegister + Register> AddAssign for Vector<R>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<R: NumericRegister + Register> AddAssignMasked<Mask<R>> for Vector<R>

fn add_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes AddAssign with rhs where mask is true.

fn add_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges AddAssign with src using mask, assigning src where mask is false.

fn add_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes AddAssign masked (zeroed where mask is false).

impl<R: NumericRegister + Register> AddMasked<Mask<R>> for Vector<R>

fn add_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Add with rhs where mask is true.

fn add_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges Add with src using mask, returning src where mask is false.

fn add_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Add masked (zeroed where mask is false).

impl<R: FloatRegister> AddSubExt for Vector<R>

type Output = Vector<R>

The result of the lane-alternating operation.

fn addsub(self, b: Self) -> Self

[a0 - b0, a1 + b1, a2 - b2, ...] - even lanes subtract, odd lanes add.

fn fmaddsub(self, b: Self, c: Self) -> Self

[a0*b0 - c0, a1*b1 + c1, ...] - fused multiply then addsub.

fn fmsubadd(self, b: Self, c: Self) -> Self

[a0*b0 + c0, a1*b1 - c1, ...] - fused multiply then subadd (opposite parity).

impl<R: FloatRegister> AddSubExtMasked<Mask<R>> for Vector<R>

fn addsub_c(self, mask: Mask<R>, b: Self) -> Self

addsub where mask is true, else self.

fn addsub_m(self, src: Self, mask: Mask<R>, b: Self) -> Self

addsub where mask is true, else src.

fn addsub_z(self, mask: Mask<R>, b: Self) -> Self

addsub where mask is true, else zero.

fn fmaddsub_c(self, mask: Mask<R>, b: Self, c: Self) -> Self

fmaddsub where mask is true, else self.

fn fmaddsub_m(self, src: Self, mask: Mask<R>, b: Self, c: Self) -> Self

fmaddsub where mask is true, else src.

fn fmaddsub_z(self, mask: Mask<R>, b: Self, c: Self) -> Self

fmaddsub where mask is true, else zero.

fn fmsubadd_c(self, mask: Mask<R>, b: Self, c: Self) -> Self

fmsubadd where mask is true, else self.

fn fmsubadd_m(self, src: Self, mask: Mask<R>, b: Self, c: Self) -> Self

fmsubadd where mask is true, else src.

fn fmsubadd_z(self, mask: Mask<R>, b: Self, c: Self) -> Self

fmsubadd where mask is true, else zero.

impl<R: BitwiseRegister + Register> BitAnd for Vector<R>

type Output = Vector<R>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<R: BitwiseRegister + Register> BitAndAssign for Vector<R>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<R: BitwiseRegister + Register> BitAndAssignMasked<Mask<R>> for Vector<R>

fn bitand_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes BitAndAssign with rhs where mask is true.

fn bitand_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges BitAndAssign with src using mask, assigning src where mask is false.

fn bitand_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes BitAndAssign masked (zeroed where mask is false).

impl<R: BitwiseRegister + Register> BitAndMasked<Mask<R>> for Vector<R>

fn bitand_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes BitAnd with rhs where mask is true.

fn bitand_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges BitAnd with src using mask, returning src where mask is false.

fn bitand_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes BitAnd masked (zeroed where mask is false).

impl<R: BitwiseRegister + Register> BitAndNot for Vector<R>

type Output = Vector<R>

The result of the AND NOT.

fn bitandnot(self, rhs: Self) -> Self::Output

Computes self & !rhs, one instruction on every SIMD backend.

impl<R: BitwiseRegister + Register> BitAndNotAssign for Vector<R>

fn bitandnot_assign(&mut self, rhs: Self)

Assigns self & !rhs into self.

impl<R: BitwiseRegister + Register> BitAndNotAssignMasked<Mask<R>> for Vector<R>

fn bitandnot_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes BitAndNotAssign with rhs where mask is true.

fn bitandnot_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges BitAndNotAssign with src using mask, assigning src where mask is false.

fn bitandnot_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes BitAndNotAssign masked (zeroed where mask is false).

impl<R: BitwiseRegister + Register> BitAndNotMasked<Mask<R>> for Vector<R>

fn bitandnot_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes BitAndNot with rhs where mask is true.

fn bitandnot_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges BitAndNot with src using mask, returning src where mask is false.

fn bitandnot_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes BitAndNot masked (zeroed where mask is false).

impl<FROM, INTO> BitCastVector<Vector<FROM>> for Vector<INTO>

where FROM: Register, INTO: Register + BitCastRegister<FROM>,

fn from_bits(bits: Vector<FROM>) -> Self

Reinterpret the bit pattern of bits as a value of Self.

impl<R: BitwiseRegister + Register> BitOr for Vector<R>

type Output = Vector<R>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<R: BitwiseRegister + Register> BitOrAssign for Vector<R>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<R: BitwiseRegister + Register> BitOrAssignMasked<Mask<R>> for Vector<R>

fn bitor_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes BitOrAssign with rhs where mask is true.

fn bitor_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges BitOrAssign with src using mask, assigning src where mask is false.

fn bitor_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes BitOrAssign masked (zeroed where mask is false).

impl<R: BitwiseRegister + Register> BitOrMasked<Mask<R>> for Vector<R>

fn bitor_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes BitOr with rhs where mask is true.

fn bitor_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges BitOr with src using mask, returning src where mask is false.

fn bitor_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes BitOr masked (zeroed where mask is false).

impl<R: BitwiseRegister + Register> BitXor for Vector<R>

type Output = Vector<R>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<R: BitwiseRegister + Register> BitXorAssign for Vector<R>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<R: BitwiseRegister + Register> BitXorAssignMasked<Mask<R>> for Vector<R>

fn bitxor_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes BitXorAssign with rhs where mask is true.

fn bitxor_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges BitXorAssign with src using mask, assigning src where mask is false.

fn bitxor_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes BitXorAssign masked (zeroed where mask is false).

impl<R: BitwiseRegister + Register> BitXorMasked<Mask<R>> for Vector<R>

fn bitxor_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes BitXor with rhs where mask is true.

fn bitxor_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges BitXor with src using mask, returning src where mask is false.

fn bitxor_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes BitXor masked (zeroed where mask is false).

impl<R: BitshiftRegister> BitshiftVector for Vector<R>

const HAS_TRUE_SHIFTV: bool = R::HAS_TRUE_SHIFTV

true if the backend has a true per-lane variable shift instruction (e.g. AVX2 vpsllvd). When false, shlv / shrv are emulated and may be slower than splatting a scalar shift count through shli / shri.

const HAS_WIDE_BYTE_SHIFTS: bool = R::HAS_WIDE_BYTE_SHIFTS

true if the backend can byte-shift the entire vector as a single large integer at register widths above 128 bits without lane-boundary stitching. When false, bshli / bshri on wider vectors are emulated via shuffles.

fn bshli<const I: i32>(self) -> Self

Treats the entire vector as a single large integer and shifts left by the immediate value number of BYTES. Not bits, bytes.

fn bshri<const I: i32>(self) -> Self

Treats the entire vector as a single large integer and shifts right by the immediate value number of BYTES. Not bits, bytes.

fn shli<const I: i32>(self) -> Self

For each lane in the vector, shift left by the immediate value.

fn shri<const I: i32>(self) -> Self

For each lane in the vector, shift right by the immediate value.

fn shlv(self, shifts: Self::Unsigned) -> Self

For each lane in the vector, shift left by the given value.

fn shrv(self, shifts: Self::Unsigned) -> Self

For each lane in the vector, shift right by the given value.

fn rol(self, shift: u32) -> Self

For each element in the vector, rotate the bits to the left by the given number of bits.

fn ror(self, shift: u32) -> Self

For each element in the vector, rotate the bits to the right by the given number of bits.

fn roli<const I: i32>(self) -> Self

For each element in the vector, rotate the bits to the left by the immediate value number of bits.

fn rori<const I: i32>(self) -> Self

For each element in the vector, rotate the bits to the right by the immediate value number of bits.

fn rolv(self, counts: Self::Unsigned) -> Self

For each element in the vector, rotate the bits to the left by the given number of bits in the corresponding lane of counts.

fn rorv(self, counts: Self::Unsigned) -> Self

For each element in the vector, rotate the bits to the right by the given number of bits in the corresponding lane of counts.

fn reverse_bits(self) -> Self

For each element in the vector, reverse the bits of that element.

fn bshli_c<const I: i32>(self, mask: Mask<R>) -> Self

Treats the entire vector as a single large integer and shifts left by the immediate value number of BYTES. Not bits, bytes.

fn bshli_m<const I: i32>(self, src: Self, mask: Mask<R>) -> Self

Treats the entire vector as a single large integer and shifts left by the immediate value number of BYTES. Not bits, bytes.

fn bshli_z<const I: i32>(self, mask: Mask<R>) -> Self

Treats the entire vector as a single large integer and shifts left by the immediate value number of BYTES. Not bits, bytes.

fn bshri_c<const I: i32>(self, mask: Mask<R>) -> Self

Treats the entire vector as a single large integer and shifts right by the immediate value number of BYTES. Not bits, bytes.

fn bshri_m<const I: i32>(self, src: Self, mask: Mask<R>) -> Self

Treats the entire vector as a single large integer and shifts right by the immediate value number of BYTES. Not bits, bytes.

fn bshri_z<const I: i32>(self, mask: Mask<R>) -> Self

Treats the entire vector as a single large integer and shifts right by the immediate value number of BYTES. Not bits, bytes.

fn shli_c<const I: i32>(self, mask: Mask<R>) -> Self

For each lane in the vector, shift left by the immediate value. Computes shli when mask is true, returns self where false.

fn shli_m<const I: i32>(self, src: Self, mask: Mask<R>) -> Self

For each lane in the vector, shift left by the immediate value. Merges shli with src using mask.

fn shli_z<const I: i32>(self, mask: Mask<R>) -> Self

For each lane in the vector, shift left by the immediate value. Computes shli masked (zeroed where mask is false).

fn shri_c<const I: i32>(self, mask: Mask<R>) -> Self

For each lane in the vector, shift right by the immediate value. Computes shri when mask is true, returns self where false.

fn shri_m<const I: i32>(self, src: Self, mask: Mask<R>) -> Self

For each lane in the vector, shift right by the immediate value. Merges shri with src using mask.

fn shri_z<const I: i32>(self, mask: Mask<R>) -> Self

For each lane in the vector, shift right by the immediate value. Computes shri masked (zeroed where mask is false).

fn shlv_c(self, mask: Mask<R>, shifts: Self::Unsigned) -> Self

For each lane in the vector, shift left by the given value. Computes shlv when mask is true, returns self where false.

fn shlv_m(self, src: Self, mask: Mask<R>, shifts: Self::Unsigned) -> Self

For each lane in the vector, shift left by the given value. Merges shlv with src using mask.

fn shlv_z(self, mask: Mask<R>, shifts: Self::Unsigned) -> Self

For each lane in the vector, shift left by the given value. Computes shlv masked (zeroed where mask is false).

fn shrv_c(self, mask: Mask<R>, shifts: Self::Unsigned) -> Self

For each lane in the vector, shift right by the given value. Computes shrv when mask is true, returns self where false.

fn shrv_m(self, src: Self, mask: Mask<R>, shifts: Self::Unsigned) -> Self

For each lane in the vector, shift right by the given value. Merges shrv with src using mask.

fn shrv_z(self, mask: Mask<R>, shifts: Self::Unsigned) -> Self

For each lane in the vector, shift right by the given value. Computes shrv masked (zeroed where mask is false).

fn rol_c(self, mask: Mask<R>, shift: u32) -> Self

For each element in the vector, rotate the bits to the left by the given number of bits. Computes rol when mask is true, returns self where false.

fn rol_m(self, src: Self, mask: Mask<R>, shift: u32) -> Self

For each element in the vector, rotate the bits to the left by the given number of bits. Merges rol with src using mask.

fn rol_z(self, mask: Mask<R>, shift: u32) -> Self

For each element in the vector, rotate the bits to the left by the given number of bits. Computes rol masked (zeroed where mask is false).

fn ror_c(self, mask: Mask<R>, shift: u32) -> Self

For each element in the vector, rotate the bits to the right by the given number of bits. Computes ror when mask is true, returns self where false.

fn ror_m(self, src: Self, mask: Mask<R>, shift: u32) -> Self

For each element in the vector, rotate the bits to the right by the given number of bits. Merges ror with src using mask.

fn ror_z(self, mask: Mask<R>, shift: u32) -> Self

For each element in the vector, rotate the bits to the right by the given number of bits. Computes ror masked (zeroed where mask is false).

fn roli_c<const I: i32>(self, mask: Mask<R>) -> Self

For each element in the vector, rotate the bits to the left by the immediate value number of bits. Computes roli when mask is true, returns self where false.

fn roli_m<const I: i32>(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, rotate the bits to the left by the immediate value number of bits. Merges roli with src using mask.

fn roli_z<const I: i32>(self, mask: Mask<R>) -> Self

For each element in the vector, rotate the bits to the left by the immediate value number of bits. Computes roli masked (zeroed where mask is false).

fn rori_c<const I: i32>(self, mask: Mask<R>) -> Self

For each element in the vector, rotate the bits to the right by the immediate value number of bits. Computes rori when mask is true, returns self where false.

fn rori_m<const I: i32>(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, rotate the bits to the right by the immediate value number of bits. Merges rori with src using mask.

fn rori_z<const I: i32>(self, mask: Mask<R>) -> Self

For each element in the vector, rotate the bits to the right by the immediate value number of bits. Computes rori masked (zeroed where mask is false).

fn rolv_c(self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each element in the vector, rotate the bits to the left by the given number of bits in the corresponding lane of counts. Computes rolv when mask is true, returns self where false.

fn rolv_m(self, src: Self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each element in the vector, rotate the bits to the left by the given number of bits in the corresponding lane of counts. Merges rolv with src using mask.

fn rolv_z(self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each element in the vector, rotate the bits to the left by the given number of bits in the corresponding lane of counts. Computes rolv masked (zeroed where mask is false).

fn rorv_c(self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each element in the vector, rotate the bits to the right by the given number of bits in the corresponding lane of counts. Computes rorv when mask is true, returns self where false.

fn rorv_m(self, src: Self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each element in the vector, rotate the bits to the right by the given number of bits in the corresponding lane of counts. Merges rorv with src using mask.

fn rorv_z(self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each element in the vector, rotate the bits to the right by the given number of bits in the corresponding lane of counts. Computes rorv masked (zeroed where mask is false).

fn reverse_bits_c(self, mask: Mask<R>) -> Self

For each element in the vector, reverse the bits of that element. Computes reverse_bits when mask is true, returns self where false.

fn reverse_bits_m(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, reverse the bits of that element. Merges reverse_bits with src using mask.

fn reverse_bits_z(self, mask: Mask<R>) -> Self

For each element in the vector, reverse the bits of that element. Computes reverse_bits masked (zeroed where mask is false).

impl<R: BitwiseRegister + Register> BitwiseVector for Vector<R>

const HAS_NATIVE_TERNLOG: bool = R::HAS_NATIVE_TERNLOG

Whether ternlog is a single native instruction (AVX-512 vpternlog{d,q}), forwarded from BitwiseRegister::HAS_NATIVE_TERNLOG.

fn ternlog<const IMM: i32>(a: Self, b: Self, c: Self) -> Self

Computes an arbitrary bitwise boolean function of three inputs (a, b, c) based on the truth table specified by IMM.

fn bilog<const IMM: i32>(a: Self, b: Self) -> Self

Two-input version of ternlog.

fn ternlog_c<const IMM: i32>(mask: Mask<R>, a: Self, b: Self, c: Self) -> Self

Computes an arbitrary bitwise boolean function of three inputs (a, b, c) based on the truth table specified by IMM.

fn ternlog_m<const IMM: i32>( src: Self, mask: Mask<R>, a: Self, b: Self, c: Self, ) -> Self

Computes an arbitrary bitwise boolean function of three inputs (a, b, c) based on the truth table specified by IMM.

fn ternlog_z<const IMM: i32>(mask: Mask<R>, a: Self, b: Self, c: Self) -> Self

Computes an arbitrary bitwise boolean function of three inputs (a, b, c) based on the truth table specified by IMM.

fn bilog_c<const IMM: i32>(mask: Mask<R>, a: Self, b: Self) -> Self

Two-input version of ternlog.

fn bilog_m<const IMM: i32>(src: Self, mask: Mask<R>, a: Self, b: Self) -> Self

Two-input version of ternlog.

fn bilog_z<const IMM: i32>(mask: Mask<R>, a: Self, b: Self) -> Self

Two-input version of ternlog.

impl<R: NumericRegister> Bounded for Vector<R>

fn max_value() -> Self

Returns the largest finite number this type can represent

fn min_value() -> Self

Returns the smallest finite number this type can represent

impl<FROM, INTO> CastVector<Vector<FROM>> for Vector<INTO>

where FROM: Register + CastRegister<INTO>, INTO: Register + CastRegister<FROM>,

fn cast_from(from: Vector<FROM>) -> Self

Convert a vector of type FROM into Self, lane-by-lane, using as semantics on each element. See the trait docs for what float-to-int does with NaN and out-of-range lanes.

fn cast_into(self) -> Vector<FROM>

Convert this vector into a vector of type FROM, lane-by-lane.

fn fast_cast_into(self) -> Vector<FROM>

Like cast_into, but may take a faster path that relaxes IEEE corner cases. See GenericVector::fast_cast.

fn saturating_cast_from(from: Vector<FROM>) -> Self

Convert lane-by-lane, clamping out-of-range values to Self’s element range rather than wrapping (integers) or producing a backend-defined value (float to int).

fn fast_cast_from(from: Vector<FROM>) -> Self

Like cast_from, but may take a faster path that relaxes IEEE corner cases. See GenericVector::fast_cast.

impl<R: Register> Clone for Vector<R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Register, B> Concat<Vector<R>> for Vector<B>

where B: ConcatRegister<R> + Register,

fn concat(lo: Vector<R>, hi: Vector<R>) -> Self

Build the double-width value from a lo and hi half, with lo’s lanes occupying the lower half of the result and hi’s the upper half.

fn split(self) -> (Vector<R>, Vector<R>)

Split into (lo, hi) halves, the inverse of concat.

impl<R: Register> ConstDefault for Vector<R>

const DEFAULT: Self = Self::EMPTY

The constant default value.

impl<R: Register> Copy for Vector<R>

impl<R: Register> Debug for Vector<R>

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

Formats the value using the given formatter.

impl<R: Register> Default for Vector<R>

fn default() -> Self

Returns the “default value” for a type.

impl<R: NumericRegister + Register> Div for Vector<R>

type Output = Vector<R>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: IntegerRegister> Div<BranchfreeDivider<<R as Register>::Element>> for Vector<R>

type Output = Vector<R>

The resulting type after applying the / operator.

fn div(self, rhs: BranchfreeDivider<R::Element>) -> Self::Output

Performs the / operation.

impl<R: IntegerRegister> Div<Divider<<R as Register>::Element>> for Vector<R>

type Output = Vector<R>

The resulting type after applying the / operator.

fn div(self, rhs: Divider<R::Element>) -> Self::Output

Performs the / operation.

impl<R: IntegerRegister> Div<VectorDivider<R>> for Vector<R>

type Output = Vector<R>

The resulting type after applying the / operator.

fn div(self, rhs: VectorDivider<R>) -> Self::Output

Performs the / operation.

impl<R: NumericRegister + Register> DivAssign for Vector<R>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<R: NumericRegister + Register> DivAssignMasked<Mask<R>> for Vector<R>

fn div_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes DivAssign with rhs where mask is true.

fn div_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges DivAssign with src using mask, assigning src where mask is false.

fn div_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes DivAssign masked (zeroed where mask is false).

impl<R: IntegerRegister> DivMasked<Mask<R>, BranchfreeDivider<<R as Register>::Element>> for Vector<R>

where R::Element: Denominator,

fn div_c( self, mask: Mask<R>, rhs: BranchfreeDivider<R::Element>, ) -> Self::Output

Computes Div with rhs where mask is true.

fn div_m( self, src: Self, mask: Mask<R>, rhs: BranchfreeDivider<R::Element>, ) -> Self::Output

Merges Div with src using mask, returning src where mask is false.

fn div_z( self, mask: Mask<R>, rhs: BranchfreeDivider<R::Element>, ) -> Self::Output

Computes Div masked (zeroed where mask is false).

impl<R: IntegerRegister> DivMasked<Mask<R>, Divider<<R as Register>::Element>> for Vector<R>

where R::Element: Denominator,

fn div_c(self, mask: Mask<R>, rhs: Divider<R::Element>) -> Self::Output

Computes Div with rhs where mask is true.

fn div_m( self, src: Self, mask: Mask<R>, rhs: Divider<R::Element>, ) -> Self::Output

Merges Div with src using mask, returning src where mask is false.

fn div_z(self, mask: Mask<R>, rhs: Divider<R::Element>) -> Self::Output

Computes Div masked (zeroed where mask is false).

impl<R: IntegerRegister> DivMasked<Mask<R>, VectorDivider<R>> for Vector<R>

where R::Element: Denominator,

fn div_c(self, mask: Mask<R>, rhs: VectorDivider<R>) -> Self::Output

Computes Div with rhs where mask is true.

fn div_m(self, src: Self, mask: Mask<R>, rhs: VectorDivider<R>) -> Self::Output

Merges Div with src using mask, returning src where mask is false.

fn div_z(self, mask: Mask<R>, rhs: VectorDivider<R>) -> Self::Output

Computes Div masked (zeroed where mask is false).

impl<R: NumericRegister + Register> DivMasked<Mask<R>> for Vector<R>

fn div_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Div with rhs where mask is true.

fn div_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges Div with src using mask, returning src where mask is false.

fn div_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Div masked (zeroed where mask is false).

impl<R: Register, B> Extend<Vector<R>> for Vector<B>

where B: ExtendRegister<R> + Register,

fn extend(v: Vector<R>) -> Self

Widen v into Self, placing v’s lanes in the lower half and filling the upper half with zeros.

fn narrow(self) -> Vector<R>

Narrow back to FROM by keeping the lower lanes and discarding the upper lanes.

impl<R: FloatRegister<Element: FloatConsts>> FloatConsts for Vector<R>

const NEG_ZERO: Self

Negative zero (-0) (only sign bit set)

const E: Self

Euler’s number (e)

const EULER_GAMMA: Self

Euler-Mascheroni constant (γ)

const PI_SQUARED: Self

$\pi^2$

const PI_CUBED: Self

$\pi^3$

const PI_FOURTH: Self

$\pi^4$

const FRAC_1_PI: Self

$1/\pi$

const FRAC_1_SQRT_2: Self

$1/\sqrt{2}$

const FRAC_1_SQRT_3: Self

$1/\sqrt{3}$

const FRAC_2_PI: Self

$2/\pi$

const FRAC_1_SQRT_PI: Self

$1/\sqrt{\pi}$

const FRAC_2_SQRT_PI: Self

$2/\sqrt{\pi}$

const FRAC_SQRT_PI_2: Self

$\sqrt{\pi}/2$

const FRAC_1_SQRT_TAU: Self

$1/\sqrt{2\pi}$

const FRAC_PI_2: Self

$\pi/2$

const FRAC_PI_3: Self

$\pi/3$

const FRAC_PI_4: Self

$\pi/4$

const FRAC_PI_6: Self

$\pi/6$

const FRAC_PI_8: Self

$\pi/8$

const FRAC_PI_180: Self

$\pi/180$

const FRAC_180_PI: Self

$180/\pi$

const LN_2: Self

$\ln 2$

const LN_10: Self

$\ln 10$

const LN_PI: Self

$\ln \pi$

const FRAC_LN_PI_2: Self

$frac{1}{2}\ln \pi$

const LOG2_10: Self

$\log_2 10$

const LOG2_E: Self

$\log_2 e$

const LOG10_2: Self

$\log_{10} 2$

const LOG10_E: Self

$\log_{10} e$

const PI: Self

Archimedes’ constant (π)

const SQRT_2: Self

$\sqrt{2}$

const SQRT_3: Self

$\sqrt{3}$

const SQRT_E: Self

$\sqrt{e}$

const EPSILON: Self

The machine epsilon

const SQRT_EPSILON: Self

The square root of the machine epsilon ($\sqrt{arepsilon}$)

const FOURTH_ROOT_EPSILON: Self

The fourth root of the machine epsilon ($\sqrt[4]{arepsilon}$)

const TAU: Self

The full circle constant (τ)

const SQRT_FRAC_PI_2: Self

$\sqrt{\pi/2}$

const SQRT_TAU: Self

$\sqrt{2\pi}$

const PHI: Self

The golden ratio (φ)

const FRAC_1_3: Self

$1/3$

const FRAC_2_3: Self

$2/3$

const FRAC_1_4: Self

1/4

const FRAC_1_6: Self

1/6

const FRAC_NEG_1_E: Self

-1/e

impl<R: FloatRegister> FloatVector for Vector<R>

const HALF: Self

The value 0.5 represented in this vector type.

const NEG_ZERO: Self

The value -0.0 represented in this vector type.

const INFINITY: Self

The value infinity represented in this vector type.

const NEG_INFINITY: Self

The value -infinity represented in this vector type.

const NAN: Self

The value NaN represented in this vector type.

const EPSILON: Self

Hardware epsilon value in this vector type.

const HAS_APPROX_RCP: bool = R::HAS_APPROX_RCP

true if the backend has a hardware approximate-reciprocal instruction (e.g. rcpps on x86). When false, rcp falls back to a full IEEE division and provides no speed advantage over Self::ONE / self.

const HAS_APPROX_RSQRT: bool = R::HAS_APPROX_RSQRT

true if the backend has a hardware approximate-reciprocal-square-root instruction (e.g. rsqrtps on x86). When false, rsqrt falls back to Self::ONE / self.sqrt().

type ExtendedPrecision = Vector<<R as FloatRegister>::ExtendedPrecision>

If available, an extended precision floating point vector type corresponding to this vector type. E.g., for f32 vectors, this would be an f64 vector type.

fn is_infinite(self) -> Self::Mask

Check if each element in the vector is infinite, returning a mask.

fn is_finite(self) -> Self::Mask

Check if each element in the vector is finite, returning a mask.

fn is_nan(self) -> Self::Mask

Check if each element in the vector is NaN, returning a mask.

fn is_zero_or_subnormal(self) -> Self::Mask

Check if each element in the vector is zero or subnormal, returning a mask.

fn is_normal(self) -> Self::Mask

Check if each element in the vector is normal, returning a mask.

fn is_subnormal(self) -> Self::Mask

Check if each element in the vector is subnormal, returning a mask.

fn sqrt(self) -> Self

Lane-wise IEEE 754 square root.

fn rsqrt(self) -> Self

Lane-wise approximate reciprocal square root.

fn rcp(self) -> Self

Lane-wise approximate reciprocal: 1 / self.

fn floor(self) -> Self

Lane-wise floor: largest integer less than or equal to each element.

fn ceil(self) -> Self

Lane-wise ceiling: smallest integer greater than or equal to each element, kept in the float representation.

fn round(self) -> Self

Lane-wise round-to-nearest.

fn trunc(self) -> Self

Lane-wise truncation toward zero (drops the fractional part), kept in the float representation.

fn fract(self) -> Self

Lane-wise fractional part: self - self.trunc().

fn mul_sign(self, sign: Self) -> Self

Effectively self * sign.signum(), multiplying the sign bits.

fn signed_zero(self) -> Self

Returns zero with the sign of self, i.e.: only the sign bit is set.

fn next_up(self) -> Self

Returns the next representable value greater than the current value, towards positive infinity.

fn next_down(self) -> Self

Returns the next representable value less than the current value, towards negative infinity.

fn mix(self, a: Self, b: Self) -> Self

Linearly interpolates between a and b by self, where self is typically in the range [0, 1].

unsafe fn block_autovectorization(&mut self)

Inhibit further LLVM auto-vectorization of code surrounding this call.

fn with_bits<const N: usize, K: AsFloatVectorWithBitsKernel<Self, N>>( values: [Self; N], kernel: K, ) -> Option<<K as AsFloatVectorWithBitsKernel<Self, N>>::Output>

Attempt to upcast this FloatVector to a FloatVectorWithBits, using the provided kernel. If not possible, returns None.

fn sqrt_c(self, mask: Mask<R>) -> Self

Lane-wise IEEE 754 square root.

fn sqrt_m(self, src: Self, mask: Mask<R>) -> Self

Lane-wise IEEE 754 square root.

fn sqrt_z(self, mask: Mask<R>) -> Self

Lane-wise IEEE 754 square root.

fn rsqrt_c(self, mask: Mask<R>) -> Self

Lane-wise approximate reciprocal square root.

fn rsqrt_m(self, src: Self, mask: Mask<R>) -> Self

Lane-wise approximate reciprocal square root.

fn rsqrt_z(self, mask: Mask<R>) -> Self

Lane-wise approximate reciprocal square root.

fn rcp_c(self, mask: Mask<R>) -> Self

Lane-wise approximate reciprocal: 1 / self.

fn rcp_m(self, src: Self, mask: Mask<R>) -> Self

Lane-wise approximate reciprocal: 1 / self.

fn rcp_z(self, mask: Mask<R>) -> Self

Lane-wise approximate reciprocal: 1 / self.

fn floor_c(self, mask: Mask<R>) -> Self

Lane-wise floor: largest integer less than or equal to each element.

fn floor_m(self, src: Self, mask: Mask<R>) -> Self

Lane-wise floor: largest integer less than or equal to each element.

fn floor_z(self, mask: Mask<R>) -> Self

Lane-wise floor: largest integer less than or equal to each element.

fn ceil_c(self, mask: Mask<R>) -> Self

Lane-wise ceiling: smallest integer greater than or equal to each element, kept in the float representation. Computes ceil when mask is true, returns self where false.

fn ceil_m(self, src: Self, mask: Mask<R>) -> Self

Lane-wise ceiling: smallest integer greater than or equal to each element, kept in the float representation. Merges ceil with src using mask.

fn ceil_z(self, mask: Mask<R>) -> Self

Lane-wise ceiling: smallest integer greater than or equal to each element, kept in the float representation. Computes ceil masked (zeroed where mask is false).

fn round_c(self, mask: Mask<R>) -> Self

Lane-wise round-to-nearest.

fn round_m(self, src: Self, mask: Mask<R>) -> Self

Lane-wise round-to-nearest.

fn round_z(self, mask: Mask<R>) -> Self

Lane-wise round-to-nearest.

fn trunc_c(self, mask: Mask<R>) -> Self

Lane-wise truncation toward zero (drops the fractional part), kept in the float representation. Computes trunc when mask is true, returns self where false.

fn trunc_m(self, src: Self, mask: Mask<R>) -> Self

Lane-wise truncation toward zero (drops the fractional part), kept in the float representation. Merges trunc with src using mask.

fn trunc_z(self, mask: Mask<R>) -> Self

Lane-wise truncation toward zero (drops the fractional part), kept in the float representation. Computes trunc masked (zeroed where mask is false).

fn fract_c(self, mask: Mask<R>) -> Self

Lane-wise fractional part: self - self.trunc().

fn fract_m(self, src: Self, mask: Mask<R>) -> Self

Lane-wise fractional part: self - self.trunc().

fn fract_z(self, mask: Mask<R>) -> Self

Lane-wise fractional part: self - self.trunc().

fn mul_sign_c(self, mask: Mask<R>, sign: Self) -> Self

Effectively self * sign.signum(), multiplying the sign bits. Computes mul_sign when mask is true, returns self where false.

fn mul_sign_m(self, src: Self, mask: Mask<R>, sign: Self) -> Self

Effectively self * sign.signum(), multiplying the sign bits. Merges mul_sign with src using mask.

fn mul_sign_z(self, mask: Mask<R>, sign: Self) -> Self

Effectively self * sign.signum(), multiplying the sign bits. Computes mul_sign masked (zeroed where mask is false).

fn signed_zero_c(self, mask: Mask<R>) -> Self

Returns zero with the sign of self, i.e.: only the sign bit is set. Computes signed_zero when mask is true, returns self where false.

fn signed_zero_m(self, src: Self, mask: Mask<R>) -> Self

Returns zero with the sign of self, i.e.: only the sign bit is set. Merges signed_zero with src using mask.

fn signed_zero_z(self, mask: Mask<R>) -> Self

Returns zero with the sign of self, i.e.: only the sign bit is set. Computes signed_zero masked (zeroed where mask is false).

fn next_up_c(self, mask: Mask<R>) -> Self

Returns the next representable value greater than the current value, towards positive infinity. Computes next_up when mask is true, returns self where false.

fn next_up_m(self, src: Self, mask: Mask<R>) -> Self

Returns the next representable value greater than the current value, towards positive infinity. Merges next_up with src using mask.

fn next_up_z(self, mask: Mask<R>) -> Self

Returns the next representable value greater than the current value, towards positive infinity. Computes next_up masked (zeroed where mask is false).

fn next_down_c(self, mask: Mask<R>) -> Self

Returns the next representable value less than the current value, towards negative infinity. Computes next_down when mask is true, returns self where false.

fn next_down_m(self, src: Self, mask: Mask<R>) -> Self

Returns the next representable value less than the current value, towards negative infinity. Merges next_down with src using mask.

fn next_down_z(self, mask: Mask<R>) -> Self

Returns the next representable value less than the current value, towards negative infinity. Computes next_down masked (zeroed where mask is false).

fn one_minus_sq(self) -> Self

Computes $1 - x^2$ accurately, avoiding the cancellation a naive 1 - self * self suffers as self approaches ±1 (where the result is small but self * self is near 1).

impl<R: FloatRegister> FloatVectorWithBits for Vector<R>

const NATIVE_CAP: NativeCapability = R::NATIVE_CAP

Bit-flag set describing which native_* methods on this trait have a real hardware implementation on the current backend.

type SignedBits = Vector<<R as FloatRegister>::SignedBits>

This vector’s bit pattern viewed as signed integer lanes of the same width, for exponent arithmetic and the sign-aware bit tricks.

type Bits = Vector<<R as FloatRegister>::Bits>

This vector’s bit pattern viewed as unsigned integer lanes of the same width, which is what masking and shifting the raw bits wants.

unsafe fn native_ldexp(self, exp: Self::SignedBits) -> Self

Hardware-accelerated ldexp: self * 2^exp, lane-wise.

unsafe fn native_frexp(self) -> (Self, Self::SignedBits)

Hardware-accelerated frexp: split each lane into a normalized mantissa in [0.5, 1.0) and an integer exponent.

unsafe fn native_sin_cos<P: Policy>(self) -> (Self, Self)

Hardware-accelerated combined sine and cosine, lane-wise.

unsafe fn native_sin<P: Policy>(self) -> Self

Hardware-accelerated sine, lane-wise.

unsafe fn native_cos<P: Policy>(self) -> Self

Hardware-accelerated cosine, lane-wise.

unsafe fn native_tan<P: Policy>(self) -> Self

Hardware-accelerated tangent, lane-wise.

unsafe fn native_exp2<P: Policy>(self) -> Self

Hardware-accelerated 2^self, lane-wise.

unsafe fn native_log2<P: Policy>(self) -> Self

Hardware-accelerated log2(self), lane-wise.

unsafe fn native_exp<P: Policy>(self) -> Self

Hardware-accelerated e^self, lane-wise.

unsafe fn native_ln<P: Policy>(self) -> Self

Hardware-accelerated natural logarithm, lane-wise.

unsafe fn native_powf<P: Policy>(self, exp: Self) -> Self

Hardware-accelerated self^exp, lane-wise.

fn total_order(self) -> Self::SignedBits

Return a signed integer vector that is capable of encapsulating the “total order” of the floating point values in this vector, /// such that when compared as integers, the ordering is the same as the floating point ordering, including NaNs, in the following order:

fn linear_order(self) -> Self::SignedBits

Similar to total_order, but positive zero and negative zero are the same value. This can be used for calculating ULP differences by simply subtracting one from another.

impl<R> FloatVectorWithRegister for Vector<R>

where R: FloatRegister,

type Register = R

The backing hardware register this vector is a thin wrapper over.

impl<R> From<Vector<R>> for Mask<R>

where R: NumericRegister + Register,

fn from(value: Vector<R>) -> Self

Converts a vector of R into a mask. The mask will have all bits set to true if the corresponding element in the vector is non-zero, and false otherwise.

impl<R> GenericSelectable for Vector<R>

where R: Register,

type SelectableMask = Mask<R>

The mask type whose lane count and layout match Self.

fn select<M>(mask: M, t: Self, f: Self) -> Self

where Mask<R>: CastMask<M>,

For each lane, take the value from t where mask is true, otherwise from f.

impl<R: Register> GenericVector for Vector<R>

const EMPTY: Self

A vector with all elements zeroed.

const LANES: usize = <R::Lanes as generic_array::typenum::Unsigned>::USIZE

Number of lanes in the vector.

const HAS_NATIVE_ALIGN: bool = R::HAS_NATIVE_ALIGN

Whether align is a native cross-register instruction rather than the generic shuffle-and-blend fallback, forwarded from Register::HAS_NATIVE_ALIGN.

type Element = <R as Register>::Element

Scalar element type of the vector.

type Lanes = <R as CoreRegister>::Lanes

Number of lanes in the vector, as a typenum.

type Unsigned = Vector<<R as Register>::Unsigned>

Unsigned Integer Type suitable for use with this vector.

type Signed = Vector<<R as Register>::Signed>

SignedBits Integer Type suitable for use with this vector.

type Mask = Mask<R>

Mask type for this vector. Masks are semantically boolean vectors indicating true or false for each lane. They may or may not be represented as actual bits.

fn new<const N: usize>(values: [R::Element; N]) -> Self

where Const<N>: IntoArrayLength<ArrayLength = R::Lanes>,

Create a new vector from an array of elements.

fn into_array(self) -> GenericArray<R::Element, R::Lanes>

Consume the vector and return its elements as a GenericArray.

fn splat(value: Self::Element) -> Self

Create a new vector from a single element by splatting it across all lanes.

fn single(value: Self::Element) -> Self

Create a new vector with the first lane set to the given value, and all other lanes set to zero.

fn broadcast<const I: usize>(self) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn broadcastv(self, idx: usize) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn extract<const I: usize>(self) -> Self::Element

Extract a single element from the vector at the const-generic index I.

fn extractv(self, idx: usize) -> Self::Element

Extract a single element from the vector at the runtime index idx.

fn insert<const I: usize>(self, value: Self::Element) -> Self

Replace a single element in the vector at the const-generic index I.

fn insertv(self, idx: usize, value: Self::Element) -> Self

Replace a single element in the vector at the runtime index idx.

unsafe fn lookup_unchecked( values: &[Self::Element], indices: Self::Unsigned, ) -> Self

Assemble a vector from a slice of elements and a vector of indices into that slice. The indices are NOT checked to be within bounds.

fn reverse(self) -> Self

Reverse the order of the elements in the vector.

fn swap_bytes(self) -> Self

Swap the byte order of each element in the vector, converting between little-endian and big-endian representations lane-by-lane.

fn compress(self, mask: Self::Mask) -> Self

Left-pack (a.k.a. compress): gather the lanes where mask is true into the low lanes, preserving their relative order. The unselected lanes are kept (not zeroed) and packed into the high lanes, also in order - a stable partition of the vector by mask.

fn compress_z(self, mask: Self::Mask) -> Self

Zero-filling left-pack: like compress, but the lanes beyond the mask population count are zeroed instead of holding the unselected elements. Matches AVX-512 zero-masking vpcompress*.

fn compress_m(self, src: Self, mask: Self::Mask) -> Self

Merge-masked left-pack: like compress, but the lanes at and beyond the mask population count take their values from src (at their own positions). Matches AVX-512 merge-masked vpcompress*.

fn expand(self, mask: Self::Mask) -> Self

Inverse left-pack (expand): scatter this vector’s packed low lanes back out to the lanes where mask is set, preserving order; the unselected lanes read the tail. The exact inverse permutation of compress: v.compress(m).expand(m) == v and v.expand(m).compress(m) == v for every v and m.

fn expand_z(self, mask: Self::Mask) -> Self

Zero-filling inverse left-pack: like expand, but the unselected lanes are zeroed. Matches AVX-512 zero-masking vpexpand*.

fn expand_m(self, src: Self, mask: Self::Mask) -> Self

Merge-masked inverse left-pack: like expand, but the unselected lanes take their values from src. Matches AVX-512 merge-masked vpexpand*.

fn align<const OFFSET: usize>(self, other: Self) -> Self

Two-register element align (the palignr family): the window of LANES lanes starting at lane OFFSET of the concatenation [self, other] (self’s lanes first, then other’s). OFFSET == 0 returns self, OFFSET == LANES returns other; in between, lanes spill from the tail of self into the head of other.

fn zz(self, mask: Self::Mask) -> Self

(Zero If False) Zero elements if the corresponding mask lane is false; otherwise, leave unchanged.

fn nz(self, mask: Self::Mask) -> Self

(Zero If True) Zero elements if the corresponding mask lane is true; otherwise, leave unchanged.

fn map<F>(self, f: F) -> Self

where F: Fn(Self::Element) -> Self::Element,

Apply a function to each element in the vector, returning a new vector with the results.

fn fold<F>(self, init: Self::Element, f: F) -> Self::Element

where F: Fn(Self::Element, Self::Element) -> Self::Element,

Fold the elements of the vector using the provided function and initial value.

fn reduce<F>(self, f: F) -> Self::Element

where F: Fn(Self::Element, Self::Element) -> Self::Element,

Reduce the elements of the vector using the provided function.

unsafe fn load(ptr: *const Self::Element) -> Self

Load a vector from an aligned pointer to its elements.

unsafe fn load_unaligned(ptr: *const Self::Element) -> Self

Load a vector from an unaligned pointer to its elements.

unsafe fn load_streaming(ptr: *const Self::Element) -> Self

Load a vector from a pointer to its elements using non-temporal (streaming) loads.

unsafe fn store(self, ptr: *mut Self::Element)

Store the vector to an aligned pointer to its elements.

unsafe fn store_masked(self, mask: Self::Mask, ptr: *mut Self::Element)

Store the vector to an aligned pointer to its elements, but only for lanes where the corresponding mask lane is true. For lanes where the mask is false, the store is suppressed without panicking.

unsafe fn store_unaligned(self, ptr: *mut Self::Element)

Store the vector to an unaligned pointer to its elements.

unsafe fn store_streaming(self, ptr: *mut Self::Element)

Store the vector to a pointer to its elements using non-temporal (streaming) stores.

fn interleave_by<const GROUP: usize>(self, other: Self) -> (Self, Self)

Interleave two vectors at group granularity: blocks of GROUP consecutive elements move as a unit and are never split. GROUP == 1 is interleave; GROUP == 2 is the complex interleave - lo == [a.c0, b.c0, a.c1, b.c1, ...] over the low half of the groups, hi over the high half - which lowers to the doubled-element unpack (unpacklo_pd + permute2f128 on AVX2, zip on NEON) rather than a general permute. The primitive for complex FFT transposes and any group-structured SIMD. GROUP must divide LANES.

fn deinterleave_by<const GROUP: usize>(self, other: Self) -> (Self, Self)

The inverse of interleave_by - group-granularity de-interleave.

fn interleave_radix<const N: usize>(inputs: [Self; N]) -> [Self; N]

Radix-N interleave: the generic sibling of interleave (N == 2). Treats the N inputs as one contiguous N * LANES span and gives out with concat(out)[q * N + r] == inputs[r].extract(q).

fn deinterleave_radix<const N: usize>(inputs: [Self; N]) -> [Self; N]

The inverse of interleave_radix - radix-N de-interleave: out[r].extract(q) == concat(inputs)[q * N + r].

fn deinterleave_radix_by<const N: usize, const GROUP: usize>( inputs: [Self; N], ) -> [Self; N]

Group-granularity radix-N de-interleave: the two-axis unification of deinterleave_radix (GROUP == 1) and deinterleave_by (N == 2). Each vector is viewed as LANES / GROUP groups of GROUP consecutive elements; out[r] group q is the (q * N + r)-th group of the concatenated input sequence, each group moving as a unit.

fn interleave_radix_by<const N: usize, const GROUP: usize>( inputs: [Self; N], ) -> [Self; N]

The inverse of deinterleave_radix_by - group-granularity radix-N interleave. For the square case it is the same (self-inverse) register-array transpose.

unsafe fn load_deinterleaved<const N: usize>( ptr: *const Self::Element, ) -> [Self; N]

Load N interleaved (array-of-structures) streams and de-interleave them into N vectors: reads N * LANES contiguous elements from ptr and returns out with out[j].extract(lane) == ptr[lane * N + j].

unsafe fn store_interleaved<const N: usize>( ptr: *mut Self::Element, values: [Self; N], )

Interleave N vectors and store them contiguously as an array-of-structures: writes N * LANES elements such that ptr[lane * N + j] == values[j].extract(lane).

unsafe fn load_deinterleaved_arrays<const M: usize, const C: usize>( ptr: *const Self::Element, ) -> [[Self; C]; M]

Load M interleaved AoS records of C components each and de-interleave them: reads M * C * LANES contiguous elements, and out[j][c] holds component c of record j (out[j][c].extract(lane) == ptr[lane * M * C + j * C + c]).

unsafe fn store_interleaved_arrays<const M: usize, const C: usize>( ptr: *mut Self::Element, values: [[Self; C]; M], )

Interleave M records of C components and store them contiguously - the exact inverse of load_deinterleaved_arrays, with the same lane-wise default.

unsafe fn load_deinterleaved_grouped<const M: usize, const TAIL: usize>( ptr: *const Self::Element, ) -> [StreamGroup<Self, TAIL>; M]

Load M interleaved composite streams of 1 + TAIL components each and de-interleave them into M StreamGroups: reads M * (TAIL + 1) * LANES contiguous elements, and group j’s head/tail[c - 1] hold the de-interleaved components of composite stream j. See StreamGroup for why the component count is a separate const generic, and Register::load_deinterleaved_grouped for the register-level strategy.

unsafe fn store_interleaved_grouped<const M: usize, const TAIL: usize>( ptr: *mut Self::Element, values: [StreamGroup<Self, TAIL>; M], )

Interleave M StreamGroups and store them as a contiguous array-of-structures - the exact inverse of load_deinterleaved_grouped, with the same lane-wise default and the same override expectations.

fn splat_m(src: Self, mask: Mask<R>, value: Self::Element) -> Self

Create a new vector from a single element by splatting it across all lanes. Merges splat with src using mask.

fn splat_z(mask: Mask<R>, value: Self::Element) -> Self

Create a new vector from a single element by splatting it across all lanes. Computes splat masked (zeroed where mask is false).

fn broadcast_c<const I: usize>(self, mask: Mask<R>) -> Self

Broadcast the value of a single lane across all lanes of the vector. Computes broadcast when mask is true, returns self where false.

fn broadcast_m<const I: usize>(self, src: Self, mask: Mask<R>) -> Self

Broadcast the value of a single lane across all lanes of the vector. Merges broadcast with src using mask.

fn broadcast_z<const I: usize>(self, mask: Mask<R>) -> Self

Broadcast the value of a single lane across all lanes of the vector. Computes broadcast masked (zeroed where mask is false).

fn broadcastv_c(self, mask: Mask<R>, idx: usize) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn broadcastv_m(self, src: Self, mask: Mask<R>, idx: usize) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn broadcastv_z(self, mask: Mask<R>, idx: usize) -> Self

Broadcast the value of a single lane across all lanes of the vector.

fn reverse_c(self, mask: Mask<R>) -> Self

Reverse the order of the elements in the vector.

fn reverse_m(self, src: Self, mask: Mask<R>) -> Self

Reverse the order of the elements in the vector.

fn reverse_z(self, mask: Mask<R>) -> Self

Reverse the order of the elements in the vector.

fn swap_bytes_c(self, mask: Mask<R>) -> Self

Swap the byte order of each element in the vector, converting between little-endian and big-endian representations lane-by-lane.

fn swap_bytes_m(self, src: Self, mask: Mask<R>) -> Self

Swap the byte order of each element in the vector, converting between little-endian and big-endian representations lane-by-lane.

fn swap_bytes_z(self, mask: Mask<R>) -> Self

Swap the byte order of each element in the vector, converting between little-endian and big-endian representations lane-by-lane.

unsafe fn load_m(src: Self, mask: Mask<R>, ptr: *const Self::Element) -> Self

Load a vector from an aligned pointer to its elements.

unsafe fn load_z(mask: Mask<R>, ptr: *const Self::Element) -> Self

Load a vector from an aligned pointer to its elements.

fn lanes() -> usize

Number of lanes in the vector, as a runtime value.

fn concat<INTO>(self, hi: Self) -> INTO

where INTO: ConcatVector<Self, Element = Self::Element>,

Combine two vectors of the same type into one wider vector, with self as the lower half and hi as the upper half.

fn split<INTO: GenericVector>(self) -> (INTO, INTO)

where Self: ConcatVector<INTO, Element = INTO::Element>,

Split this vector into two narrower vectors of the same type, with the lower lanes in the first vector and the upper lanes in the second vector.

fn extend<INTO>(self) -> INTO

where INTO: ExtendVector<Self, Element = Self::Element>,

Zero-extend a narrower vector into this wider vector type, placing the original values in the lower lanes and filling the upper lanes with zeros.

fn narrow<INTO: GenericVector>(self) -> INTO

where Self: ExtendVector<INTO, Element = INTO::Element>,

Narrow this wider vector into a narrower vector by taking the lower lanes.

fn align_slice( slice: &[Self::Element], ) -> (&[Self::Element], &[Self], &[Self::Element])

Align a slice of elements to the vector’s lane count, returning the aligned portion and any unaligned head or tail.

fn align_slice_mut( slice: &mut [Self::Element], ) -> (&mut [Self::Element], &mut [Self], &mut [Self::Element])

Align a mutable slice of elements to the vector’s lane count, returning the aligned portion and any unaligned head or tail.

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

Create a new vector from a slice of elements. The slice must have at least as many elements as the vector’s lanes.

fn copy_to_slice(self, slice: &mut [Self::Element])

Copy the elements of the vector into a slice. The slice must have at least as many elements as the vector’s lanes.

fn iter_unaligned<'a>( values: &'a [Self::Element], ) -> (Unaligned<'a, Self>, &'a [Self::Element])

Transform a slice of element values into an unaligned iterator of vectors, returning any remaining elements as a suffix slice.

fn iter_mut_unaligned<'a>( values: &'a mut [Self::Element], ) -> (UnalignedMut<'a, Self>, &'a mut [Self::Element])

Transform a mutable slice of element values into an unaligned iterator of vectors, returning any remaining elements as a suffix slice.

fn stream_aligned_slice<'a>( values: &'a [Self::Element], ) -> impl DoubleEndedIterator<Item = StreamingVector<'a, Self>>

Iterate over a slice of element values as Vectors using non-temporal (streaming) loads.

fn stream_aligned_slice_mut<'a>( values: &'a mut [Self::Element], ) -> impl DoubleEndedIterator<Item = StreamingVectorMut<'a, Self>>

Iterate over a mutable slice of element values as Vectors using non-temporal (streaming) loads and stores.

fn gather<I: VectorIndices<Self>>(slice: &[Self::Element], indices: I) -> Self

Gather elements from memory at the specified indices and return a new vector with those elements.

fn gather_or<I: VectorIndices<Self>>( slice: &[Self::Element], indices: I, or: Self, ) -> Self

where Self::Mask: CastMask<I::Mask>,

Gather elements from memory at the specified indices, or return or if the index is out of bounds.

fn gather_or_zero<I: VectorIndices<Self>>( slice: &[Self::Element], indices: I, ) -> Self

where Self::Mask: CastMask<I::Mask>,

Gather elements from memory at the specified indices, or set the lane to zero if the index is out of bounds.

fn gather_if<I: VectorIndices<Self>>( slice: &[Self::Element], enable: Self::Mask, indices: I, or: Self, ) -> Self

where Self::Mask: CastMask<I::Mask>, Self::Element: Default,

Gather elements from memory at the specified indices, or return or if the enable mask is false OR if any index is out of bounds.

fn scatter<I: VectorIndices<Self>>( self, slice: &mut [Self::Element], indices: I, )

where Self::Mask: CastMask<I::Mask>,

Scatter elements from the given vector into memory at the specified indices. If the index is outside of the bounds of the provided slice, the write is suppressed without panicking.

fn scatter_if<I: VectorIndices<Self>>( self, slice: &mut [Self::Element], enable: Self::Mask, indices: I, )

where Self::Mask: CastMask<I::Mask>,

Scatter elements from the given vector into memory at the specified indices, but only for lanes where the enable mask is true. If the index is outside of the bounds of the provided slice, the write is suppressed without panicking.

fn lookup(values: &[Self::Element], indices: Self::Unsigned) -> Self

Assemble a vector from a slice of elements and a vector of indices into that slice. If an index is outside the bounds of the given slice, the resulting lane will be the first element of the input slice.

fn first(self) -> Self::Element

Extract lane 0 – the scalar counterpart to single.

fn prefix_mask(n: usize) -> Self::Mask

Construct a mask whose first n lanes are true and the remaining lanes false.

fn suffix_mask(n: usize) -> Self::Mask

Construct a mask whose last n lanes are true and the remaining lanes false.

fn cast<INTO>(self) -> INTO

where INTO: CastVector<Self>,

Numeric cast to another vector type, matching the semantics of Rust’s as operator on the underlying scalar elements for in-range, finite inputs.

fn fast_cast<INTO>(self) -> INTO

where INTO: CastVector<Self>,

Fast numeric cast to another vector type.

fn into_bits<INTO>(self) -> INTO

where INTO: BitCastVector<Self>,

Reinterpret the bits of this vector as another vector type of the same size and lane count.

fn saturating_cast<INTO>(self) -> INTO

where INTO: CastVector<Self>,

Cast that saturates (clamps) out-of-range values to the destination element range, rather than wrapping (integers) or producing a backend-defined value (float-to-int) like cast.

impl<R: Register> HasIsa for Vector<R>

const ISA: InstructionSet = R::ISA

The instruction set this backend implements.

type Native = <R as CoreRegister>::NativeIsa

The backend this type executes on.

impl<R: Register> Index<usize> for Vector<R>

type Output = <R as Register>::Element

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<R: Register> IndexMut<usize> for Vector<R>

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

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

impl<R, I> IndexableVector<Vector<I>> for Vector<R>

where R: IndexableRegister<I>, I: UnsignedIntegerRegister<Lanes = R::Lanes>,

unsafe fn gather_ptr(ptr: *const Self::Element, indices: Vector<I>) -> Self

Gather one element per lane from ptr[indices[lane]].

unsafe fn gather_ptr_m( src: Self, mask: Self::Mask, ptr: *const Self::Element, indices: Vector<I>, ) -> Self

Like gather_ptr, but only lanes where mask is true are loaded; the rest are taken from src.

unsafe fn gather_ptr_z( mask: Self::Mask, ptr: *const Self::Element, indices: Vector<I>, ) -> Self

Like gather_ptr_m, but masked-off lanes are zeroed instead of taken from a source vector.

unsafe fn scatter_ptr(value: Self, ptr: *mut Self::Element, indices: Vector<I>)

Scatter each lane of value to ptr[indices[lane]].

unsafe fn scatter_ptr_m( value: Self, mask: Self::Mask, ptr: *mut Self::Element, indices: Vector<I>, )

Like scatter_ptr, but only lanes where mask is true are written.

impl<R: IntegerRegister> IntegerVector for Vector<R>

where R::Element: Denominator,

type Divider = Divider<<R as Register>::Element>

Precomputed scalar divider used by per-lane division against a runtime-known but loop-invariant divisor. See crate::Divider.

type BranchfreeDivider = BranchfreeDivider<<R as Register>::Element>

Branchfree variant of Divider. Slightly slower for some divisors but always emits straight-line code with no conditional branches, which is what you want inside a hot SIMD loop.

type VectorizedDivider = VectorDivider<R>

Precomputed per-lane divider produced by to_divider. Used when each lane needs a different (but loop-invariant) divisor.

fn mulhi(self, other: Self) -> Self

Multiply two vectors lane-wise and return the high half of each double-width product.

fn mullo(self, other: Self) -> Self

Multiply two vectors lane-wise and return the low half of each product, with wrapping on overflow.

fn saturating_add(self, other: Self) -> Self

Per-lane saturating addition: instead of wrapping, the result is clamped to the element type’s range (MIN..=MAX) on overflow.

fn saturating_sub(self, other: Self) -> Self

Per-lane saturating subtraction: instead of wrapping, the result is clamped to the element type’s range (MIN..=MAX) on overflow.

fn wrapping_sum(self) -> Self::Element

Horizontal sum of all lanes, wrapping on overflow.

fn wrapping_prod(self) -> Self::Element

Horizontal product of all lanes, wrapping on overflow.

fn create_divider(d: Self::Element) -> Self::Divider

Build a Divider for a single scalar divisor d, suitable for repeatedly dividing many vectors by the same d.

fn create_branchfree_divider(d: Self::Element) -> Self::BranchfreeDivider

Build a BranchfreeDivider for a single scalar divisor d. Prefer this over create_divider inside tight SIMD loops where conditional branches would hurt throughput.

fn to_divider(self) -> Self::VectorizedDivider

Use this vector as the denominators for a vectorized division operation.

fn count_ones(self) -> Self

For each element in the vector, count the number of bits that are set to 1.

fn count_zeros(self) -> Self

For each element in the vector, count the number of bits that are set to 0.

fn leading_ones(self) -> Self

For each element in the vector, count the number of leading ones.

fn leading_zeros(self) -> Self

For each element in the vector, count the number of leading zeros.

fn trailing_ones(self) -> Self

For each element in the vector, count the number of trailing ones.

fn trailing_zeros(self) -> Self

For each element in the vector, count the number of trailing zeros.

fn count_conflicts(self) -> Self

For each lane, how many earlier lanes hold the same value: out[i] == |{ j < i : self[j] == self[i] }|.

fn mulhi_c(self, mask: Mask<R>, other: Self) -> Self

Multiply two vectors lane-wise and return the high half of each double-width product.

fn mulhi_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Multiply two vectors lane-wise and return the high half of each double-width product.

fn mulhi_z(self, mask: Mask<R>, other: Self) -> Self

Multiply two vectors lane-wise and return the high half of each double-width product.

fn mullo_c(self, mask: Mask<R>, other: Self) -> Self

Multiply two vectors lane-wise and return the low half of each product, with wrapping on overflow.

fn mullo_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Multiply two vectors lane-wise and return the low half of each product, with wrapping on overflow.

fn mullo_z(self, mask: Mask<R>, other: Self) -> Self

Multiply two vectors lane-wise and return the low half of each product, with wrapping on overflow.

fn saturating_add_c(self, mask: Mask<R>, other: Self) -> Self

Per-lane saturating addition: instead of wrapping, the result is clamped to the element type’s range (MIN..=MAX) on overflow. Computes saturating_add when mask is true, returns self where false.

fn saturating_add_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Per-lane saturating addition: instead of wrapping, the result is clamped to the element type’s range (MIN..=MAX) on overflow. Merges saturating_add with src using mask.

fn saturating_add_z(self, mask: Mask<R>, other: Self) -> Self

Per-lane saturating addition: instead of wrapping, the result is clamped to the element type’s range (MIN..=MAX) on overflow. Computes saturating_add masked (zeroed where mask is false).

fn saturating_sub_c(self, mask: Mask<R>, other: Self) -> Self

Per-lane saturating subtraction: instead of wrapping, the result is clamped to the element type’s range (MIN..=MAX) on overflow. Computes saturating_sub when mask is true, returns self where false.

fn saturating_sub_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Per-lane saturating subtraction: instead of wrapping, the result is clamped to the element type’s range (MIN..=MAX) on overflow. Merges saturating_sub with src using mask.

fn saturating_sub_z(self, mask: Mask<R>, other: Self) -> Self

Per-lane saturating subtraction: instead of wrapping, the result is clamped to the element type’s range (MIN..=MAX) on overflow. Computes saturating_sub masked (zeroed where mask is false).

fn count_ones_c(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of bits that are set to 1. Computes count_ones when mask is true, returns self where false.

fn count_ones_m(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, count the number of bits that are set to 1. Merges count_ones with src using mask.

fn count_ones_z(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of bits that are set to 1. Computes count_ones masked (zeroed where mask is false).

fn count_zeros_c(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of bits that are set to 0. Computes count_zeros when mask is true, returns self where false.

fn count_zeros_m(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, count the number of bits that are set to 0. Merges count_zeros with src using mask.

fn count_zeros_z(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of bits that are set to 0. Computes count_zeros masked (zeroed where mask is false).

fn leading_ones_c(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of leading ones. Computes leading_ones when mask is true, returns self where false.

fn leading_ones_m(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, count the number of leading ones. Merges leading_ones with src using mask.

fn leading_ones_z(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of leading ones. Computes leading_ones masked (zeroed where mask is false).

fn leading_zeros_c(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of leading zeros. Computes leading_zeros when mask is true, returns self where false.

fn leading_zeros_m(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, count the number of leading zeros. Merges leading_zeros with src using mask.

fn leading_zeros_z(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of leading zeros. Computes leading_zeros masked (zeroed where mask is false).

fn trailing_ones_c(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of trailing ones. Computes trailing_ones when mask is true, returns self where false.

fn trailing_ones_m(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, count the number of trailing ones. Merges trailing_ones with src using mask.

fn trailing_ones_z(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of trailing ones. Computes trailing_ones masked (zeroed where mask is false).

fn trailing_zeros_c(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of trailing zeros. Computes trailing_zeros when mask is true, returns self where false.

fn trailing_zeros_m(self, src: Self, mask: Mask<R>) -> Self

For each element in the vector, count the number of trailing zeros. Merges trailing_zeros with src using mask.

fn trailing_zeros_z(self, mask: Mask<R>) -> Self

For each element in the vector, count the number of trailing zeros. Computes trailing_zeros masked (zeroed where mask is false).

impl<R: Register> Interleave for Vector<R>

fn interleave(self, other: Self) -> (Self, Self)

Unpack and interleave elements from two vectors.

fn deinterleave(self, other: Self) -> (Self, Self)

Pack and deinterleave elements from two vectors. This is the inverse operation of interleave.

impl<R: LinAlg3Register> LinAlg3Vector for Vector<R>

fn dot3(self, other: Self) -> Self::Element

Scalar Product using only the first three lanes of the register as a 3D vector.

fn cross3<const DOP: bool>(self, other: Self) -> Self

Cross Product using only the first three lanes of the register as a 3D vector.

fn refract(self, n: Self, eta: Self::Element) -> Self

Refraction of incident vector self through a surface with normal n and relative index of refraction eta ($\eta = \eta_i/\eta_t$). self and n are assumed unit length.

fn zero4(self) -> Self

Efficiently set the 4th (last) lane of the register to 0.0.

fn one4(self) -> Self

Efficiently set the 4th (last) lane of the register to 1.0.

fn min_element3(self) -> Self::Element

Returns the minimum value in the first three lanes of the register.

fn max_element3(self) -> Self::Element

Returns the maximum value in the first three lanes of the register.

fn sum_elements3(self) -> Self::Element

Returns the sum of the first three elements of the register.

fn prod_elements3(self) -> Self::Element

Returns the product of the first three elements of the register.

fn mat3_transpose(m: &[Self; 3]) -> [Self; 3]

3x3 Matrix Transpose.

fn mat3_vec3_product<const COLUMN_MAJOR: bool>(self, m: &[Self; 3]) -> Self

3x3 Matrix-Vector multiplication, assuming self as the vector.

fn mat3_vec3_product_array<const COLUMN_MAJOR: bool, const N: usize>( m: &[Self; 3], vectors: &[Self; N], ) -> [Self; N]

3x3 matrix times N 3D vectors (small-N batch; see mat4_vec4_product_array).

fn mat3_product<const COLUMN_MAJOR: bool>( lhs: &[Self; 3], rhs: &[Self; 3], ) -> [Self; 3]

3x3 Matrix-Matrix multiplication.

fn mat3_det(m: &[Self; 3]) -> Self::Element

Determinant of a column-major 3x3 matrix.

fn mat3_inverse_inplace(m: &mut [Self; 3]) -> Self::Element

In-place 3x3 Matrix inversion; returns the determinant.

fn mat3_normal<const DIVIDE: bool>(m: &[Self; 3]) -> [Self; 3]

“Normal matrix” for transforming normals under non-uniform scale, from the cofactor cross-products of a column-major 3x3.

fn mat3_inverse(m: &[Self; 3]) -> Option<[Self; 3]>

3x3 Matrix inversion.

impl<R: LinAlg4Register> LinAlg4Vector for Vector<R>

fn dot4(self, other: Self) -> Self::Element

Scalar Product using all four lanes of the register as a 4D vector.

fn quat4_product(self, other: Self) -> Self

Quaternion multiplication.

fn quat4_vec3_product<const DOP: bool>(self, vec: Self) -> Self

Quaternion-vector multiplication.

fn quat_to_mat3<const COLUMN_MAJOR: bool>(self) -> [Self; 3]

Rotation matrix of a unit quaternion as 3 registers; the 4th lane of each is unspecified.

fn quat_to_mat4<const COLUMN_MAJOR: bool>(self) -> [Self; 4]

Homogeneous 4x4 rotation matrix of a unit quaternion: the quat_to_mat3 rotation with each rotation register’s 4th lane zeroed and a [0, 0, 0, 1] 4th register. COLUMN_MAJOR is forwarded to quat_to_mat3.

fn mat4_transpose(m: &[Self; 4]) -> [Self; 4]

4x4 Matrix Transpose.

fn mat4_vec4_product<const COLUMN_MAJOR: bool>(self, m: &[Self; 4]) -> Self

4x4 Matrix-Vector multiplication, assuming self as the vector.

fn mat4_vec3_product<const COLUMN_MAJOR: bool>(self, m: &[Self; 4]) -> Self

4x4 Matrix-Vector3 multiplication, optimized for the case where the vector is a 3D coordinate (i.e., the 4th lane is ignored).

fn mat4_vec3_product_array<const COLUMN_MAJOR: bool, const N: usize>( m: &[Self; 4], vectors: &[Self; N], ) -> [Self; N]

4x4 matrix multiplied with N 3D vectors (small-N batch; see mat4_vec4_product_array).

fn mat4_point3_product<const COLUMN_MAJOR: bool>(self, m: &[Self; 4]) -> Self

4x4 Matrix-Point3 multiplication, optimized for the case where the input 3D value is a point of homogenous coordinates (i.e. 4th lane is 1.0).

fn mat4_point3_product_array<const COLUMN_MAJOR: bool, const N: usize>( m: &[Self; 4], vectors: &[Self; N], ) -> [Self; N]

4x4 Matrix multiplied with N 3D points (small-N batch).

fn mat4_product<const COLUMN_MAJOR: bool>( lhs: &[Self; 4], rhs: &[Self; 4], ) -> [Self; 4]

4x4 Matrix-Matrix multiplication.

fn mat4_vec4_product_array<const COLUMN_MAJOR: bool, const N: usize>( m: &[Self; 4], vectors: &[Self; N], ) -> [Self; N]

Transform N vectors by a single 4x4 matrix, returning the transformed array.

fn mat4_det(m: &[Self; 4]) -> Self::Element

Compute the determinant of a 4x4 matrix without inverting it.

fn mat4_inverse_inplace(m: &mut [Self; 4]) -> Self::Element

In-place 4x4 Matrix inversion; returns the determinant.

fn mat4_inverse(m: &[Self; 4]) -> Option<[Self; 4]>

4x4 Matrix inversion.

impl<R: NumericRegister + Register> Mul for Vector<R>

type Output = Vector<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: FloatRegister> MulAddAssignExt for Vector<R>

fn mul_add_assign(&mut self, a: Self, b: Self)

Guaranteed fused-multiply-add operation.

fn mul_sub_assign(&mut self, a: Self, b: Self)

Guaranteed fused-multiply-subtract operation.

fn nmul_add_assign(&mut self, a: Self, b: Self)

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub_assign(&mut self, a: Self, b: Self)

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde_assign(&mut self, a: Self, b: Self)

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube_assign(&mut self, a: Self, b: Self)

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde_assign(&mut self, a: Self, b: Self)

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube_assign(&mut self, a: Self, b: Self)

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<R: FloatRegister> MulAddAssignExtMasked<Mask<R>> for Vector<R>

fn mul_add_assign_c(&mut self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-multiply-add operation.

fn mul_add_assign_m(&mut self, src: Self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-multiply-add operation.

fn mul_add_assign_z(&mut self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-multiply-add operation.

fn mul_sub_assign_c(&mut self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-multiply-subtract operation.

fn mul_sub_assign_m(&mut self, src: Self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-multiply-subtract operation.

fn mul_sub_assign_z(&mut self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-multiply-subtract operation.

fn nmul_add_assign_c(&mut self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-negated-multiply-add operation.

fn nmul_add_assign_m(&mut self, src: Self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-negated-multiply-add operation.

fn nmul_add_assign_z(&mut self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub_assign_c(&mut self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-negated-multiply-subtract operation.

fn nmul_sub_assign_m(&mut self, src: Self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-negated-multiply-subtract operation.

fn nmul_sub_assign_z(&mut self, mask: Mask<R>, a: Self, b: Self)

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde_assign_c(&mut self, mask: Mask<R>, a: Self, b: Self)

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_adde_assign_m(&mut self, src: Self, mask: Mask<R>, a: Self, b: Self)

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_adde_assign_z(&mut self, mask: Mask<R>, a: Self, b: Self)

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube_assign_c(&mut self, mask: Mask<R>, a: Self, b: Self)

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn mul_sube_assign_m(&mut self, src: Self, mask: Mask<R>, a: Self, b: Self)

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn mul_sube_assign_z(&mut self, mask: Mask<R>, a: Self, b: Self)

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde_assign_c(&mut self, mask: Mask<R>, a: Self, b: Self)

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_adde_assign_m(&mut self, src: Self, mask: Mask<R>, a: Self, b: Self)

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_adde_assign_z(&mut self, mask: Mask<R>, a: Self, b: Self)

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube_assign_c(&mut self, mask: Mask<R>, a: Self, b: Self)

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_sube_assign_m(&mut self, src: Self, mask: Mask<R>, a: Self, b: Self)

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_sube_assign_z(&mut self, mask: Mask<R>, a: Self, b: Self)

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<R: FloatRegister> MulAddExt for Vector<R>

const HAS_TRUE_FMA: bool = R::HAS_TRUE_FMA

Indicates whether the implementation uses true fused-multiply-add instructions.

type Output = Vector<R>

The result of the fused operation.

fn mul_add(self, a: Self, b: Self) -> Self::Output

Guaranteed fused-multiply-add operation.

fn mul_sub(self, a: Self, b: Self) -> Self::Output

Guaranteed fused-multiply-subtract operation.

fn nmul_add(self, a: Self, b: Self) -> Self::Output

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub(self, a: Self, b: Self) -> Self::Output

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde(self, a: Self, b: Self) -> Self::Output

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube(self, a: Self, b: Self) -> Self::Output

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde(self, a: Self, b: Self) -> Self::Output

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube(self, a: Self, b: Self) -> Self::Output

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<R: FloatRegister> MulAddExtMasked<Mask<R>> for Vector<R>

fn mul_add_c(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-multiply-add operation.

fn mul_add_m(self, src: Self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-multiply-add operation.

fn mul_add_z(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-multiply-add operation.

fn mul_sub_c(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-multiply-subtract operation.

fn mul_sub_m(self, src: Self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-multiply-subtract operation.

fn mul_sub_z(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-multiply-subtract operation.

fn nmul_add_c(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-negated-multiply-add operation.

fn nmul_add_m(self, src: Self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-negated-multiply-add operation.

fn nmul_add_z(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-negated-multiply-add operation.

fn nmul_sub_c(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-negated-multiply-subtract operation.

fn nmul_sub_m(self, src: Self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-negated-multiply-subtract operation.

fn nmul_sub_z(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Guaranteed fused-negated-multiply-subtract operation.

fn mul_adde_c(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_adde_m(self, src: Self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_adde_z(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn mul_sube_c(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn mul_sube_m(self, src: Self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn mul_sube_z(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_adde_c(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_adde_m(self, src: Self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_adde_z(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-negated-multiply-add operation where possible. May gracefully degrade to separate multiply and add if the target architecture does not support native FMA.

fn nmul_sube_c(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_sube_m(self, src: Self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

fn nmul_sube_z(self, mask: Mask<R>, a: Self, b: Self) -> Self::Output

Fused-negated-multiply-subtract operation where possible. May gracefully degrade to separate multiply and subtract if the target architecture does not support native FMA.

impl<R: NumericRegister + Register> MulAssign for Vector<R>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<R: NumericRegister + Register> MulAssignMasked<Mask<R>> for Vector<R>

fn mul_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes MulAssign with rhs where mask is true.

fn mul_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges MulAssign with src using mask, assigning src where mask is false.

fn mul_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes MulAssign masked (zeroed where mask is false).

impl<R: NumericRegister + Register> MulMasked<Mask<R>> for Vector<R>

fn mul_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Mul with rhs where mask is true.

fn mul_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges Mul with src using mask, returning src where mask is false.

fn mul_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Mul masked (zeroed where mask is false).

impl<R: SignedRegister> Neg for Vector<R>

type Output = Vector<R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R: SignedRegister> NegMasked<Mask<R>> for Vector<R>

fn neg_c(self, mask: Mask<R>) -> Self::Output

Computes Neg where mask is true, does nothing where false.

fn neg_m(self, src: Self, mask: Mask<R>) -> Self::Output

Merges Neg with src using mask, returning src where mask is false.

fn neg_z(self, mask: Mask<R>) -> Self::Output

Computes Neg masked (zeroed where mask is false).

impl<R: Register> NewVector<<R as Register>::Element, <R as CoreRegister>::Lanes> for Vector<R>

type New<T: NewConst<R::Element, R::Lanes>> = NewVectorImpl

For a given array carrier T, the type exposing the constructed vector constant via VectorValue.

impl<R: BitwiseRegister + Register> Not for Vector<R>

type Output = Vector<R>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<R: BitwiseRegister + Register> NotMasked<Mask<R>> for Vector<R>

fn not_c(self, mask: Mask<R>) -> Self::Output

Computes Not where mask is true, does nothing where false.

fn not_m(self, src: Self, mask: Mask<R>) -> Self::Output

Merges Not with src using mask, returning src where mask is false.

fn not_z(self, mask: Mask<R>) -> Self::Output

Computes Not masked (zeroed where mask is false).

impl<R: NumericRegister> NumericVector for Vector<R>

const ZERO: Self

A vector of the value “0” in the element type.

const ONE: Self

A vector of the value “1” in the element type.

const TWO: Self

A vector of the value “2” in the element type.

const MIN: Self

A vector of the minimum value the element type of this vector can represent.

const MAX: Self

A vector of the maximum value the element type of this vector can represent.

fn to_signed_integer(self) -> Self::Signed

Convert each lane to the companion signed integer type, with as semantics - round toward zero, saturating at the bounds, NaN to zero.

fn from_signed_integer(v: Self::Signed) -> Self

Convert each lane from the companion signed integer type, with as semantics.

fn to_unsigned_integer(self) -> Self::Unsigned

Convert each lane to the companion unsigned integer type, with as semantics. See to_signed_integer.

fn from_unsigned_integer(v: Self::Unsigned) -> Self

Convert each lane from the companion unsigned integer type, with as semantics. See from_signed_integer.

fn fast_to_signed_integer(self) -> Self::Signed

Like to_signed_integer, but may relax IEEE corner cases (out-of-range and NaN inputs) for speed. Defaults to the exact form.

fn fast_to_unsigned_integer(self) -> Self::Unsigned

Like to_unsigned_integer, but may relax IEEE corner cases. Defaults to the exact form.

fn is_zero(self) -> Self::Mask

For each element in the vector, return a mask indicating whether that element is zero.

fn is_all_zero(self) -> bool

Returns true if all elements in the vector are zero, false otherwise.

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

Return the minimum of two vectors, element-wise.

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

Return the maximum of two vectors, element-wise.

fn sort_by<O: SortOrder>(self) -> Self

Sort the lanes of this vector in O order.

fn bitonic_clean_by<O: SortOrder>(self) -> Self

Sort the lanes of a bitonic vector in O order - one that rises then falls, or a rotation of one.

fn prefix_sum(self) -> Self

Inclusive forward prefix sum (“running total”): out[i] = self[0] + .. + self[i].

fn prefix_min(self) -> Self

Inclusive forward prefix minimum: out[i] = min(self[0], .., self[i]).

fn prefix_max(self) -> Self

Inclusive forward prefix maximum: out[i] = max(self[0], .., self[i]).

fn reverse_prefix_sum(self) -> Self

Inclusive reverse (suffix) sum: out[i] = self[i] + .. + self[LANES-1].

fn reverse_prefix_min(self) -> Self

Inclusive reverse (suffix) minimum: out[i] = min(self[i], .., self[LANES-1]).

fn reverse_prefix_max(self) -> Self

Inclusive reverse (suffix) maximum: out[i] = max(self[i], .., self[LANES-1]).

fn clamp(self, min: Self, max: Self) -> Self

Clamps the elements of the vector between the given minimum and maximum values.

fn min_element(self) -> Self::Element

Returns the minimum value in the vector.

fn max_element(self) -> Self::Element

Returns the maximum value in the vector.

fn min_max_element(self) -> (Self::Element, Self::Element)

Returns both the minimum and maximum values in the vector simultaneously.

fn arg_minmax(self) -> (usize, usize)

Returns the indices of the minimum and maximum elements in the vector, respectively.

fn scale(self, factor: Self::Element) -> Self

Scales each element in the vector by the given factor.

fn pairwise_sum(lo: Self, hi: Self) -> Self

Sums adjacent lane pairs from lo and hi, returning a vector of the same width.

fn relaxed_pairwise_sum(lo: Self, hi: Self) -> Self

Like pairwise_sum, but may return a relaxed (implementation-defined) lane ordering for performance. Treat this as if randomly shuffling the result of pairwise_sum, with better performance than pairwise_sum.

fn sum_elements(self) -> Self::Element

Returns the sum of all elements in the vector.

fn prod_elements(self) -> Self::Element

Returns the product of all elements in the vector.

fn offset() -> Self

Returns a vector whose every lane equals LANES, converted into the element type.

fn indexed() -> Self

Returns a vector where each lane holds its own index, cast to the element type: [0, 1, 2, ..., LANES-1].

fn min_c(self, mask: Mask<R>, other: Self) -> Self

Return the minimum of two vectors, element-wise. Computes min when mask is true, returns self where false.

fn min_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Return the minimum of two vectors, element-wise. Merges min with src using mask.

fn min_z(self, mask: Mask<R>, other: Self) -> Self

Return the minimum of two vectors, element-wise. Computes min masked (zeroed where mask is false).

fn max_c(self, mask: Mask<R>, other: Self) -> Self

Return the maximum of two vectors, element-wise. Computes max when mask is true, returns self where false.

fn max_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Return the maximum of two vectors, element-wise. Merges max with src using mask.

fn max_z(self, mask: Mask<R>, other: Self) -> Self

Return the maximum of two vectors, element-wise. Computes max masked (zeroed where mask is false).

fn scale_c(self, mask: Mask<R>, factor: Self::Element) -> Self

Scales each element in the vector by the given factor.

fn scale_m(self, src: Self, mask: Mask<R>, factor: Self::Element) -> Self

Scales each element in the vector by the given factor.

fn scale_z(self, mask: Mask<R>, factor: Self::Element) -> Self

Scales each element in the vector by the given factor.

fn sort(self) -> Self

Sort the lanes ascending. Shorthand for sort_by::<Ascending>.

fn bitonic_clean(self) -> Self

Sort the lanes of a bitonic vector ascending. Shorthand for bitonic_clean_by::<Ascending>.

impl<R: NumericRegister> One for Vector<R>

fn is_one(&self) -> bool

Returns true if all elements in the vector are one.

fn set_one(&mut self)

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

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

impl<S, R, FR, B> PackedFloatVector<S, Vector<FR>> for Vector<R>

where S: FloatSpec, B: CastRegister<R>, FR: FloatRegister<Element = f32, Lanes = R::Lanes, Bits = B>, R: PackedFloatRegister<S, FR> + CastRegister<B>,

fn pack(values: Vector<FR>) -> Self

Encode the f32 vector values into this packed format (round to nearest, ties to even; overflow / non-finite handled per the format S).

fn unpack(self) -> Vector<FR>

Decode this packed-float vector into the f32 vector it represents (exact).

impl<R: PartialOrdRegister> PartialEq for Vector<R>

fn eq(&self, other: &Self) -> bool

Compare two vectors for equality, returning true only if all elements are equal.

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

Compare two vectors for inequality, returning true if any element is not equal.

impl<R: PartialOrdRegister> PartialOrdVector for Vector<R>

fn cmp_lt(self, other: Self) -> Self::Mask

Lane-wise self < other.

fn cmp_le(self, other: Self) -> Self::Mask

Lane-wise self <= other.

fn cmp_gt(self, other: Self) -> Self::Mask

Lane-wise self > other.

fn cmp_ge(self, other: Self) -> Self::Mask

Lane-wise self >= other.

fn cmp_eq(self, other: Self) -> Self::Mask

Lane-wise self == other.

fn cmp_ne(self, other: Self) -> Self::Mask

Lane-wise self != other.

fn group_by_value(self, valid: Self::Mask) -> ValueGroups<Self>

Partition the lanes selected by valid into groups of equal value.

impl<R: NumericRegister> Product for Vector<R>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<R: NumericRegister + Register> Rem for Vector<R>

type Output = Vector<R>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<R: NumericRegister + Register> RemAssign for Vector<R>

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<R: NumericRegister + Register> RemAssignMasked<Mask<R>> for Vector<R>

fn rem_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes RemAssign with rhs where mask is true.

fn rem_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges RemAssign with src using mask, assigning src where mask is false.

fn rem_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes RemAssign masked (zeroed where mask is false).

impl<R: NumericRegister + Register> RemMasked<Mask<R>> for Vector<R>

fn rem_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Rem with rhs where mask is true.

fn rem_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges Rem with src using mask, returning src where mask is false.

fn rem_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Rem masked (zeroed where mask is false).

impl<R, W> Sad16Vector<Vector<W>> for Vector<R>

where W: UnsignedIntegerRegister<Element = u16>, R: Sad16Register<W>,

fn sad16(self, other: Self) -> Vector<W>

Sum of absolute differences over each aligned pair of byte lanes.

impl<R, W> Sad32Vector<Vector<W>> for Vector<R>

where W: UnsignedIntegerRegister<Element = u32>, R: Sad32Register<W>,

fn sad32(self, other: Self) -> Vector<W>

Sum of absolute differences over each aligned group of 4 byte lanes.

fn sad32_accum(self, acc: Vector<W>, other: Self) -> Vector<W>

acc + self.sad32(other) - the accumulate step of a blocked SAD loop.

impl<R, W> Sad64Vector<Vector<W>> for Vector<R>

where W: UnsignedIntegerRegister<Element = u64>, R: Sad64Register<W>,

fn sad64(self, other: Self) -> Vector<W>

Sum of absolute differences over each aligned group of 8 byte lanes.

fn sad64_accum(self, acc: Vector<W>, other: Self) -> Vector<W>

acc + self.sad64(other) - the accumulate step of a blocked SAD loop.

impl<R: IntegerRegister> Saturating for Vector<R>

fn saturating_add(self, v: Self) -> Self

Saturating addition operator. Returns a+b, saturating at the numeric bounds instead of overflowing.

fn saturating_sub(self, v: Self) -> Self

Saturating subtraction operator. Returns a-b, saturating at the numeric bounds instead of overflowing.

impl<R: IntegerRegister> SaturatingAdd for Vector<R>

fn saturating_add(&self, v: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<R: IntegerRegister> SaturatingSub for Vector<R>

fn saturating_sub(&self, v: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<R: Register> Selectable<R> for Vector<R>

fn select<M: Register>(mask: Mask<M>, truthy: Self, falsy: Self) -> Self

where R::Mask: CastMaskRegister<M::Mask, Lanes = M::Lanes>,

For each lane in mask, if the lane is true, the corresponding lane in truthy is selected, otherwise the corresponding lane in falsy is selected.

impl<R: BitshiftRegister> Shl<Vector<<R as Register>::Unsigned>> for Vector<R>

type Output = Vector<R>

The resulting type after applying the << operator.

fn shl(self, rhs: Vector<R::Unsigned>) -> Self::Output

Performs the << operation.

impl<R: BitshiftRegister> Shl<u32> for Vector<R>

type Output = Vector<R>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl<R: BitshiftRegister> ShlAssign<Vector<<R as Register>::Unsigned>> for Vector<R>

fn shl_assign(&mut self, rhs: Vector<R::Unsigned>)

Performs the <<= operation.

impl<R: BitshiftRegister> ShlAssign<u32> for Vector<R>

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<R: BitshiftRegister> ShlAssignMasked<Mask<R>, Vector<<R as Register>::Unsigned>> for Vector<R>

fn shl_assign_c(&mut self, mask: Mask<R>, rhs: Vector<R::Unsigned>)

Computes ShlAssign with rhs where mask is true.

fn shl_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Vector<R::Unsigned>)

Merges ShlAssign with src using mask, assigning src where mask is false.

fn shl_assign_z(&mut self, mask: Mask<R>, rhs: Vector<R::Unsigned>)

Computes ShlAssign masked (zeroed where mask is false).

impl<R: BitshiftRegister> ShlAssignMasked<Mask<R>, u32> for Vector<R>

fn shl_assign_c(&mut self, mask: Mask<R>, rhs: u32)

Computes ShlAssign with rhs where mask is true.

fn shl_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: u32)

Merges ShlAssign with src using mask, assigning src where mask is false.

fn shl_assign_z(&mut self, mask: Mask<R>, rhs: u32)

Computes ShlAssign masked (zeroed where mask is false).

impl<R: BitshiftRegister> ShlMasked<Mask<R>, Vector<<R as Register>::Unsigned>> for Vector<R>

fn shl_c(self, mask: Mask<R>, rhs: Vector<R::Unsigned>) -> Self::Output

Computes Shl with rhs where mask is true.

fn shl_m( self, src: Self, mask: Mask<R>, rhs: Vector<R::Unsigned>, ) -> Self::Output

Merges Shl with src using mask, returning src where mask is false.

fn shl_z(self, mask: Mask<R>, rhs: Vector<R::Unsigned>) -> Self::Output

Computes Shl masked (zeroed where mask is false).

impl<R: BitshiftRegister> ShlMasked<Mask<R>, u32> for Vector<R>

fn shl_c(self, mask: Mask<R>, rhs: u32) -> Self::Output

Computes Shl with rhs where mask is true.

fn shl_m(self, src: Self, mask: Mask<R>, rhs: u32) -> Self::Output

Merges Shl with src using mask, returning src where mask is false.

fn shl_z(self, mask: Mask<R>, rhs: u32) -> Self::Output

Computes Shl masked (zeroed where mask is false).

impl<R: BitshiftRegister> Shr<Vector<<R as Register>::Unsigned>> for Vector<R>

type Output = Vector<R>

The resulting type after applying the >> operator.

fn shr(self, rhs: Vector<R::Unsigned>) -> Self::Output

Performs the >> operation.

impl<R: BitshiftRegister> Shr<u32> for Vector<R>

type Output = Vector<R>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl<R: BitshiftRegister> ShrAssign<Vector<<R as Register>::Unsigned>> for Vector<R>

fn shr_assign(&mut self, rhs: Vector<R::Unsigned>)

Performs the >>= operation.

impl<R: BitshiftRegister> ShrAssign<u32> for Vector<R>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<R: BitshiftRegister> ShrAssignMasked<Mask<R>, Vector<<R as Register>::Unsigned>> for Vector<R>

fn shr_assign_c(&mut self, mask: Mask<R>, rhs: Vector<R::Unsigned>)

Computes ShrAssign with rhs where mask is true.

fn shr_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Vector<R::Unsigned>)

Merges ShrAssign with src using mask, assigning src where mask is false.

fn shr_assign_z(&mut self, mask: Mask<R>, rhs: Vector<R::Unsigned>)

Computes ShrAssign masked (zeroed where mask is false).

impl<R: BitshiftRegister> ShrAssignMasked<Mask<R>, u32> for Vector<R>

fn shr_assign_c(&mut self, mask: Mask<R>, rhs: u32)

Computes ShrAssign with rhs where mask is true.

fn shr_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: u32)

Merges ShrAssign with src using mask, assigning src where mask is false.

fn shr_assign_z(&mut self, mask: Mask<R>, rhs: u32)

Computes ShrAssign masked (zeroed where mask is false).

impl<R: BitshiftRegister> ShrMasked<Mask<R>, Vector<<R as Register>::Unsigned>> for Vector<R>

fn shr_c(self, mask: Mask<R>, rhs: Vector<R::Unsigned>) -> Self::Output

Computes Shr with rhs where mask is true.

fn shr_m( self, src: Self, mask: Mask<R>, rhs: Vector<R::Unsigned>, ) -> Self::Output

Merges Shr with src using mask, returning src where mask is false.

fn shr_z(self, mask: Mask<R>, rhs: Vector<R::Unsigned>) -> Self::Output

Computes Shr masked (zeroed where mask is false).

impl<R: BitshiftRegister> ShrMasked<Mask<R>, u32> for Vector<R>

fn shr_c(self, mask: Mask<R>, rhs: u32) -> Self::Output

Computes Shr with rhs where mask is true.

fn shr_m(self, src: Self, mask: Mask<R>, rhs: u32) -> Self::Output

Merges Shr with src using mask, returning src where mask is false.

fn shr_z(self, mask: Mask<R>, rhs: u32) -> Self::Output

Computes Shr masked (zeroed where mask is false).

impl<R: SignedIntegerRegister> SignedIntegerVector for Vector<R>

where R::Element: Denominator,

fn srai<const I: i32>(self) -> Self

For each lane in the vector, right shift in sign bits by the immediate value.

fn sra(self, count: u32) -> Self

For each lane in the vector, right shift in sign bits by the given value.

fn srav(self, counts: Self::Unsigned) -> Self

For each lane in the vector, right shift in sign bits by the corresponding lane in the shifts vector.

fn avg_floor(self, other: Self) -> Self

Floor average: (a + b) >> 1 rounded toward -∞, computed without overflow.

fn avg_ceil(self, other: Self) -> Self

Ceiling average: (a + b + 1) >> 1 rounded toward +∞, computed without overflow.

fn mulhrs(self, other: Self) -> Self

Rounded high-half signed multiply: the fixed-point Q(W-1) product (self * other + 2^(W-2)) >> (W-1), where W is the element bit width.

fn srai_c<const I: i32>(self, mask: Mask<R>) -> Self

For each lane in the vector, right shift in sign bits by the immediate value. Computes srai when mask is true, returns self where false.

fn srai_m<const I: i32>(self, src: Self, mask: Mask<R>) -> Self

For each lane in the vector, right shift in sign bits by the immediate value. Merges srai with src using mask.

fn srai_z<const I: i32>(self, mask: Mask<R>) -> Self

For each lane in the vector, right shift in sign bits by the immediate value. Computes srai masked (zeroed where mask is false).

fn sra_c(self, mask: Mask<R>, count: u32) -> Self

For each lane in the vector, right shift in sign bits by the given value. Computes sra when mask is true, returns self where false.

fn sra_m(self, src: Self, mask: Mask<R>, count: u32) -> Self

For each lane in the vector, right shift in sign bits by the given value. Merges sra with src using mask.

fn sra_z(self, mask: Mask<R>, count: u32) -> Self

For each lane in the vector, right shift in sign bits by the given value. Computes sra masked (zeroed where mask is false).

fn srav_c(self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each lane in the vector, right shift in sign bits by the corresponding lane in the shifts vector. Computes srav when mask is true, returns self where false.

fn srav_m(self, src: Self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each lane in the vector, right shift in sign bits by the corresponding lane in the shifts vector. Merges srav with src using mask.

fn srav_z(self, mask: Mask<R>, counts: Self::Unsigned) -> Self

For each lane in the vector, right shift in sign bits by the corresponding lane in the shifts vector. Computes srav masked (zeroed where mask is false).

fn avg_floor_c(self, mask: Mask<R>, other: Self) -> Self

Floor average: (a + b) >> 1 rounded toward -∞, computed without overflow. Computes avg_floor when mask is true, returns self where false.

fn avg_floor_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Floor average: (a + b) >> 1 rounded toward -∞, computed without overflow. Merges avg_floor with src using mask.

fn avg_floor_z(self, mask: Mask<R>, other: Self) -> Self

Floor average: (a + b) >> 1 rounded toward -∞, computed without overflow. Computes avg_floor masked (zeroed where mask is false).

fn avg_ceil_c(self, mask: Mask<R>, other: Self) -> Self

Ceiling average: (a + b + 1) >> 1 rounded toward +∞, computed without overflow. Computes avg_ceil when mask is true, returns self where false.

fn avg_ceil_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Ceiling average: (a + b + 1) >> 1 rounded toward +∞, computed without overflow. Merges avg_ceil with src using mask.

fn avg_ceil_z(self, mask: Mask<R>, other: Self) -> Self

Ceiling average: (a + b + 1) >> 1 rounded toward +∞, computed without overflow. Computes avg_ceil masked (zeroed where mask is false).

fn mulhrs_c(self, mask: Mask<R>, other: Self) -> Self

Rounded high-half signed multiply: the fixed-point Q(W-1) product (self * other + 2^(W-2)) >> (W-1), where W is the element bit width.

fn mulhrs_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Rounded high-half signed multiply: the fixed-point Q(W-1) product (self * other + 2^(W-2)) >> (W-1), where W is the element bit width.

fn mulhrs_z(self, mask: Mask<R>, other: Self) -> Self

Rounded high-half signed multiply: the fixed-point Q(W-1) product (self * other + 2^(W-2)) >> (W-1), where W is the element bit width.

impl<R> SignedIntegerVectorWithRegister for Vector<R>

where R: SignedIntegerRegister,

type Register = R

The backing hardware register this vector is a thin wrapper over.

impl<R: SignedRegister> SignedVector for Vector<R>

const NEG_ONE: Self

A vector of the value “-1” in the element type.

const MIN_POSITIVE: Self

A vector of the smallest positive (non-zero) value in the element type.

fn abs(self) -> Self

Take the absolute value of the vector, element-wise.

fn signum(self) -> Self

For each element in the vector, return a new vector where each element is either -1 or +1 depending on the sign of the element.

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

For each element in the vector, set the sign of that element to the sign of the corresponding element in the other vector.

fn is_positive(self) -> Self::Mask

For each element in the vector, return a mask indicating whether that element is negative.

fn is_negative(self) -> Self::Mask

For each element in the vector, return a mask indicating whether that element is positive.

fn select_negative(self, if_neg: Self, if_pos: Self) -> Self

Based on if self is negative, select between if_neg and if_pos.

fn abs_c(self, mask: Mask<R>) -> Self

Take the absolute value of the vector, element-wise. Computes abs when mask is true, returns self where false.

fn abs_m(self, src: Self, mask: Mask<R>) -> Self

Take the absolute value of the vector, element-wise. Merges abs with src using mask.

fn abs_z(self, mask: Mask<R>) -> Self

Take the absolute value of the vector, element-wise. Computes abs masked (zeroed where mask is false).

fn copysign_c(self, mask: Mask<R>, sign: Self) -> Self

For each element in the vector, set the sign of that element to the sign of the corresponding element in the other vector. Computes copysign when mask is true, returns self where false.

fn copysign_m(self, src: Self, mask: Mask<R>, sign: Self) -> Self

For each element in the vector, set the sign of that element to the sign of the corresponding element in the other vector. Merges copysign with src using mask.

fn copysign_z(self, mask: Mask<R>, sign: Self) -> Self

For each element in the vector, set the sign of that element to the sign of the corresponding element in the other vector. Computes copysign masked (zeroed where mask is false).

impl<R: Register> SplatVector<<R as Register>::Element> for Vector<R>

type Splat<T: SplatConst<R::Element>> = SplatVectorImpl

For a given constant carrier T, the type exposing the splatted vector constant via VectorValue.

impl<R: NumericRegister> Square for Vector<R>

type Output = Vector<R>

The squared value. Not always Self: a type may widen to hold the product.

fn square(self) -> Self

Computes self * self.

impl<R: NumericRegister> SquareMasked<Mask<R>> for Vector<R>

fn square_c(self, mask: Mask<R>) -> Self

Computes Square where mask is true, does nothing where false.

fn square_m(self, src: Self, mask: Mask<R>) -> Self

Merges Square with src using mask, returning src where mask is false.

fn square_z(self, mask: Mask<R>) -> Self

Computes Square masked (zeroed where mask is false).

impl<R: NumericRegister + Register> Sub for Vector<R>

type Output = Vector<R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: NumericRegister + Register> SubAssign for Vector<R>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<R: NumericRegister + Register> SubAssignMasked<Mask<R>> for Vector<R>

fn sub_assign_c(&mut self, mask: Mask<R>, rhs: Self)

Computes SubAssign with rhs where mask is true.

fn sub_assign_m(&mut self, src: Self, mask: Mask<R>, rhs: Self)

Merges SubAssign with src using mask, assigning src where mask is false.

fn sub_assign_z(&mut self, mask: Mask<R>, rhs: Self)

Computes SubAssign masked (zeroed where mask is false).

impl<R: NumericRegister + Register> SubMasked<Mask<R>> for Vector<R>

fn sub_c(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Sub with rhs where mask is true.

fn sub_m(self, src: Self, mask: Mask<R>, rhs: Self) -> Self::Output

Merges Sub with src using mask, returning src where mask is false.

fn sub_z(self, mask: Mask<R>, rhs: Self) -> Self::Output

Computes Sub masked (zeroed where mask is false).

impl<R: NumericRegister> Sum for Vector<R>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<R> Swizzle<<R as CoreRegister>::Lanes> for Vector<R>

where R: Register,

fn swizzle(self, other: Self, indices: GenericArray<u32, R::Lanes>) -> Self

Swizzle lanes from two vectors according to the given indices.

fn swizzle_const<I: SwizzleIndices<R::Lanes>>(self, other: Self) -> Self

fn permute(self, indices: GenericArray<u32, R::Lanes>) -> Self

Permute lanes from a single vector according to the given indices.

fn permute_const<I: SwizzleIndices<R::Lanes>>(self) -> Self

impl<R: UnsignedIntegerRegister> UnsignedIntegerVector for Vector<R>

where R::Element: Denominator,

fn is_power_of_two(self) -> Self::Mask

Determines if each unsigned integer element in the vector is a power of two, returning a mask indicating whether or not it is.

fn in_range(self, lo: Self, hi: Self) -> Self::Mask

Per-lane inclusive unsigned range test: a mask of lo <= self <= hi, assuming lo <= hi.

fn next_power_of_two_m1(self) -> Self

Returns the next power of two minus one for each unsigned integer element in the vector.

fn ilog2p1(self) -> Self

Computes log2(x) + 1 for each unsigned integer element in the vector.

fn parity(self) -> Self

Compute the parity of each unsigned integer lane in the vector.

fn avg(self, other: Self) -> Self

Ceiling average: (a + b + 1) >> 1, computed without overflow.

fn abs_diff(self, other: Self) -> Self

Per-lane unsigned absolute difference |self - other|, without overflow.

fn morton<const N: usize>(values: [Self; N]) -> Self

Per-lane N-dimensional Morton code (Z-order curve index): interleave the low floor(W / N) bits of each of the N coordinate vectors into one, placing bit i of values[d] at output position i * N + d. N = 2 is the classic 2D code, N = 3 the 3D (voxel/octree) code.

fn reverse_morton<const N: usize>(self) -> [Self; N]

Inverse of morton: de-interleave a Morton code back into its N coordinate vectors, where out[d] gathers output bits d, d + N, d + 2N, ... into the low floor(W / N) bits.

fn next_power_of_two_m1_c(self, mask: Mask<R>) -> Self

Returns the next power of two minus one for each unsigned integer element in the vector. Computes next_power_of_two_m1 when mask is true, returns self where false.

fn next_power_of_two_m1_m(self, src: Self, mask: Mask<R>) -> Self

Returns the next power of two minus one for each unsigned integer element in the vector. Merges next_power_of_two_m1 with src using mask.

fn next_power_of_two_m1_z(self, mask: Mask<R>) -> Self

Returns the next power of two minus one for each unsigned integer element in the vector. Computes next_power_of_two_m1 masked (zeroed where mask is false).

fn ilog2p1_c(self, mask: Mask<R>) -> Self

Computes log2(x) + 1 for each unsigned integer element in the vector. Computes ilog2p1 when mask is true, returns self where false.

fn ilog2p1_m(self, src: Self, mask: Mask<R>) -> Self

Computes log2(x) + 1 for each unsigned integer element in the vector. Merges ilog2p1 with src using mask.

fn ilog2p1_z(self, mask: Mask<R>) -> Self

Computes log2(x) + 1 for each unsigned integer element in the vector. Computes ilog2p1 masked (zeroed where mask is false).

fn parity_c(self, mask: Mask<R>) -> Self

Compute the parity of each unsigned integer lane in the vector. Computes parity when mask is true, returns self where false.

fn parity_m(self, src: Self, mask: Mask<R>) -> Self

Compute the parity of each unsigned integer lane in the vector. Merges parity with src using mask.

fn parity_z(self, mask: Mask<R>) -> Self

Compute the parity of each unsigned integer lane in the vector. Computes parity masked (zeroed where mask is false).

fn avg_c(self, mask: Mask<R>, other: Self) -> Self

Ceiling average: (a + b + 1) >> 1, computed without overflow.

fn avg_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Ceiling average: (a + b + 1) >> 1, computed without overflow.

fn avg_z(self, mask: Mask<R>, other: Self) -> Self

Ceiling average: (a + b + 1) >> 1, computed without overflow.

fn abs_diff_c(self, mask: Mask<R>, other: Self) -> Self

Per-lane unsigned absolute difference |self - other|, without overflow.

fn abs_diff_m(self, src: Self, mask: Mask<R>, other: Self) -> Self

Per-lane unsigned absolute difference |self - other|, without overflow.

fn abs_diff_z(self, mask: Mask<R>, other: Self) -> Self

Per-lane unsigned absolute difference |self - other|, without overflow.

impl<R> UnsignedIntegerVectorWithRegister for Vector<R>

where R: UnsignedIntegerRegister,

type Register = R

The backing hardware register this vector is a thin wrapper over.

impl<R: Register> VectorWithRegister<R> for Vector<R>

fn into_register(self) -> Storage<R>

Consume the vector and yield its raw register storage.

fn from_register(reg: Storage<R>) -> Self

Wrap a raw register storage value back into a Vector.

fn as_slice(&self) -> &[R::Element]

Borrow the vector’s elements as a slice.

fn as_mut_slice(&mut self) -> &mut [R::Element]

Mutably borrow the vector’s elements as a slice.

impl<R: IntegerRegister> WrappingAdd for Vector<R>

fn wrapping_add(&self, v: &Self) -> Self

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl<R: IntegerRegister> WrappingMul for Vector<R>

fn wrapping_mul(&self, v: &Self) -> Self

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl<R: IntegerRegister> WrappingSub for Vector<R>

fn wrapping_sub(&self, v: &Self) -> Self

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl<R: NumericRegister> Zero for Vector<R>

fn is_zero(&self) -> bool

Returns true if all elements in the vector are zero.

fn set_zero(&mut self)

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

fn zero() -> Self

Returns the additive identity element of Self, 0.