Struct V1 

pub struct V1 {
    pub sse: Sse,
    pub sse2: Sse2,
    pub fxsr: Fxsr,
}

SSE instruction set.

Fields

sse: Sse

sse2: Sse2

fxsr: Fxsr

Implementations

impl V1

SSE instruction set.

pub const unsafe fn new_unchecked() -> Self

Returns a SIMD token type without checking if the required CPU features for this type are available.

Safety

• the required CPU features must be available.

pub fn try_new() -> Option<Self>

Returns a SIMD token type if the required CPU features for this type are available, otherwise returns None.

pub fn is_available() -> bool

Returns true if the required CPU features for this type are available, otherwise returns false.

pub fn vectorize<F: NullaryFnOnce>(self, f: F) -> F::Output

Vectorizes the given function as if the CPU features for this type were applied to it.

Note

For the vectorization to work properly, the given function must be inlined. Consider marking it as #[inline(always)]

pub fn to_ref(self) -> &'static Self

Takes a proof of the existence of this SIMD token (self), and returns a persistent reference to it.

impl V1

pub fn add_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Computes a + b for each lane of a and b.

pub fn add_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Adds the elements of each lane of a and b.

pub fn wrapping_add_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Adds the elements of each lane of a and b, with wrapping on overflow.

pub fn wrapping_add_i8x16(self, a: i8x16, b: i8x16) -> i8x16

Adds the elements of each lane of a and b, with wrapping on overflow.

pub fn wrapping_add_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Adds the elements of each lane of a and b, with wrapping on overflow.

pub fn wrapping_add_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Adds the elements of each lane of a and b, with wrapping on overflow.

pub fn wrapping_add_u32x4(self, a: u32x4, b: u32x4) -> u32x4

Adds the elements of each lane of a and b, with wrapping on overflow.

pub fn wrapping_add_i32x4(self, a: i32x4, b: i32x4) -> i32x4

Adds the elements of each lane of a and b, with wrapping on overflow.

pub fn wrapping_add_u64x2(self, a: u64x2, b: u64x2) -> u64x2

Adds the elements of each lane of a and b, with wrapping on overflow.

pub fn wrapping_add_i64x2(self, a: i64x2, b: i64x2) -> i64x2

Adds the elements of each lane of a and b, with wrapping on overflow.

pub fn and_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Returns a & b for each bit in a and b.

pub fn and_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Returns a & b for each bit in a and b.

pub fn and_m8x16(self, a: m8x16, b: m8x16) -> m8x16

Returns a & b for each bit in a and b.

pub fn and_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Returns a & b for each bit in a and b.

pub fn and_i8x16(self, a: i8x16, b: i8x16) -> i8x16

Returns a & b for each bit in a and b.

pub fn and_m16x8(self, a: m16x8, b: m16x8) -> m16x8

Returns a & b for each bit in a and b.

pub fn and_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Returns a & b for each bit in a and b.

pub fn and_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Returns a & b for each bit in a and b.

pub fn and_m32x4(self, a: m32x4, b: m32x4) -> m32x4

Returns a & b for each bit in a and b.

pub fn and_u32x4(self, a: u32x4, b: u32x4) -> u32x4

Returns a & b for each bit in a and b.

pub fn and_i32x4(self, a: i32x4, b: i32x4) -> i32x4

Returns a & b for each bit in a and b.

pub fn and_m64x2(self, a: m64x2, b: m64x2) -> m64x2

Returns a & b for each bit in a and b.

pub fn and_u64x2(self, a: u64x2, b: u64x2) -> u64x2

Returns a & b for each bit in a and b.

pub fn and_i64x2(self, a: i64x2, b: i64x2) -> i64x2

Returns a & b for each bit in a and b.

pub fn andnot_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Returns !a & b for each bit in a and b.

pub fn andnot_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Returns !a & b for each bit in a and b.

pub fn andnot_m8x16(self, a: m8x16, b: m8x16) -> m8x16

Returns !a & b for each bit in a and b.

pub fn andnot_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Returns !a & b for each bit in a and b.

