Struct pulp::x86::V2

#[repr(transparent)]
pub struct V2 {
    pub sse: Sse,
    pub sse2: Sse2,
    pub fxsr: Fxsr,
    pub sse3: Sse3,
    pub ssse3: Ssse3,
    pub sse4_1: Sse4_1,
    pub sse4_2: Sse4_2,
    pub popcnt: Popcnt,
}

SSE instruction set.

Fields

sse: Sse

sse2: Sse2

fxsr: Fxsr

sse3: Sse3

ssse3: Ssse3

sse4_1: Sse4_1

sse4_2: Sse4_2

popcnt: Popcnt

Implementations

impl V2

SSE instruction set.

pub 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 V2

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

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_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_i16x8(self, value: i16) -> i16x8

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_u32x4(self, value: u32) -> u32x4

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_m32x4(self, value: m32) -> m32x4

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

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

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_i64x2(self, value: i64) -> i64x2

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_f64x2(self, value: f64) -> f64x2

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

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise AND of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise OR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise XOR of a and b.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise NOT of a.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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

Returns the bitwise AND of NOT a and b.

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_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_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_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_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_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 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_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_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_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_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 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_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_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_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_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 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 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_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_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_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_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 add_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Adds the elements of 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 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 subadd_f32x4(self, a: f32x4, b: f32x4) -> f32x4

Alternatively subtracts and adds the elements of each lane of a and b.

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

Alternatively subtracts and adds the elements of each lane of a and b.

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

Multiplies the elements of each lane of a and b.

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

Multiplies the elements of each lane of a and b.

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 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 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 wrapping_sub_u8x16(self, a: u8x16, b: u8x16) -> u8x16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 wrapping_mul_u16x8(self, a: u16x8, b: u16x8) -> u16x8

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

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

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

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

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

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

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

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.