pub fn andnot_i8x16(self, a: i8x16, b: i8x16) -> i8x16

Returns !a & b for each bit in a and b.

pub fn andnot_m16x8(self, a: m16x8, b: m16x8) -> m16x8

Returns !a & b for each bit in a and b.

pub fn andnot_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Returns !a & b for each bit in a and b.

pub fn andnot_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Returns !a & b for each bit in a and b.

pub fn andnot_m32x4(self, a: m32x4, b: m32x4) -> m32x4

Returns !a & b for each bit in a and b.

pub fn andnot_u32x4(self, a: u32x4, b: u32x4) -> u32x4

Returns !a & b for each bit in a and b.

pub fn andnot_i32x4(self, a: i32x4, b: i32x4) -> i32x4

Returns !a & b for each bit in a and b.

pub fn andnot_m64x2(self, a: m64x2, b: m64x2) -> m64x2

Returns !a & b for each bit in a and b.

pub fn andnot_u64x2(self, a: u64x2, b: u64x2) -> u64x2

Returns !a & b for each bit in a and b.

pub fn andnot_i64x2(self, a: i64x2, b: i64x2) -> i64x2

Returns !a & b for each bit in a and b.

pub fn average_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Computes average(a, b) for each lane of a and b.

pub fn average_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Computes average(a, b) for each lane of a and b.

pub fn cmp_eq_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_m8x16(self, a: m8x16, b: m8x16) -> m8x16

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_u8x16(self, a: u8x16, b: u8x16) -> m8x16

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_i8x16(self, a: i8x16, b: i8x16) -> m8x16

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_m16x8(self, a: m16x8, b: m16x8) -> m16x8

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_u16x8(self, a: u16x8, b: u16x8) -> m16x8

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_i16x8(self, a: i16x8, b: i16x8) -> m16x8

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_m32x4(self, a: m32x4, b: m32x4) -> m32x4

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_u32x4(self, a: u32x4, b: u32x4) -> m32x4

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_i32x4(self, a: i32x4, b: i32x4) -> m32x4

Compares the elements in each lane of a and b for equality.

pub fn cmp_eq_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for equality.

pub fn cmp_ge_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for greater-than-or-equal-to.

pub fn cmp_ge_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for greater-than-or-equal-to.

pub fn cmp_gt_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for greater-than.

pub fn cmp_gt_i8x16(self, a: i8x16, b: i8x16) -> m8x16

Compares the elements in each lane of a and b for equality.

pub fn cmp_gt_i16x8(self, a: i16x8, b: i16x8) -> m16x8

Compares the elements in each lane of a and b for equality.

pub fn cmp_gt_i32x4(self, a: i32x4, b: i32x4) -> m32x4

Compares the elements in each lane of a and b for equality.

pub fn cmp_gt_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for equality.

pub fn cmp_lt_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for greater-than.

pub fn cmp_lt_i8x16(self, a: i8x16, b: i8x16) -> m8x16

Compares the elements in each lane of a and b for less-than.

pub fn cmp_lt_i16x8(self, a: i16x8, b: i16x8) -> m16x8

Compares the elements in each lane of a and b for less-than.

pub fn cmp_lt_i32x4(self, a: i32x4, b: i32x4) -> m32x4

Compares the elements in each lane of a and b for less-than.

pub fn cmp_lt_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for less-than.

pub fn cmp_le_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for less-than-or-equal-to.

pub fn cmp_le_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for less-than-or-equal-to.

pub fn cmp_not_eq_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for inequality.

pub fn cmp_not_eq_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for inequality.

pub fn cmp_not_ge_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for not-greater-than-or-equal.

pub fn cmp_not_ge_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for not-greater-than-or-equal.

pub fn cmp_not_gt_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for not-greater-than.

pub fn cmp_not_gt_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for not-greater-than.

pub fn cmp_not_le_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for not-less-than-or-equal.

pub fn cmp_not_le_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for not-less-than-or-equal.

pub fn cmp_not_lt_f32x4(self, a: f32x4, b: f32x4) -> m32x4