pub fn widening_mul_i16x8(self, a: i16x8, b: i16x8) -> (i16x8, 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_u32x4(self, a: u32x4, b: u32x4) -> (u32x4, u32x4)

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_i32x4(self, a: i32x4, b: i32x4) -> (i32x4, i32x4)

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

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

Averages the elements of each lane of a and b.

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

Averages the elements of each lane of a and b.

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

Computes the elementwise minimum of each lane of a and b.

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

Computes the elementwise minimum of each lane of a and b.

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

Computes the elementwise minimum of each lane of a and b.

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

Computes the elementwise minimum of each lane of a and b.

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

Computes the elementwise minimum of each lane of a and b.

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

Computes the elementwise minimum of each lane of a and b.

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

Computes the elementwise minimum of each lane of a and b.

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

Computes the elementwise minimum of each lane of a and b.

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

Computes the elementwise maximum of each lane of a and b.

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

Computes the elementwise maximum of each lane of a and b.

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

Computes the elementwise maximum of each lane of a and b.

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

Computes the elementwise maximum of each lane of a and b.

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

Computes the elementwise maximum of each lane of a and b.

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

Computes the elementwise maximum of each lane of a and b.

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

Computes the elementwise maximum of each lane of a and b.

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

Computes the elementwise maximum of each lane of a and b.

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

Computes the absolute value of the elements of each lane of a.

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

Computes the absolute value of the elements of each lane of a.

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

Computes the unsigned absolute value of the elements of each lane of a.

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

Computes the unsigned absolute value of the elements of each lane of a.

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

Computes the unsigned absolute value of the elements of each lane of a.

pub fn apply_sign_i8x16(self, sign: i8x16, a: i8x16) -> i8x16

Applies the sign of each element of sign to the corresponding lane in a.

• If sign is zero, the corresponding element is zeroed.
• If sign is positive, the corresponding element is returned as is.
• If sign is negative, the corresponding element is negated.

pub fn apply_sign_i16x8(self, sign: i16x8, a: i16x8) -> i16x8

Applies the sign of each element of sign to the corresponding lane in a.

• If sign is zero, the corresponding element is zeroed.
• If sign is positive, the corresponding element is returned as is.
• If sign is negative, the corresponding element is negated.

pub fn apply_sign_i32x4(self, sign: i32x4, a: i32x4) -> i32x4

Applies the sign of each element of sign to the corresponding lane in a.

• If sign is zero, the corresponding element is zeroed.
• If sign is positive, the corresponding element is returned as is.
• If sign is negative, the corresponding element is negated.

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 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 floor_f32x4(self, a: f32x4) -> f32x4

Rounds the elements of each lane of a to the nearest integer towards negative infinity.

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

Rounds the elements of each lane of a to the nearest integer towards negative infinity.

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

Rounds the elements of each lane of a to the nearest integer towards positive infinity.

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

Rounds the elements of each lane of a to the nearest integer towards positive infinity.

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

Rounds the elements of each lane of a to the nearest integer. If two values are equally close, the even value is returned.

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

Rounds the elements of each lane of a to the nearest integer. If two values are equally close, the even value is returned.

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

Rounds the elements of each lane of a to the nearest integer towards zero.

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

Rounds the elements of each lane of a to the nearest integer towards zero.

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

See _mm_hadd_epi16.

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

See _mm_hadd_epi32.

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

See _mm_hadd_ps.

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

See _mm_hadd_pd.

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

See _mm_hsub_epi16

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

See _mm_hsub_epi32

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

See _mm_hsub_ps

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

See _mm_hsub_pd

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

See _mm_hadds_epi16

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

See _mm_hsubs_epi16

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

See _mm_madd_epi16

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

See _mm_maddubs_epi16

pub fn multisum_of_absolute_differences_u8x16<const OFFSETS: i32>( self, a: u8x16, b: u8x16 ) -> u16x8

See _mm_mpsadbw_epu8.

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 pack_with_unsigned_saturation_i32x4(self, a: i32x4, b: i32x4) -> u16x8

See _mm_packus_epi32

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

See _mm_sad_epu8

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

Converts a u8x16 to i8x16, elementwise.

pub fn convert_u8x16_to_u16x8(self, a: u8x16) -> u16x8

Converts a u8x16 to u16x8, elementwise, while truncating the extra elements.

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

Converts a u8x16 to i16x8, elementwise, while truncating the extra elements.

pub fn convert_u8x16_to_u32x4(self, a: u8x16) -> u32x4

Converts a u8x16 to u32x4, elementwise, while truncating the extra elements.

pub fn convert_u8x16_to_i32x4(self, a: u8x16) -> i32x4

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

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

Converts a u8x16 to u64x2, elementwise, while truncating the extra elements.

pub fn convert_u8x16_to_i64x2(self, a: u8x16) -> i64x2

Converts a u8x16 to i64x2, elementwise, while truncating the extra elements.

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

Converts a i8x16 to u8x16, elementwise.

pub fn convert_i8x16_to_u16x8(self, a: i8x16) -> u16x8

Converts a i8x16 to u16x8, elementwise, while truncating the extra elements.

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

Converts a i8x16 to i16x8, elementwise, while truncating the extra elements.

pub fn convert_i8x16_to_u32x4(self, a: i8x16) -> u32x4

Converts a i8x16 to u32x4, elementwise, while truncating the extra elements.

pub fn convert_i8x16_to_i32x4(self, a: i8x16) -> i32x4

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

pub fn convert_i8x16_to_u64x2(self, a: i8x16) -> u64x2

Converts a i8x16 to u64x2, elementwise, while truncating the extra elements.

pub fn convert_i8x16_to_i64x2(self, a: i8x16) -> i64x2

Converts a i8x16 to i64x2, elementwise, while truncating the extra elements.

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

Converts a u16x8 to i16x8, elementwise.

pub fn convert_u16x8_to_u32x4(self, a: u16x8) -> u32x4

Converts a u16x8 to u32x4, elementwise, while truncating the extra elements.

pub fn convert_u16x8_to_i32x4(self, a: u16x8) -> i32x4

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

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

Converts a u16x8 to u64x2, elementwise, while truncating the extra elements.

pub fn convert_u16x8_to_i64x2(self, a: u16x8) -> i64x2

Converts a u16x8 to i64x2, elementwise, while truncating the extra elements.

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

Converts a i16x8 to u16x8, elementwise.

pub fn convert_i16x8_to_u32x4(self, a: i16x8) -> u32x4

Converts a i16x8 to u32x4, elementwise, while truncating the extra elements.

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

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

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

Converts a i16x8 to u64x2, elementwise, while truncating the extra elements.

pub fn convert_i16x8_to_i64x2(self, a: i16x8) -> i64x2

Converts a i16x8 to i64x2, elementwise, while truncating the extra elements.

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

Converts a u32x4 to i32x4, elementwise.

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

Converts a u32x4 to u64x2, elementwise, while truncating the extra elements.

pub fn convert_u32x4_to_i64x2(self, a: u32x4) -> i64x2

Converts a u32x4 to i64x2, 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_i32x4_to_f32x4(self, a: i32x4) -> f32x4

Converts a i32x4 to f32x4, elementwise.

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

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

pub fn convert_i32x4_to_i64x2(self, a: i32x4) -> i64x2

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

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

Converts a i32x4 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_f32x4_to_f64x2(self, a: f32x4) -> f64x2

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

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

Converts a f64x2 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 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_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_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_u64x2(self, a: u64x2, b: u64x2) -> m64x2

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

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

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

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_gt_i8x16(self, a: i8x16, b: i8x16) -> m8x16

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

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_i16x8(self, a: i16x8, b: i16x8) -> 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_i32x4(self, a: i32x4, b: i32x4) -> m32x4

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

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

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

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

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

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_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_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_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_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_u64x2(self, a: u64x2, b: u64x2) -> m64x2

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

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

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

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 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_u16x8(self, a: u16x8, b: u16x8) -> m16x8

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_u32x4(self, a: u32x4, b: u32x4) -> m32x4

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_u64x2(self, a: u64x2, b: u64x2) -> m64x2

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

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

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

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_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_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_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_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_u64x2(self, a: u64x2, b: u64x2) -> m64x2

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

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

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

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_f64x2(self, a: f64x2, b: f64x2) -> m64x2

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

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_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_f64x2(self, a: f64x2, b: f64x2) -> m64x2

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

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_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_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_lt_f32x4(self, a: f32x4, b: f32x4) -> 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_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 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 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 select_const_u32x4<const MASK4: i32>( self, if_true: u32x4, if_false: u32x4 ) -> u32x4

Combines if_true and if_false, selecting elements from if_true if the corresponding bit in the mask is set, otherwise selecting elements from if_false.

pub fn select_const_i32x4<const MASK4: i32>( self, if_true: i32x4, if_false: i32x4 ) -> i32x4

Combines if_true and if_false, selecting elements from if_true if the corresponding bit in the mask is set, otherwise selecting elements from if_false.

pub fn select_const_f32x4<const MASK4: i32>( self, if_true: f32x4, if_false: f32x4 ) -> f32x4

Combines if_true and if_false, selecting elements from if_true if the corresponding bit in the mask is set, otherwise selecting elements from if_false.

pub fn select_const_u64x2<const MASK2: i32>( self, if_true: u64x2, if_false: u64x2 ) -> u64x2

Combines if_true and if_false, selecting elements from if_true if the corresponding bit in the mask is set, otherwise selecting elements from if_false.

pub fn select_const_i64x2<const MASK2: i32>( self, if_true: i64x2, if_false: i64x2 ) -> i64x2

Combines if_true and if_false, selecting elements from if_true if the corresponding bit in the mask is set, otherwise selecting elements from if_false.

pub fn select_const_f64x2<const MASK2: i32>( self, if_true: f64x2, if_false: f64x2 ) -> f64x2

Combines if_true and if_false, selecting elements from if_true if the corresponding bit in the mask is set, otherwise selecting elements from if_false.

pub fn select_u8x16(self, mask: m8x16, if_true: u8x16, if_false: u8x16) -> u8x16

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_i8x16(self, mask: m8x16, if_true: i8x16, if_false: i8x16) -> i8x16

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_u16x8(self, mask: m16x8, if_true: u16x8, if_false: u16x8) -> u16x8

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_i16x8(self, mask: m16x8, if_true: i16x8, if_false: i16x8) -> i16x8

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_u32x4(self, mask: m32x4, if_true: u32x4, if_false: u32x4) -> u32x4

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_i32x4(self, mask: m32x4, if_true: i32x4, if_false: i32x4) -> i32x4

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_f32x4(self, mask: m32x4, if_true: f32x4, if_false: f32x4) -> f32x4

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_u64x2(self, mask: m64x2, if_true: u64x2, if_false: u64x2) -> u64x2

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_i64x2(self, mask: m64x2, if_true: i64x2, if_false: i64x2) -> i64x2

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

pub fn select_f64x2(self, mask: m64x2, if_true: f64x2, if_false: f64x2) -> f64x2

Combines if_true and if_false, selecting elements from if_true if the corresponding mask in mask is set, otherwise selecting elements from if_false.

Trait Implementations

impl Clone for V2

fn clone(&self) -> V2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for V2

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

Formats the value using the given formatter.

impl Copy for V2