Compares the elements in each lane of a and b for not-less-than.

pub fn cmp_not_lt_f64x2(self, a: f64x2, b: f64x2) -> m64x2

Compares the elements in each lane of a and b for not-less-than.

pub fn div_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Divides the elements of each lane of a and b.

pub fn div_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Divides the elements of each lane of a and b.

pub fn max_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Computes max(a, b). for each lane in a and b.

pub fn max_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Computes max(a, b). for each lane in a and b.

pub fn max_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Computes max(a, b). for each lane in a and b.

pub fn max_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Computes max(a, b). for each lane in a and b.

pub fn min_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Computes max(a, b). for each lane in a and b.

pub fn min_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Computes max(a, b). for each lane in a and b.

pub fn min_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Computes max(a, b). for each lane in a and b.

pub fn min_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Computes max(a, b). for each lane in a and b.

pub fn mul_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Computes a * b for each lane in a and b.

pub fn mul_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Computes a * b for each lane in a and b.

pub fn wrapping_mul_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Computes a * b for each lane in a and b, with wrapping overflow.

pub fn wrapping_mul_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Computes a * b for each lane in a and b, with wrapping overflow.

pub fn or_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Returns a | b for each bit in a and b.

pub fn or_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Returns a | b for each bit in a and b.

pub fn or_m8x16(self, a: m8x16, b: m8x16) -> m8x16

Returns a | b for each bit in a and b.

pub fn or_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Returns a | b for each bit in a and b.

pub fn or_i8x16(self, a: i8x16, b: i8x16) -> i8x16

Returns a | b for each bit in a and b.

pub fn or_m16x8(self, a: m16x8, b: m16x8) -> m16x8

Returns a | b for each bit in a and b.

pub fn or_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Returns a | b for each bit in a and b.

pub fn or_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Returns a | b for each bit in a and b.

pub fn or_m32x4(self, a: m32x4, b: m32x4) -> m32x4

Returns a | b for each bit in a and b.

pub fn or_u32x4(self, a: u32x4, b: u32x4) -> u32x4

Returns a | b for each bit in a and b.

pub fn or_i32x4(self, a: i32x4, b: i32x4) -> i32x4

Returns a | b for each bit in a and b.

pub fn or_m64x2(self, a: m64x2, b: m64x2) -> m64x2

Returns a | b for each bit in a and b.

pub fn or_u64x2(self, a: u64x2, b: u64x2) -> u64x2

Returns a | b for each bit in a and b.

pub fn or_i64x2(self, a: i64x2, b: i64x2) -> i64x2

Returns a | b for each bit in a and b.

pub fn saturating_add_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Adds the elements of each lane of a and b, with saturation.

pub fn saturating_add_i8x16(self, a: i8x16, b: i8x16) -> i8x16

Adds the elements of each lane of a and b, with saturation.

pub fn saturating_add_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Adds the elements of each lane of a and b, with saturation.

pub fn saturating_add_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Adds the elements of each lane of a and b, with saturation.

pub fn saturating_sub_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Subtracts the elements of each lane of a and b, with saturation.

pub fn saturating_sub_i8x16(self, a: i8x16, b: i8x16) -> i8x16

Subtracts the elements of each lane of a and b, with saturation.

pub fn saturating_sub_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Subtracts the elements of each lane of a and b, with saturation.

pub fn saturating_sub_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Subtracts the elements of each lane of a and b, with saturation.

pub fn sub_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Subtracts the elements of each lane of a and b.

pub fn sub_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Subtracts the elements of each lane of a and b.

pub fn wrapping_sub_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Subtracts the elements of each lane of a and b, with wrapping overflow.

pub fn wrapping_sub_i8x16(self, a: i8x16, b: i8x16) -> i8x16

Subtracts the elements of each lane of a and b, with wrapping overflow.

pub fn wrapping_sub_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Subtracts the elements of each lane of a and b, with wrapping overflow.

pub fn wrapping_sub_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Subtracts the elements of each lane of a and b, with wrapping overflow.

pub fn wrapping_sub_u32x4(self, a: u32x4, b: u32x4) -> u32x4

Subtracts the elements of each lane of a and b, with wrapping overflow.

pub fn wrapping_sub_i32x4(self, a: i32x4, b: i32x4) -> i32x4

Subtracts the elements of each lane of a and b, with wrapping overflow.

pub fn wrapping_sub_u64x2(self, a: u64x2, b: u64x2) -> u64x2

Subtracts the elements of each lane of a and b, with wrapping overflow.

pub fn wrapping_sub_i64x2(self, a: i64x2, b: i64x2) -> i64x2

Subtracts the elements of each lane of a and b, with wrapping overflow.

pub fn xor_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Returns a ^ b for each bit in a and b.

pub fn xor_f64x2(self, a: f64x2, b: f64x2) -> f64x2

Returns a ^ b for each bit in a and b.

pub fn xor_m8x16(self, a: m8x16, b: m8x16) -> m8x16

Returns a ^ b for each bit in a and b.

pub fn xor_u8x16(self, a: u8x16, b: u8x16) -> u8x16

Returns a ^ b for each bit in a and b.

pub fn xor_i8x16(self, a: i8x16, b: i8x16) -> i8x16

Returns a ^ b for each bit in a and b.

pub fn xor_m16x8(self, a: m16x8, b: m16x8) -> m16x8

Returns a ^ b for each bit in a and b.

pub fn xor_u16x8(self, a: u16x8, b: u16x8) -> u16x8

Returns a ^ b for each bit in a and b.

pub fn xor_i16x8(self, a: i16x8, b: i16x8) -> i16x8

Returns a ^ b for each bit in a and b.

pub fn xor_m32x4(self, a: m32x4, b: m32x4) -> m32x4

Returns a ^ b for each bit in a and b.

pub fn xor_u32x4(self, a: u32x4, b: u32x4) -> u32x4

Returns a ^ b for each bit in a and b.

pub fn xor_i32x4(self, a: i32x4, b: i32x4) -> i32x4

Returns a ^ b for each bit in a and b.

pub fn xor_m64x2(self, a: m64x2, b: m64x2) -> m64x2

Returns a ^ b for each bit in a and b.

pub fn xor_u64x2(self, a: u64x2, b: u64x2) -> u64x2

Returns a ^ b for each bit in a and b.

pub fn xor_i64x2(self, a: i64x2, b: i64x2) -> i64x2

Returns a ^ b for each bit in a and b.

pub fn abs_f32x4(self, a: f32x4) -> f32x4

Computes abs(a) for each lane of a.

pub fn abs_f64x2(self, a: f64x2) -> f64x2

Computes abs(a) for each lane of a.

pub fn approx_reciprocal_f32x4(self, a: f32x4) -> f32x4

Computes the approximate reciprocal of the elements of each lane of a.

pub fn approx_reciprocal_sqrt_f32x4(self, a: f32x4) -> f32x4

Computes the approximate reciprocal of the square roots of the elements of each lane of a.

pub fn cmp_ge_i16x8(self, a: i16x8, b: i16x8) -> m16x8

Compares the elements in each lane of a and b for greater-than-or-equal-to.

pub fn cmp_ge_i32x4(self, a: i32x4, b: i32x4) -> m32x4

Compares the elements in each lane of a and b for greater-than-or-equal-to.

pub fn cmp_ge_i8x16(self, a: i8x16, b: i8x16) -> m8x16

Compares the elements in each lane of a and b for greater-than-or-equal-to.

pub fn cmp_ge_u16x8(self, a: u16x8, b: u16x8) -> m16x8

Compares the elements in each lane of a and b for greater-than-or-equal-to.

pub fn cmp_ge_u32x4(self, a: u32x4, b: u32x4) -> m32x4

Compares the elements in each lane of a and b for greater-than-or-equal-to.

pub fn cmp_ge_u8x16(self, a: u8x16, b: u8x16) -> m8x16

Compares the elements in each lane of a and b for greater-than-or-equal-to.

pub fn cmp_gt_u16x8(self, a: u16x8, b: u16x8) -> m16x8

Compares the elements in each lane of a and b for greater-than.

pub fn cmp_gt_u32x4(self, a: u32x4, b: u32x4) -> m32x4

Compares the elements in each lane of a and b for greater-than.

pub fn cmp_gt_u8x16(self, a: u8x16, b: u8x16) -> m8x16

Compares the elements in each lane of a and b for greater-than.

pub fn cmp_le_i16x8(self, a: i16x8, b: i16x8) -> m16x8

Compares the elements in each lane of a and b for less-than-or-equal-to.

pub fn cmp_le_i32x4(self, a: i32x4, b: i32x4) -> m32x4

Compares the elements in each lane of a and b for less-than-or-equal-to.

pub fn cmp_le_i8x16(self, a: i8x16, b: i8x16) -> m8x16

Compares the elements in each lane of a and b for less-than-or-equal-to.

pub fn cmp_le_u16x8(self, a: u16x8, b: u16x8) -> m16x8

Compares the elements in each lane of a and b for less-than-or-equal-to.

pub fn cmp_le_u32x4(self, a: u32x4, b: u32x4) -> m32x4

Compares the elements in each lane of a and b for less-than-or-equal-to.

pub fn cmp_le_u8x16(self, a: u8x16, b: u8x16) -> m8x16

Compares the elements in each lane of a and b for less-than-or-equal-to.

pub fn cmp_lt_u16x8(self, a: u16x8, b: u16x8) -> m16x8

Compares the elements in each lane of a and b for less-than.

pub fn cmp_lt_u32x4(self, a: u32x4, b: u32x4) -> m32x4

Compares the elements in each lane of a and b for less-than.

pub fn cmp_lt_u8x16(self, a: u8x16, b: u8x16) -> m8x16

Compares the elements in each lane of a and b for less-than.

pub fn convert_f32x4_to_f64x2(self, a: f32x4) -> f64x2

Converts a f32x4 to f64x2, elementwise, while truncating the extra elements.

pub fn convert_f32x4_to_i32x4(self, a: f32x4) -> i32x4

Converts a f32x4 to i32x4, elementwise.

pub fn convert_f64x2_to_f32x4(self, a: f64x2) -> f32x4

Converts a f64x2 to f32x4, elementwise, filling the remaining elements with zeros.

pub fn convert_f64x2_to_i32x4(self, a: f64x2) -> i32x4

Converts a f64x2 to i32x4, elementwise.

pub fn convert_i16x8_to_u16x8(self, a: i16x8) -> u16x8

Converts a i16x8 to u16x8, elementwise.

pub fn convert_i32x4_to_f32x4(self, a: i32x4) -> f32x4

Converts a i32x4 to f32x4, elementwise.

pub fn convert_i32x4_to_f64x2(self, a: i32x4) -> f64x2

Converts a i32x4 to f64x2, elementwise, while truncating the extra elements.

pub fn convert_i32x4_to_u32x4(self, a: i32x4) -> u32x4

Converts a i32x4 to u32x4, elementwise.

pub fn convert_i8x16_to_u8x16(self, a: i8x16) -> u8x16

Converts a i8x16 to u8x16, elementwise.

pub fn convert_u16x8_to_i16x8(self, a: u16x8) -> i16x8

Converts a u16x8 to i16x8, elementwise.

pub fn convert_u32x4_to_i32x4(self, a: u32x4) -> i32x4

Converts a u32x4 to i32x4, elementwise.

pub fn convert_u8x16_to_i8x16(self, a: u8x16) -> i8x16

Converts a u8x16 to i8x16, elementwise.

pub fn is_nan_f32x4(self, a: f32x4) -> m32x4

Checks if the elements in each lane of a are NaN.

pub fn is_nan_f64x2(self, a: f64x2) -> m64x2

Checks if the elements in each lane of a are NaN.

pub fn is_not_nan_f32x4(self, a: f32x4) -> m32x4

Checks if the elements in each lane of a are not NaN.

pub fn is_not_nan_f64x2(self, a: f64x2) -> m64x2

Checks if the elements in each lane of a are not NaN.

pub fn multiply_wrapping_add_adjacent_i16x8(self, a: i16x8, b: i16x8) -> i32x4

See _mm_madd_epi16.

pub fn not_i16x8(self, a: i16x8) -> i16x8

Returns !a for each bit in a.

pub fn not_i32x4(self, a: i32x4) -> i32x4

Returns !a for each bit in a.

pub fn not_i64x2(self, a: i64x2) -> i64x2

Returns !a for each bit in a.

pub fn not_i8x16(self, a: i8x16) -> i8x16

Returns !a for each bit in a.

pub fn not_m16x8(self, a: m16x8) -> m16x8

Returns !a for each bit in a.

pub fn not_m32x4(self, a: m32x4) -> m32x4

Returns !a for each bit in a.

pub fn not_m64x2(self, a: m64x2) -> m64x2

Returns !a for each bit in a.

pub fn not_m8x16(self, a: m8x16) -> m8x16

Returns !a for each bit in a.

pub fn not_u16x8(self, a: u16x8) -> u16x8

Returns !a for each bit in a.

pub fn not_u32x4(self, a: u32x4) -> u32x4

Returns !a for each bit in a.

pub fn not_u64x2(self, a: u64x2) -> u64x2

Returns !a for each bit in a.

pub fn not_u8x16(self, a: u8x16) -> u8x16

Returns !a for each bit in a.

pub fn pack_with_signed_saturation_i16x8(self, a: i16x8, b: i16x8) -> i8x16

See _mm_packs_epi16.

pub fn pack_with_signed_saturation_i32x4(self, a: i32x4, b: i32x4) -> i16x8

See _mm_packs_epi32.

pub fn pack_with_unsigned_saturation_i16x8(self, a: i16x8, b: i16x8) -> u8x16

See _mm_packus_epi16.

pub fn reduce_max_c32x2(self, a: f32x4) -> c32

pub fn reduce_max_c64x1(self, a: f64x2) -> c64

pub fn reduce_max_f32x4(self, a: f32x4) -> f32

pub fn reduce_max_f64x2(self, a: f64x2) -> f64

pub fn reduce_min_c32x2(self, a: f32x4) -> c32

pub fn reduce_min_c64x1(self, a: f64x2) -> c64

pub fn reduce_min_f32x4(self, a: f32x4) -> f32

pub fn reduce_min_f64x2(self, a: f64x2) -> f64

pub fn reduce_product_f32x4(self, a: f32x4) -> f32

pub fn reduce_product_f64x2(self, a: f64x2) -> f64

pub fn reduce_sum_c32x2(self, a: f32x4) -> c32

pub fn reduce_sum_c64x1(self, a: f64x2) -> c64

pub fn reduce_sum_f32x4(self, a: f32x4) -> f32

pub fn reduce_sum_f64x2(self, a: f64x2) -> f64

pub fn shl_const_i16x8<const AMOUNT: i32>(self, a: i16x8) -> i16x8

Shift the bits of each lane of a to the left by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_const_i32x4<const AMOUNT: i32>(self, a: i32x4) -> i32x4

Shift the bits of each lane of a to the left by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_const_i64x2<const AMOUNT: i32>(self, a: i64x2) -> i64x2

Shift the bits of each lane of a to the left by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_const_u16x8<const AMOUNT: i32>(self, a: u16x8) -> u16x8

Shift the bits of each lane of a to the left by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_const_u32x4<const AMOUNT: i32>(self, a: u32x4) -> u32x4

Shift the bits of each lane of a to the left by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_const_u64x2<const AMOUNT: i32>(self, a: u64x2) -> u64x2

Shift the bits of each lane of a to the left by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_i16x8(self, a: i16x8, amount: u64x2) -> i16x8

Shift the bits of each lane of a to the left by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_i32x4(self, a: i32x4, amount: u64x2) -> i32x4

Shift the bits of each lane of a to the left by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_i64x2(self, a: i64x2, amount: u64x2) -> u64x2

Shift the bits of each lane of a to the left by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_u16x8(self, a: u16x8, amount: u64x2) -> u16x8

Shift the bits of each lane of a to the left by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_u32x4(self, a: u32x4, amount: u64x2) -> u32x4

Shift the bits of each lane of a to the left by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shl_u64x2(self, a: u64x2, amount: u64x2) -> u64x2

Shift the bits of each lane of a to the left by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shr_const_i16x8<const AMOUNT: i32>(self, a: i16x8) -> i16x8

Shift the bits of each lane of a to the right by AMOUNT, while shifting in sign bits. Shifting by a value greater than the bit width of the type sets the result to zero if the sign bit is not set, and to -1 if the sign bit is set.

pub fn shr_const_i32x4<const AMOUNT: i32>(self, a: i32x4) -> i32x4

Shift the bits of each lane of a to the right by AMOUNT, while shifting in sign bits. Shifting by a value greater than the bit width of the type sets the result to zero if the sign bit is not set, and to -1 if the sign bit is set.

pub fn shr_const_u16x8<const AMOUNT: i32>(self, a: u16x8) -> u16x8

Shift the bits of each lane of a to the right by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shr_const_u32x4<const AMOUNT: i32>(self, a: u32x4) -> u32x4

Shift the bits of each lane of a to the right by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shr_const_u64x2<const AMOUNT: i32>(self, a: u64x2) -> u64x2

Shift the bits of each lane of a to the right by AMOUNT, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shr_i16x8(self, a: i16x8, amount: u64x2) -> i16x8

Shift the bits of each lane of a to the right by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero if the sign bit is not set, and to -1 if the sign bit is set.

pub fn shr_i32x4(self, a: i32x4, amount: u64x2) -> i32x4

Shift the bits of each lane of a to the right by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero if the sign bit is not set, and to -1 if the sign bit is set.

pub fn shr_u16x8(self, a: u16x8, amount: u64x2) -> u16x8

Shift the bits of each lane of a to the right by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shr_u32x4(self, a: u32x4, amount: u64x2) -> u32x4

Shift the bits of each lane of a to the right by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn shr_u64x2(self, a: u64x2, amount: u64x2) -> u64x2

Shift the bits of each lane of a to the right by the first element in amount, while shifting in zeros. Shifting by a value greater than the bit width of the type sets the result to zero.

pub fn splat_f32x4(self, value: f32) -> f32x4

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_f64x2(self, value: f64) -> f64x2

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_i16x8(self, value: i16) -> i16x8

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_i32x4(self, value: i32) -> i32x4

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_i64x2(self, value: i64) -> i64x2

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_i8x16(self, value: i8) -> i8x16

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_m16x8(self, value: m16) -> m16x8

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_m32x4(self, value: m32) -> m32x4

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_m64x2(self, value: m64) -> m64x2

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_m8x16(self, value: m8) -> m8x16

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_u16x8(self, value: u16) -> u16x8

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_u32x4(self, value: u32) -> u32x4

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_u64x2(self, value: u64) -> u64x2

Returns a SIMD vector with all lanes set to the given value.

pub fn splat_u8x16(self, value: u8) -> u8x16

Returns a SIMD vector with all lanes set to the given value.

pub fn sqrt_f32x4(self, a: f32x4) -> f32x4

Computes the square roots of the elements of each lane of a.

pub fn sqrt_f64x2(self, a: f64x2) -> f64x2

Computes the square roots of the elements of each lane of a.

pub fn sum_of_absolute_differences_u8x16(self, a: u8x16, b: u8x16) -> u64x2

See _mm_sad_epu8.

pub fn widening_mul_i16x8(self, a: i16x8, b: i16x8) -> (u16x8, i16x8)

Multiplies the elements of each lane of a and b, and returns separately the low and high bits of the result.

pub fn widening_mul_u16x8(self, a: u16x8, b: u16x8) -> (u16x8, u16x8)

Multiplies the elements of each lane of a and b, and returns separately the low and high bits of the result.

Trait Implementations

impl Clone for V1

fn clone(&self) -> V1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for V1

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

Formats the value using the given formatter.

impl Copy for V1