pub trait Simd:
Sized
+ Clone
+ Copy
+ Send
+ Sync
+ Seal
+ ArchTypes
+ 'static {
type f32s: SimdFloat<Self, Element = f32, Block = f32x4<Self>, Mask = Self::mask32s, Bytes = <Self::u32s as Bytes>::Bytes> + SimdCvtFloat<Self::u32s> + SimdCvtFloat<Self::i32s>;
type f64s: SimdFloat<Self, Element = f64, Block = f64x2<Self>, Mask = Self::mask64s>;
type u8s: SimdInt<Self, Element = u8, Block = u8x16<Self>, Mask = Self::mask8s>;
type i8s: SimdInt<Self, Element = i8, Block = i8x16<Self>, Mask = Self::mask8s, Bytes = <Self::u8s as Bytes>::Bytes> + Neg<Output = Self::i8s>;
type u16s: SimdInt<Self, Element = u16, Block = u16x8<Self>, Mask = Self::mask16s>;
type i16s: SimdInt<Self, Element = i16, Block = i16x8<Self>, Mask = Self::mask16s, Bytes = <Self::u16s as Bytes>::Bytes> + Neg<Output = Self::i16s>;
type u32s: SimdInt<Self, Element = u32, Block = u32x4<Self>, Mask = Self::mask32s> + SimdCvtTruncate<Self::f32s>;
type i32s: SimdInt<Self, Element = i32, Block = i32x4<Self>, Mask = Self::mask32s, Bytes = <Self::u32s as Bytes>::Bytes> + SimdCvtTruncate<Self::f32s> + Neg<Output = Self::i32s>;
type mask8s: SimdMask<Self, Element = i8, Block = mask8x16<Self>, Bytes = <Self::u8s as Bytes>::Bytes> + Select<Self::u8s> + Select<Self::i8s> + Select<Self::mask8s>;
type mask16s: SimdMask<Self, Element = i16, Block = mask16x8<Self>, Bytes = <Self::u16s as Bytes>::Bytes> + Select<Self::u16s> + Select<Self::i16s> + Select<Self::mask16s>;
type mask32s: SimdMask<Self, Element = i32, Block = mask32x4<Self>, Bytes = <Self::u32s as Bytes>::Bytes> + Select<Self::f32s> + Select<Self::u32s> + Select<Self::i32s> + Select<Self::mask32s>;
type mask64s: SimdMask<Self, Element = i64, Block = mask64x2<Self>> + Select<Self::f64s> + Select<Self::mask64s>;
Show 1286 methods
// Required methods
fn level(self) -> Level;
fn vectorize<F: FnOnce() -> R, R>(self, f: F) -> R;
fn splat_f32x4(self, val: f32) -> f32x4<Self>;
fn load_array_f32x4(self, val: [f32; 4]) -> f32x4<Self>;
fn load_array_ref_f32x4(self, val: &[f32; 4]) -> f32x4<Self>;
fn as_array_f32x4(self, a: f32x4<Self>) -> [f32; 4];
fn as_array_ref_f32x4(self, a: &f32x4<Self>) -> &[f32; 4];
fn as_array_mut_f32x4(self, a: &mut f32x4<Self>) -> &mut [f32; 4];
fn store_array_f32x4(self, a: f32x4<Self>, dest: &mut [f32; 4]);
fn cvt_from_bytes_f32x4(self, a: u8x16<Self>) -> f32x4<Self>;
fn cvt_to_bytes_f32x4(self, a: f32x4<Self>) -> u8x16<Self>;
fn slide_f32x4<const SHIFT: usize>(
self,
a: f32x4<Self>,
b: f32x4<Self>,
) -> f32x4<Self>;
fn slide_within_blocks_f32x4<const SHIFT: usize>(
self,
a: f32x4<Self>,
b: f32x4<Self>,
) -> f32x4<Self>;
fn abs_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
fn neg_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
fn sqrt_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
fn add_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn sub_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn mul_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn div_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn copysign_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn simd_eq_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>;
fn simd_lt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>;
fn simd_le_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>;
fn simd_ge_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>;
fn simd_gt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>;
fn zip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn zip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn unzip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn unzip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn interleave_f32x4(
self,
a: f32x4<Self>,
b: f32x4<Self>,
) -> (f32x4<Self>, f32x4<Self>);
fn deinterleave_f32x4(
self,
a: f32x4<Self>,
b: f32x4<Self>,
) -> (f32x4<Self>, f32x4<Self>);
fn max_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn min_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn max_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn min_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>;
fn mul_add_f32x4(
self,
a: f32x4<Self>,
b: f32x4<Self>,
c: f32x4<Self>,
) -> f32x4<Self>;
fn mul_sub_f32x4(
self,
a: f32x4<Self>,
b: f32x4<Self>,
c: f32x4<Self>,
) -> f32x4<Self>;
fn floor_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
fn ceil_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
fn round_ties_even_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
fn fract_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
fn trunc_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
fn select_f32x4(
self,
a: mask32x4<Self>,
b: f32x4<Self>,
c: f32x4<Self>,
) -> f32x4<Self>;
fn combine_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x8<Self>;
fn reinterpret_f64_f32x4(self, a: f32x4<Self>) -> f64x2<Self>;
fn reinterpret_i32_f32x4(self, a: f32x4<Self>) -> i32x4<Self>;
fn reinterpret_u8_f32x4(self, a: f32x4<Self>) -> u8x16<Self>;
fn reinterpret_u32_f32x4(self, a: f32x4<Self>) -> u32x4<Self>;
fn cvt_u32_f32x4(self, a: f32x4<Self>) -> u32x4<Self>;
fn cvt_u32_precise_f32x4(self, a: f32x4<Self>) -> u32x4<Self>;
fn cvt_i32_f32x4(self, a: f32x4<Self>) -> i32x4<Self>;
fn cvt_i32_precise_f32x4(self, a: f32x4<Self>) -> i32x4<Self>;
fn splat_i8x16(self, val: i8) -> i8x16<Self>;
fn load_array_i8x16(self, val: [i8; 16]) -> i8x16<Self>;
fn load_array_ref_i8x16(self, val: &[i8; 16]) -> i8x16<Self>;
fn as_array_i8x16(self, a: i8x16<Self>) -> [i8; 16];
fn as_array_ref_i8x16(self, a: &i8x16<Self>) -> &[i8; 16];
fn as_array_mut_i8x16(self, a: &mut i8x16<Self>) -> &mut [i8; 16];
fn store_array_i8x16(self, a: i8x16<Self>, dest: &mut [i8; 16]);
fn cvt_from_bytes_i8x16(self, a: u8x16<Self>) -> i8x16<Self>;
fn cvt_to_bytes_i8x16(self, a: i8x16<Self>) -> u8x16<Self>;
fn slide_i8x16<const SHIFT: usize>(
self,
a: i8x16<Self>,
b: i8x16<Self>,
) -> i8x16<Self>;
fn slide_within_blocks_i8x16<const SHIFT: usize>(
self,
a: i8x16<Self>,
b: i8x16<Self>,
) -> i8x16<Self>;
fn add_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn sub_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn mul_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn and_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn or_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn xor_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn not_i8x16(self, a: i8x16<Self>) -> i8x16<Self>;
fn shl_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self>;
fn shlv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn shr_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self>;
fn shrv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn simd_eq_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>;
fn simd_lt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>;
fn simd_le_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>;
fn simd_ge_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>;
fn simd_gt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>;
fn zip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn zip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn unzip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn unzip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn interleave_i8x16(
self,
a: i8x16<Self>,
b: i8x16<Self>,
) -> (i8x16<Self>, i8x16<Self>);
fn deinterleave_i8x16(
self,
a: i8x16<Self>,
b: i8x16<Self>,
) -> (i8x16<Self>, i8x16<Self>);
fn select_i8x16(
self,
a: mask8x16<Self>,
b: i8x16<Self>,
c: i8x16<Self>,
) -> i8x16<Self>;
fn min_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn max_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
fn combine_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x32<Self>;
fn neg_i8x16(self, a: i8x16<Self>) -> i8x16<Self>;
fn reinterpret_u8_i8x16(self, a: i8x16<Self>) -> u8x16<Self>;
fn reinterpret_u32_i8x16(self, a: i8x16<Self>) -> u32x4<Self>;
fn splat_u8x16(self, val: u8) -> u8x16<Self>;
fn load_array_u8x16(self, val: [u8; 16]) -> u8x16<Self>;
fn load_array_ref_u8x16(self, val: &[u8; 16]) -> u8x16<Self>;
fn as_array_u8x16(self, a: u8x16<Self>) -> [u8; 16];
fn as_array_ref_u8x16(self, a: &u8x16<Self>) -> &[u8; 16];
fn as_array_mut_u8x16(self, a: &mut u8x16<Self>) -> &mut [u8; 16];
fn store_array_u8x16(self, a: u8x16<Self>, dest: &mut [u8; 16]);
fn cvt_from_bytes_u8x16(self, a: u8x16<Self>) -> u8x16<Self>;
fn cvt_to_bytes_u8x16(self, a: u8x16<Self>) -> u8x16<Self>;
fn slide_u8x16<const SHIFT: usize>(
self,
a: u8x16<Self>,
b: u8x16<Self>,
) -> u8x16<Self>;
fn slide_within_blocks_u8x16<const SHIFT: usize>(
self,
a: u8x16<Self>,
b: u8x16<Self>,
) -> u8x16<Self>;
fn add_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn sub_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn mul_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn and_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn or_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn xor_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn not_u8x16(self, a: u8x16<Self>) -> u8x16<Self>;
fn shl_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self>;
fn shlv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn shr_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self>;
fn shrv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn simd_eq_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>;
fn simd_lt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>;
fn simd_le_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>;
fn simd_ge_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>;
fn simd_gt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>;
fn zip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn zip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn unzip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn unzip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn interleave_u8x16(
self,
a: u8x16<Self>,
b: u8x16<Self>,
) -> (u8x16<Self>, u8x16<Self>);
fn deinterleave_u8x16(
self,
a: u8x16<Self>,
b: u8x16<Self>,
) -> (u8x16<Self>, u8x16<Self>);
fn select_u8x16(
self,
a: mask8x16<Self>,
b: u8x16<Self>,
c: u8x16<Self>,
) -> u8x16<Self>;
fn min_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn max_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
fn combine_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x32<Self>;
fn widen_u8x16(self, a: u8x16<Self>) -> u16x16<Self>;
fn reinterpret_u32_u8x16(self, a: u8x16<Self>) -> u32x4<Self>;
fn splat_mask8x16(self, val: i8) -> mask8x16<Self>;
fn load_array_mask8x16(self, val: [i8; 16]) -> mask8x16<Self>;
fn load_array_ref_mask8x16(self, val: &[i8; 16]) -> mask8x16<Self>;
fn as_array_mask8x16(self, a: mask8x16<Self>) -> [i8; 16];
fn as_array_ref_mask8x16(self, a: &mask8x16<Self>) -> &[i8; 16];
fn as_array_mut_mask8x16(self, a: &mut mask8x16<Self>) -> &mut [i8; 16];
fn store_array_mask8x16(self, a: mask8x16<Self>, dest: &mut [i8; 16]);
fn cvt_from_bytes_mask8x16(self, a: u8x16<Self>) -> mask8x16<Self>;
fn cvt_to_bytes_mask8x16(self, a: mask8x16<Self>) -> u8x16<Self>;
fn slide_mask8x16<const SHIFT: usize>(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x16<Self>;
fn slide_within_blocks_mask8x16<const SHIFT: usize>(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x16<Self>;
fn and_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x16<Self>;
fn or_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>;
fn xor_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x16<Self>;
fn not_mask8x16(self, a: mask8x16<Self>) -> mask8x16<Self>;
fn select_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
c: mask8x16<Self>,
) -> mask8x16<Self>;
fn simd_eq_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x16<Self>;
fn any_true_mask8x16(self, a: mask8x16<Self>) -> bool;
fn all_true_mask8x16(self, a: mask8x16<Self>) -> bool;
fn any_false_mask8x16(self, a: mask8x16<Self>) -> bool;
fn all_false_mask8x16(self, a: mask8x16<Self>) -> bool;
fn combine_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x32<Self>;
fn splat_i16x8(self, val: i16) -> i16x8<Self>;
fn load_array_i16x8(self, val: [i16; 8]) -> i16x8<Self>;
fn load_array_ref_i16x8(self, val: &[i16; 8]) -> i16x8<Self>;
fn as_array_i16x8(self, a: i16x8<Self>) -> [i16; 8];
fn as_array_ref_i16x8(self, a: &i16x8<Self>) -> &[i16; 8];
fn as_array_mut_i16x8(self, a: &mut i16x8<Self>) -> &mut [i16; 8];
fn store_array_i16x8(self, a: i16x8<Self>, dest: &mut [i16; 8]);
fn cvt_from_bytes_i16x8(self, a: u8x16<Self>) -> i16x8<Self>;
fn cvt_to_bytes_i16x8(self, a: i16x8<Self>) -> u8x16<Self>;
fn slide_i16x8<const SHIFT: usize>(
self,
a: i16x8<Self>,
b: i16x8<Self>,
) -> i16x8<Self>;
fn slide_within_blocks_i16x8<const SHIFT: usize>(
self,
a: i16x8<Self>,
b: i16x8<Self>,
) -> i16x8<Self>;
fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn and_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn or_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn xor_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn not_i16x8(self, a: i16x8<Self>) -> i16x8<Self>;
fn shl_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self>;
fn shlv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn shr_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self>;
fn shrv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn simd_eq_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>;
fn simd_lt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>;
fn simd_le_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>;
fn simd_ge_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>;
fn simd_gt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>;
fn zip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn zip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn unzip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn unzip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn interleave_i16x8(
self,
a: i16x8<Self>,
b: i16x8<Self>,
) -> (i16x8<Self>, i16x8<Self>);
fn deinterleave_i16x8(
self,
a: i16x8<Self>,
b: i16x8<Self>,
) -> (i16x8<Self>, i16x8<Self>);
fn select_i16x8(
self,
a: mask16x8<Self>,
b: i16x8<Self>,
c: i16x8<Self>,
) -> i16x8<Self>;
fn min_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn max_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
fn combine_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x16<Self>;
fn neg_i16x8(self, a: i16x8<Self>) -> i16x8<Self>;
fn reinterpret_u8_i16x8(self, a: i16x8<Self>) -> u8x16<Self>;
fn reinterpret_u32_i16x8(self, a: i16x8<Self>) -> u32x4<Self>;
fn splat_u16x8(self, val: u16) -> u16x8<Self>;
fn load_array_u16x8(self, val: [u16; 8]) -> u16x8<Self>;
fn load_array_ref_u16x8(self, val: &[u16; 8]) -> u16x8<Self>;
fn as_array_u16x8(self, a: u16x8<Self>) -> [u16; 8];
fn as_array_ref_u16x8(self, a: &u16x8<Self>) -> &[u16; 8];
fn as_array_mut_u16x8(self, a: &mut u16x8<Self>) -> &mut [u16; 8];
fn store_array_u16x8(self, a: u16x8<Self>, dest: &mut [u16; 8]);
fn cvt_from_bytes_u16x8(self, a: u8x16<Self>) -> u16x8<Self>;
fn cvt_to_bytes_u16x8(self, a: u16x8<Self>) -> u8x16<Self>;
fn slide_u16x8<const SHIFT: usize>(
self,
a: u16x8<Self>,
b: u16x8<Self>,
) -> u16x8<Self>;
fn slide_within_blocks_u16x8<const SHIFT: usize>(
self,
a: u16x8<Self>,
b: u16x8<Self>,
) -> u16x8<Self>;
fn add_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn sub_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn mul_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn and_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn or_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn xor_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn not_u16x8(self, a: u16x8<Self>) -> u16x8<Self>;
fn shl_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self>;
fn shlv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn shr_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self>;
fn shrv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn simd_eq_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>;
fn simd_lt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>;
fn simd_le_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>;
fn simd_ge_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>;
fn simd_gt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>;
fn zip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn zip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn unzip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn unzip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn interleave_u16x8(
self,
a: u16x8<Self>,
b: u16x8<Self>,
) -> (u16x8<Self>, u16x8<Self>);
fn deinterleave_u16x8(
self,
a: u16x8<Self>,
b: u16x8<Self>,
) -> (u16x8<Self>, u16x8<Self>);
fn select_u16x8(
self,
a: mask16x8<Self>,
b: u16x8<Self>,
c: u16x8<Self>,
) -> u16x8<Self>;
fn min_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn max_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
fn combine_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x16<Self>;
fn reinterpret_u8_u16x8(self, a: u16x8<Self>) -> u8x16<Self>;
fn reinterpret_u32_u16x8(self, a: u16x8<Self>) -> u32x4<Self>;
fn splat_mask16x8(self, val: i16) -> mask16x8<Self>;
fn load_array_mask16x8(self, val: [i16; 8]) -> mask16x8<Self>;
fn load_array_ref_mask16x8(self, val: &[i16; 8]) -> mask16x8<Self>;
fn as_array_mask16x8(self, a: mask16x8<Self>) -> [i16; 8];
fn as_array_ref_mask16x8(self, a: &mask16x8<Self>) -> &[i16; 8];
fn as_array_mut_mask16x8(self, a: &mut mask16x8<Self>) -> &mut [i16; 8];
fn store_array_mask16x8(self, a: mask16x8<Self>, dest: &mut [i16; 8]);
fn cvt_from_bytes_mask16x8(self, a: u8x16<Self>) -> mask16x8<Self>;
fn cvt_to_bytes_mask16x8(self, a: mask16x8<Self>) -> u8x16<Self>;
fn slide_mask16x8<const SHIFT: usize>(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x8<Self>;
fn slide_within_blocks_mask16x8<const SHIFT: usize>(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x8<Self>;
fn and_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x8<Self>;
fn or_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>;
fn xor_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x8<Self>;
fn not_mask16x8(self, a: mask16x8<Self>) -> mask16x8<Self>;
fn select_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
c: mask16x8<Self>,
) -> mask16x8<Self>;
fn simd_eq_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x8<Self>;
fn any_true_mask16x8(self, a: mask16x8<Self>) -> bool;
fn all_true_mask16x8(self, a: mask16x8<Self>) -> bool;
fn any_false_mask16x8(self, a: mask16x8<Self>) -> bool;
fn all_false_mask16x8(self, a: mask16x8<Self>) -> bool;
fn combine_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x16<Self>;
fn splat_i32x4(self, val: i32) -> i32x4<Self>;
fn load_array_i32x4(self, val: [i32; 4]) -> i32x4<Self>;
fn load_array_ref_i32x4(self, val: &[i32; 4]) -> i32x4<Self>;
fn as_array_i32x4(self, a: i32x4<Self>) -> [i32; 4];
fn as_array_ref_i32x4(self, a: &i32x4<Self>) -> &[i32; 4];
fn as_array_mut_i32x4(self, a: &mut i32x4<Self>) -> &mut [i32; 4];
fn store_array_i32x4(self, a: i32x4<Self>, dest: &mut [i32; 4]);
fn cvt_from_bytes_i32x4(self, a: u8x16<Self>) -> i32x4<Self>;
fn cvt_to_bytes_i32x4(self, a: i32x4<Self>) -> u8x16<Self>;
fn slide_i32x4<const SHIFT: usize>(
self,
a: i32x4<Self>,
b: i32x4<Self>,
) -> i32x4<Self>;
fn slide_within_blocks_i32x4<const SHIFT: usize>(
self,
a: i32x4<Self>,
b: i32x4<Self>,
) -> i32x4<Self>;
fn add_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn sub_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn mul_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn and_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn or_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn xor_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn not_i32x4(self, a: i32x4<Self>) -> i32x4<Self>;
fn shl_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self>;
fn shlv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn shr_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self>;
fn shrv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn simd_eq_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>;
fn simd_lt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>;
fn simd_le_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>;
fn simd_ge_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>;
fn simd_gt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>;
fn zip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn zip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn unzip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn unzip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn interleave_i32x4(
self,
a: i32x4<Self>,
b: i32x4<Self>,
) -> (i32x4<Self>, i32x4<Self>);
fn deinterleave_i32x4(
self,
a: i32x4<Self>,
b: i32x4<Self>,
) -> (i32x4<Self>, i32x4<Self>);
fn select_i32x4(
self,
a: mask32x4<Self>,
b: i32x4<Self>,
c: i32x4<Self>,
) -> i32x4<Self>;
fn min_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn max_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
fn combine_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x8<Self>;
fn neg_i32x4(self, a: i32x4<Self>) -> i32x4<Self>;
fn reinterpret_u8_i32x4(self, a: i32x4<Self>) -> u8x16<Self>;
fn reinterpret_u32_i32x4(self, a: i32x4<Self>) -> u32x4<Self>;
fn cvt_f32_i32x4(self, a: i32x4<Self>) -> f32x4<Self>;
fn splat_u32x4(self, val: u32) -> u32x4<Self>;
fn load_array_u32x4(self, val: [u32; 4]) -> u32x4<Self>;
fn load_array_ref_u32x4(self, val: &[u32; 4]) -> u32x4<Self>;
fn as_array_u32x4(self, a: u32x4<Self>) -> [u32; 4];
fn as_array_ref_u32x4(self, a: &u32x4<Self>) -> &[u32; 4];
fn as_array_mut_u32x4(self, a: &mut u32x4<Self>) -> &mut [u32; 4];
fn store_array_u32x4(self, a: u32x4<Self>, dest: &mut [u32; 4]);
fn cvt_from_bytes_u32x4(self, a: u8x16<Self>) -> u32x4<Self>;
fn cvt_to_bytes_u32x4(self, a: u32x4<Self>) -> u8x16<Self>;
fn slide_u32x4<const SHIFT: usize>(
self,
a: u32x4<Self>,
b: u32x4<Self>,
) -> u32x4<Self>;
fn slide_within_blocks_u32x4<const SHIFT: usize>(
self,
a: u32x4<Self>,
b: u32x4<Self>,
) -> u32x4<Self>;
fn add_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn sub_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn mul_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn and_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn or_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn xor_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn not_u32x4(self, a: u32x4<Self>) -> u32x4<Self>;
fn shl_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self>;
fn shlv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn shr_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self>;
fn shrv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn simd_eq_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>;
fn simd_lt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>;
fn simd_le_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>;
fn simd_ge_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>;
fn simd_gt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>;
fn zip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn zip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn unzip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn unzip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn interleave_u32x4(
self,
a: u32x4<Self>,
b: u32x4<Self>,
) -> (u32x4<Self>, u32x4<Self>);
fn deinterleave_u32x4(
self,
a: u32x4<Self>,
b: u32x4<Self>,
) -> (u32x4<Self>, u32x4<Self>);
fn select_u32x4(
self,
a: mask32x4<Self>,
b: u32x4<Self>,
c: u32x4<Self>,
) -> u32x4<Self>;
fn min_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn max_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
fn combine_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x8<Self>;
fn reinterpret_u8_u32x4(self, a: u32x4<Self>) -> u8x16<Self>;
fn cvt_f32_u32x4(self, a: u32x4<Self>) -> f32x4<Self>;
fn splat_mask32x4(self, val: i32) -> mask32x4<Self>;
fn load_array_mask32x4(self, val: [i32; 4]) -> mask32x4<Self>;
fn load_array_ref_mask32x4(self, val: &[i32; 4]) -> mask32x4<Self>;
fn as_array_mask32x4(self, a: mask32x4<Self>) -> [i32; 4];
fn as_array_ref_mask32x4(self, a: &mask32x4<Self>) -> &[i32; 4];
fn as_array_mut_mask32x4(self, a: &mut mask32x4<Self>) -> &mut [i32; 4];
fn store_array_mask32x4(self, a: mask32x4<Self>, dest: &mut [i32; 4]);
fn cvt_from_bytes_mask32x4(self, a: u8x16<Self>) -> mask32x4<Self>;
fn cvt_to_bytes_mask32x4(self, a: mask32x4<Self>) -> u8x16<Self>;
fn slide_mask32x4<const SHIFT: usize>(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x4<Self>;
fn slide_within_blocks_mask32x4<const SHIFT: usize>(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x4<Self>;
fn and_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x4<Self>;
fn or_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>;
fn xor_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x4<Self>;
fn not_mask32x4(self, a: mask32x4<Self>) -> mask32x4<Self>;
fn select_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
c: mask32x4<Self>,
) -> mask32x4<Self>;
fn simd_eq_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x4<Self>;
fn any_true_mask32x4(self, a: mask32x4<Self>) -> bool;
fn all_true_mask32x4(self, a: mask32x4<Self>) -> bool;
fn any_false_mask32x4(self, a: mask32x4<Self>) -> bool;
fn all_false_mask32x4(self, a: mask32x4<Self>) -> bool;
fn combine_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x8<Self>;
fn splat_f64x2(self, val: f64) -> f64x2<Self>;
fn load_array_f64x2(self, val: [f64; 2]) -> f64x2<Self>;
fn load_array_ref_f64x2(self, val: &[f64; 2]) -> f64x2<Self>;
fn as_array_f64x2(self, a: f64x2<Self>) -> [f64; 2];
fn as_array_ref_f64x2(self, a: &f64x2<Self>) -> &[f64; 2];
fn as_array_mut_f64x2(self, a: &mut f64x2<Self>) -> &mut [f64; 2];
fn store_array_f64x2(self, a: f64x2<Self>, dest: &mut [f64; 2]);
fn cvt_from_bytes_f64x2(self, a: u8x16<Self>) -> f64x2<Self>;
fn cvt_to_bytes_f64x2(self, a: f64x2<Self>) -> u8x16<Self>;
fn slide_f64x2<const SHIFT: usize>(
self,
a: f64x2<Self>,
b: f64x2<Self>,
) -> f64x2<Self>;
fn slide_within_blocks_f64x2<const SHIFT: usize>(
self,
a: f64x2<Self>,
b: f64x2<Self>,
) -> f64x2<Self>;
fn abs_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
fn neg_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
fn sqrt_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
fn add_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn sub_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn mul_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn div_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn copysign_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn simd_eq_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>;
fn simd_lt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>;
fn simd_le_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>;
fn simd_ge_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>;
fn simd_gt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>;
fn zip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn zip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn unzip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn unzip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn interleave_f64x2(
self,
a: f64x2<Self>,
b: f64x2<Self>,
) -> (f64x2<Self>, f64x2<Self>);
fn deinterleave_f64x2(
self,
a: f64x2<Self>,
b: f64x2<Self>,
) -> (f64x2<Self>, f64x2<Self>);
fn max_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn min_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn max_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn min_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>;
fn mul_add_f64x2(
self,
a: f64x2<Self>,
b: f64x2<Self>,
c: f64x2<Self>,
) -> f64x2<Self>;
fn mul_sub_f64x2(
self,
a: f64x2<Self>,
b: f64x2<Self>,
c: f64x2<Self>,
) -> f64x2<Self>;
fn floor_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
fn ceil_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
fn round_ties_even_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
fn fract_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
fn trunc_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
fn select_f64x2(
self,
a: mask64x2<Self>,
b: f64x2<Self>,
c: f64x2<Self>,
) -> f64x2<Self>;
fn combine_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x4<Self>;
fn reinterpret_f32_f64x2(self, a: f64x2<Self>) -> f32x4<Self>;
fn splat_mask64x2(self, val: i64) -> mask64x2<Self>;
fn load_array_mask64x2(self, val: [i64; 2]) -> mask64x2<Self>;
fn load_array_ref_mask64x2(self, val: &[i64; 2]) -> mask64x2<Self>;
fn as_array_mask64x2(self, a: mask64x2<Self>) -> [i64; 2];
fn as_array_ref_mask64x2(self, a: &mask64x2<Self>) -> &[i64; 2];
fn as_array_mut_mask64x2(self, a: &mut mask64x2<Self>) -> &mut [i64; 2];
fn store_array_mask64x2(self, a: mask64x2<Self>, dest: &mut [i64; 2]);
fn cvt_from_bytes_mask64x2(self, a: u8x16<Self>) -> mask64x2<Self>;
fn cvt_to_bytes_mask64x2(self, a: mask64x2<Self>) -> u8x16<Self>;
fn slide_mask64x2<const SHIFT: usize>(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x2<Self>;
fn slide_within_blocks_mask64x2<const SHIFT: usize>(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x2<Self>;
fn and_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x2<Self>;
fn or_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>;
fn xor_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x2<Self>;
fn not_mask64x2(self, a: mask64x2<Self>) -> mask64x2<Self>;
fn select_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
c: mask64x2<Self>,
) -> mask64x2<Self>;
fn simd_eq_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x2<Self>;
fn any_true_mask64x2(self, a: mask64x2<Self>) -> bool;
fn all_true_mask64x2(self, a: mask64x2<Self>) -> bool;
fn any_false_mask64x2(self, a: mask64x2<Self>) -> bool;
fn all_false_mask64x2(self, a: mask64x2<Self>) -> bool;
fn combine_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x4<Self>;
fn splat_f32x8(self, val: f32) -> f32x8<Self>;
fn load_array_f32x8(self, val: [f32; 8]) -> f32x8<Self>;
fn load_array_ref_f32x8(self, val: &[f32; 8]) -> f32x8<Self>;
fn as_array_f32x8(self, a: f32x8<Self>) -> [f32; 8];
fn as_array_ref_f32x8(self, a: &f32x8<Self>) -> &[f32; 8];
fn as_array_mut_f32x8(self, a: &mut f32x8<Self>) -> &mut [f32; 8];
fn store_array_f32x8(self, a: f32x8<Self>, dest: &mut [f32; 8]);
fn cvt_from_bytes_f32x8(self, a: u8x32<Self>) -> f32x8<Self>;
fn cvt_to_bytes_f32x8(self, a: f32x8<Self>) -> u8x32<Self>;
fn slide_f32x8<const SHIFT: usize>(
self,
a: f32x8<Self>,
b: f32x8<Self>,
) -> f32x8<Self>;
fn slide_within_blocks_f32x8<const SHIFT: usize>(
self,
a: f32x8<Self>,
b: f32x8<Self>,
) -> f32x8<Self>;
fn abs_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
fn neg_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
fn sqrt_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
fn add_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn sub_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn mul_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn div_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn copysign_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn simd_eq_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>;
fn simd_lt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>;
fn simd_le_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>;
fn simd_ge_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>;
fn simd_gt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>;
fn zip_low_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn zip_high_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn unzip_low_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn unzip_high_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn interleave_f32x8(
self,
a: f32x8<Self>,
b: f32x8<Self>,
) -> (f32x8<Self>, f32x8<Self>);
fn deinterleave_f32x8(
self,
a: f32x8<Self>,
b: f32x8<Self>,
) -> (f32x8<Self>, f32x8<Self>);
fn max_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn min_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn max_precise_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn min_precise_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>;
fn mul_add_f32x8(
self,
a: f32x8<Self>,
b: f32x8<Self>,
c: f32x8<Self>,
) -> f32x8<Self>;
fn mul_sub_f32x8(
self,
a: f32x8<Self>,
b: f32x8<Self>,
c: f32x8<Self>,
) -> f32x8<Self>;
fn floor_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
fn ceil_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
fn round_ties_even_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
fn fract_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
fn trunc_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
fn select_f32x8(
self,
a: mask32x8<Self>,
b: f32x8<Self>,
c: f32x8<Self>,
) -> f32x8<Self>;
fn combine_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x16<Self>;
fn split_f32x8(self, a: f32x8<Self>) -> (f32x4<Self>, f32x4<Self>);
fn reinterpret_f64_f32x8(self, a: f32x8<Self>) -> f64x4<Self>;
fn reinterpret_i32_f32x8(self, a: f32x8<Self>) -> i32x8<Self>;
fn reinterpret_u8_f32x8(self, a: f32x8<Self>) -> u8x32<Self>;
fn reinterpret_u32_f32x8(self, a: f32x8<Self>) -> u32x8<Self>;
fn cvt_u32_f32x8(self, a: f32x8<Self>) -> u32x8<Self>;
fn cvt_u32_precise_f32x8(self, a: f32x8<Self>) -> u32x8<Self>;
fn cvt_i32_f32x8(self, a: f32x8<Self>) -> i32x8<Self>;
fn cvt_i32_precise_f32x8(self, a: f32x8<Self>) -> i32x8<Self>;
fn splat_i8x32(self, val: i8) -> i8x32<Self>;
fn load_array_i8x32(self, val: [i8; 32]) -> i8x32<Self>;
fn load_array_ref_i8x32(self, val: &[i8; 32]) -> i8x32<Self>;
fn as_array_i8x32(self, a: i8x32<Self>) -> [i8; 32];
fn as_array_ref_i8x32(self, a: &i8x32<Self>) -> &[i8; 32];
fn as_array_mut_i8x32(self, a: &mut i8x32<Self>) -> &mut [i8; 32];
fn store_array_i8x32(self, a: i8x32<Self>, dest: &mut [i8; 32]);
fn cvt_from_bytes_i8x32(self, a: u8x32<Self>) -> i8x32<Self>;
fn cvt_to_bytes_i8x32(self, a: i8x32<Self>) -> u8x32<Self>;
fn slide_i8x32<const SHIFT: usize>(
self,
a: i8x32<Self>,
b: i8x32<Self>,
) -> i8x32<Self>;
fn slide_within_blocks_i8x32<const SHIFT: usize>(
self,
a: i8x32<Self>,
b: i8x32<Self>,
) -> i8x32<Self>;
fn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn mul_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn and_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn or_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn xor_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn not_i8x32(self, a: i8x32<Self>) -> i8x32<Self>;
fn shl_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self>;
fn shlv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn shr_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self>;
fn shrv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn simd_eq_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>;
fn simd_lt_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>;
fn simd_le_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>;
fn simd_ge_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>;
fn simd_gt_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>;
fn zip_low_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn zip_high_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn unzip_low_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn unzip_high_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn interleave_i8x32(
self,
a: i8x32<Self>,
b: i8x32<Self>,
) -> (i8x32<Self>, i8x32<Self>);
fn deinterleave_i8x32(
self,
a: i8x32<Self>,
b: i8x32<Self>,
) -> (i8x32<Self>, i8x32<Self>);
fn select_i8x32(
self,
a: mask8x32<Self>,
b: i8x32<Self>,
c: i8x32<Self>,
) -> i8x32<Self>;
fn min_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn max_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
fn combine_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x64<Self>;
fn split_i8x32(self, a: i8x32<Self>) -> (i8x16<Self>, i8x16<Self>);
fn neg_i8x32(self, a: i8x32<Self>) -> i8x32<Self>;
fn reinterpret_u8_i8x32(self, a: i8x32<Self>) -> u8x32<Self>;
fn reinterpret_u32_i8x32(self, a: i8x32<Self>) -> u32x8<Self>;
fn splat_u8x32(self, val: u8) -> u8x32<Self>;
fn load_array_u8x32(self, val: [u8; 32]) -> u8x32<Self>;
fn load_array_ref_u8x32(self, val: &[u8; 32]) -> u8x32<Self>;
fn as_array_u8x32(self, a: u8x32<Self>) -> [u8; 32];
fn as_array_ref_u8x32(self, a: &u8x32<Self>) -> &[u8; 32];
fn as_array_mut_u8x32(self, a: &mut u8x32<Self>) -> &mut [u8; 32];
fn store_array_u8x32(self, a: u8x32<Self>, dest: &mut [u8; 32]);
fn cvt_from_bytes_u8x32(self, a: u8x32<Self>) -> u8x32<Self>;
fn cvt_to_bytes_u8x32(self, a: u8x32<Self>) -> u8x32<Self>;
fn slide_u8x32<const SHIFT: usize>(
self,
a: u8x32<Self>,
b: u8x32<Self>,
) -> u8x32<Self>;
fn slide_within_blocks_u8x32<const SHIFT: usize>(
self,
a: u8x32<Self>,
b: u8x32<Self>,
) -> u8x32<Self>;
fn add_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn sub_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn mul_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn and_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn or_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn xor_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn not_u8x32(self, a: u8x32<Self>) -> u8x32<Self>;
fn shl_u8x32(self, a: u8x32<Self>, shift: u32) -> u8x32<Self>;
fn shlv_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn shr_u8x32(self, a: u8x32<Self>, shift: u32) -> u8x32<Self>;
fn shrv_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn simd_eq_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>;
fn simd_lt_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>;
fn simd_le_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>;
fn simd_ge_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>;
fn simd_gt_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>;
fn zip_low_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn zip_high_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn unzip_low_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn unzip_high_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn interleave_u8x32(
self,
a: u8x32<Self>,
b: u8x32<Self>,
) -> (u8x32<Self>, u8x32<Self>);
fn deinterleave_u8x32(
self,
a: u8x32<Self>,
b: u8x32<Self>,
) -> (u8x32<Self>, u8x32<Self>);
fn select_u8x32(
self,
a: mask8x32<Self>,
b: u8x32<Self>,
c: u8x32<Self>,
) -> u8x32<Self>;
fn min_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn max_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
fn combine_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x64<Self>;
fn split_u8x32(self, a: u8x32<Self>) -> (u8x16<Self>, u8x16<Self>);
fn widen_u8x32(self, a: u8x32<Self>) -> u16x32<Self>;
fn reinterpret_u32_u8x32(self, a: u8x32<Self>) -> u32x8<Self>;
fn splat_mask8x32(self, val: i8) -> mask8x32<Self>;
fn load_array_mask8x32(self, val: [i8; 32]) -> mask8x32<Self>;
fn load_array_ref_mask8x32(self, val: &[i8; 32]) -> mask8x32<Self>;
fn as_array_mask8x32(self, a: mask8x32<Self>) -> [i8; 32];
fn as_array_ref_mask8x32(self, a: &mask8x32<Self>) -> &[i8; 32];
fn as_array_mut_mask8x32(self, a: &mut mask8x32<Self>) -> &mut [i8; 32];
fn store_array_mask8x32(self, a: mask8x32<Self>, dest: &mut [i8; 32]);
fn cvt_from_bytes_mask8x32(self, a: u8x32<Self>) -> mask8x32<Self>;
fn cvt_to_bytes_mask8x32(self, a: mask8x32<Self>) -> u8x32<Self>;
fn slide_mask8x32<const SHIFT: usize>(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x32<Self>;
fn slide_within_blocks_mask8x32<const SHIFT: usize>(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x32<Self>;
fn and_mask8x32(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x32<Self>;
fn or_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>;
fn xor_mask8x32(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x32<Self>;
fn not_mask8x32(self, a: mask8x32<Self>) -> mask8x32<Self>;
fn select_mask8x32(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
c: mask8x32<Self>,
) -> mask8x32<Self>;
fn simd_eq_mask8x32(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x32<Self>;
fn any_true_mask8x32(self, a: mask8x32<Self>) -> bool;
fn all_true_mask8x32(self, a: mask8x32<Self>) -> bool;
fn any_false_mask8x32(self, a: mask8x32<Self>) -> bool;
fn all_false_mask8x32(self, a: mask8x32<Self>) -> bool;
fn combine_mask8x32(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x64<Self>;
fn split_mask8x32(
self,
a: mask8x32<Self>,
) -> (mask8x16<Self>, mask8x16<Self>);
fn splat_i16x16(self, val: i16) -> i16x16<Self>;
fn load_array_i16x16(self, val: [i16; 16]) -> i16x16<Self>;
fn load_array_ref_i16x16(self, val: &[i16; 16]) -> i16x16<Self>;
fn as_array_i16x16(self, a: i16x16<Self>) -> [i16; 16];
fn as_array_ref_i16x16(self, a: &i16x16<Self>) -> &[i16; 16];
fn as_array_mut_i16x16(self, a: &mut i16x16<Self>) -> &mut [i16; 16];
fn store_array_i16x16(self, a: i16x16<Self>, dest: &mut [i16; 16]);
fn cvt_from_bytes_i16x16(self, a: u8x32<Self>) -> i16x16<Self>;
fn cvt_to_bytes_i16x16(self, a: i16x16<Self>) -> u8x32<Self>;
fn slide_i16x16<const SHIFT: usize>(
self,
a: i16x16<Self>,
b: i16x16<Self>,
) -> i16x16<Self>;
fn slide_within_blocks_i16x16<const SHIFT: usize>(
self,
a: i16x16<Self>,
b: i16x16<Self>,
) -> i16x16<Self>;
fn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn mul_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn and_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn or_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn xor_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn not_i16x16(self, a: i16x16<Self>) -> i16x16<Self>;
fn shl_i16x16(self, a: i16x16<Self>, shift: u32) -> i16x16<Self>;
fn shlv_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn shr_i16x16(self, a: i16x16<Self>, shift: u32) -> i16x16<Self>;
fn shrv_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn simd_eq_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>;
fn simd_lt_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>;
fn simd_le_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>;
fn simd_ge_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>;
fn simd_gt_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>;
fn zip_low_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn zip_high_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn unzip_low_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn unzip_high_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn interleave_i16x16(
self,
a: i16x16<Self>,
b: i16x16<Self>,
) -> (i16x16<Self>, i16x16<Self>);
fn deinterleave_i16x16(
self,
a: i16x16<Self>,
b: i16x16<Self>,
) -> (i16x16<Self>, i16x16<Self>);
fn select_i16x16(
self,
a: mask16x16<Self>,
b: i16x16<Self>,
c: i16x16<Self>,
) -> i16x16<Self>;
fn min_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn max_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
fn combine_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x32<Self>;
fn split_i16x16(self, a: i16x16<Self>) -> (i16x8<Self>, i16x8<Self>);
fn neg_i16x16(self, a: i16x16<Self>) -> i16x16<Self>;
fn reinterpret_u8_i16x16(self, a: i16x16<Self>) -> u8x32<Self>;
fn reinterpret_u32_i16x16(self, a: i16x16<Self>) -> u32x8<Self>;
fn splat_u16x16(self, val: u16) -> u16x16<Self>;
fn load_array_u16x16(self, val: [u16; 16]) -> u16x16<Self>;
fn load_array_ref_u16x16(self, val: &[u16; 16]) -> u16x16<Self>;
fn as_array_u16x16(self, a: u16x16<Self>) -> [u16; 16];
fn as_array_ref_u16x16(self, a: &u16x16<Self>) -> &[u16; 16];
fn as_array_mut_u16x16(self, a: &mut u16x16<Self>) -> &mut [u16; 16];
fn store_array_u16x16(self, a: u16x16<Self>, dest: &mut [u16; 16]);
fn cvt_from_bytes_u16x16(self, a: u8x32<Self>) -> u16x16<Self>;
fn cvt_to_bytes_u16x16(self, a: u16x16<Self>) -> u8x32<Self>;
fn slide_u16x16<const SHIFT: usize>(
self,
a: u16x16<Self>,
b: u16x16<Self>,
) -> u16x16<Self>;
fn slide_within_blocks_u16x16<const SHIFT: usize>(
self,
a: u16x16<Self>,
b: u16x16<Self>,
) -> u16x16<Self>;
fn add_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn sub_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn mul_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn and_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn or_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn xor_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn not_u16x16(self, a: u16x16<Self>) -> u16x16<Self>;
fn shl_u16x16(self, a: u16x16<Self>, shift: u32) -> u16x16<Self>;
fn shlv_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn shr_u16x16(self, a: u16x16<Self>, shift: u32) -> u16x16<Self>;
fn shrv_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn simd_eq_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>;
fn simd_lt_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>;
fn simd_le_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>;
fn simd_ge_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>;
fn simd_gt_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>;
fn zip_low_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn zip_high_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn unzip_low_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn unzip_high_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn interleave_u16x16(
self,
a: u16x16<Self>,
b: u16x16<Self>,
) -> (u16x16<Self>, u16x16<Self>);
fn deinterleave_u16x16(
self,
a: u16x16<Self>,
b: u16x16<Self>,
) -> (u16x16<Self>, u16x16<Self>);
fn select_u16x16(
self,
a: mask16x16<Self>,
b: u16x16<Self>,
c: u16x16<Self>,
) -> u16x16<Self>;
fn min_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn max_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
fn combine_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x32<Self>;
fn split_u16x16(self, a: u16x16<Self>) -> (u16x8<Self>, u16x8<Self>);
fn narrow_u16x16(self, a: u16x16<Self>) -> u8x16<Self>;
fn reinterpret_u8_u16x16(self, a: u16x16<Self>) -> u8x32<Self>;
fn reinterpret_u32_u16x16(self, a: u16x16<Self>) -> u32x8<Self>;
fn splat_mask16x16(self, val: i16) -> mask16x16<Self>;
fn load_array_mask16x16(self, val: [i16; 16]) -> mask16x16<Self>;
fn load_array_ref_mask16x16(self, val: &[i16; 16]) -> mask16x16<Self>;
fn as_array_mask16x16(self, a: mask16x16<Self>) -> [i16; 16];
fn as_array_ref_mask16x16(self, a: &mask16x16<Self>) -> &[i16; 16];
fn as_array_mut_mask16x16(self, a: &mut mask16x16<Self>) -> &mut [i16; 16];
fn store_array_mask16x16(self, a: mask16x16<Self>, dest: &mut [i16; 16]);
fn cvt_from_bytes_mask16x16(self, a: u8x32<Self>) -> mask16x16<Self>;
fn cvt_to_bytes_mask16x16(self, a: mask16x16<Self>) -> u8x32<Self>;
fn slide_mask16x16<const SHIFT: usize>(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>;
fn slide_within_blocks_mask16x16<const SHIFT: usize>(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>;
fn and_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>;
fn or_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>;
fn xor_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>;
fn not_mask16x16(self, a: mask16x16<Self>) -> mask16x16<Self>;
fn select_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
c: mask16x16<Self>,
) -> mask16x16<Self>;
fn simd_eq_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>;
fn any_true_mask16x16(self, a: mask16x16<Self>) -> bool;
fn all_true_mask16x16(self, a: mask16x16<Self>) -> bool;
fn any_false_mask16x16(self, a: mask16x16<Self>) -> bool;
fn all_false_mask16x16(self, a: mask16x16<Self>) -> bool;
fn combine_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x32<Self>;
fn split_mask16x16(
self,
a: mask16x16<Self>,
) -> (mask16x8<Self>, mask16x8<Self>);
fn splat_i32x8(self, val: i32) -> i32x8<Self>;
fn load_array_i32x8(self, val: [i32; 8]) -> i32x8<Self>;
fn load_array_ref_i32x8(self, val: &[i32; 8]) -> i32x8<Self>;
fn as_array_i32x8(self, a: i32x8<Self>) -> [i32; 8];
fn as_array_ref_i32x8(self, a: &i32x8<Self>) -> &[i32; 8];
fn as_array_mut_i32x8(self, a: &mut i32x8<Self>) -> &mut [i32; 8];
fn store_array_i32x8(self, a: i32x8<Self>, dest: &mut [i32; 8]);
fn cvt_from_bytes_i32x8(self, a: u8x32<Self>) -> i32x8<Self>;
fn cvt_to_bytes_i32x8(self, a: i32x8<Self>) -> u8x32<Self>;
fn slide_i32x8<const SHIFT: usize>(
self,
a: i32x8<Self>,
b: i32x8<Self>,
) -> i32x8<Self>;
fn slide_within_blocks_i32x8<const SHIFT: usize>(
self,
a: i32x8<Self>,
b: i32x8<Self>,
) -> i32x8<Self>;
fn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn mul_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn and_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn or_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn xor_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn not_i32x8(self, a: i32x8<Self>) -> i32x8<Self>;
fn shl_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self>;
fn shlv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn shr_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self>;
fn shrv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn simd_eq_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>;
fn simd_lt_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>;
fn simd_le_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>;
fn simd_ge_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>;
fn simd_gt_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>;
fn zip_low_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn zip_high_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn unzip_low_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn unzip_high_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn interleave_i32x8(
self,
a: i32x8<Self>,
b: i32x8<Self>,
) -> (i32x8<Self>, i32x8<Self>);
fn deinterleave_i32x8(
self,
a: i32x8<Self>,
b: i32x8<Self>,
) -> (i32x8<Self>, i32x8<Self>);
fn select_i32x8(
self,
a: mask32x8<Self>,
b: i32x8<Self>,
c: i32x8<Self>,
) -> i32x8<Self>;
fn min_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn max_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
fn combine_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x16<Self>;
fn split_i32x8(self, a: i32x8<Self>) -> (i32x4<Self>, i32x4<Self>);
fn neg_i32x8(self, a: i32x8<Self>) -> i32x8<Self>;
fn reinterpret_u8_i32x8(self, a: i32x8<Self>) -> u8x32<Self>;
fn reinterpret_u32_i32x8(self, a: i32x8<Self>) -> u32x8<Self>;
fn cvt_f32_i32x8(self, a: i32x8<Self>) -> f32x8<Self>;
fn splat_u32x8(self, val: u32) -> u32x8<Self>;
fn load_array_u32x8(self, val: [u32; 8]) -> u32x8<Self>;
fn load_array_ref_u32x8(self, val: &[u32; 8]) -> u32x8<Self>;
fn as_array_u32x8(self, a: u32x8<Self>) -> [u32; 8];
fn as_array_ref_u32x8(self, a: &u32x8<Self>) -> &[u32; 8];
fn as_array_mut_u32x8(self, a: &mut u32x8<Self>) -> &mut [u32; 8];
fn store_array_u32x8(self, a: u32x8<Self>, dest: &mut [u32; 8]);
fn cvt_from_bytes_u32x8(self, a: u8x32<Self>) -> u32x8<Self>;
fn cvt_to_bytes_u32x8(self, a: u32x8<Self>) -> u8x32<Self>;
fn slide_u32x8<const SHIFT: usize>(
self,
a: u32x8<Self>,
b: u32x8<Self>,
) -> u32x8<Self>;
fn slide_within_blocks_u32x8<const SHIFT: usize>(
self,
a: u32x8<Self>,
b: u32x8<Self>,
) -> u32x8<Self>;
fn add_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn sub_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn mul_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn and_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn or_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn xor_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn not_u32x8(self, a: u32x8<Self>) -> u32x8<Self>;
fn shl_u32x8(self, a: u32x8<Self>, shift: u32) -> u32x8<Self>;
fn shlv_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn shr_u32x8(self, a: u32x8<Self>, shift: u32) -> u32x8<Self>;
fn shrv_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn simd_eq_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>;
fn simd_lt_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>;
fn simd_le_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>;
fn simd_ge_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>;
fn simd_gt_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>;
fn zip_low_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn zip_high_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn unzip_low_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn unzip_high_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn interleave_u32x8(
self,
a: u32x8<Self>,
b: u32x8<Self>,
) -> (u32x8<Self>, u32x8<Self>);
fn deinterleave_u32x8(
self,
a: u32x8<Self>,
b: u32x8<Self>,
) -> (u32x8<Self>, u32x8<Self>);
fn select_u32x8(
self,
a: mask32x8<Self>,
b: u32x8<Self>,
c: u32x8<Self>,
) -> u32x8<Self>;
fn min_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn max_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
fn combine_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x16<Self>;
fn split_u32x8(self, a: u32x8<Self>) -> (u32x4<Self>, u32x4<Self>);
fn reinterpret_u8_u32x8(self, a: u32x8<Self>) -> u8x32<Self>;
fn cvt_f32_u32x8(self, a: u32x8<Self>) -> f32x8<Self>;
fn splat_mask32x8(self, val: i32) -> mask32x8<Self>;
fn load_array_mask32x8(self, val: [i32; 8]) -> mask32x8<Self>;
fn load_array_ref_mask32x8(self, val: &[i32; 8]) -> mask32x8<Self>;
fn as_array_mask32x8(self, a: mask32x8<Self>) -> [i32; 8];
fn as_array_ref_mask32x8(self, a: &mask32x8<Self>) -> &[i32; 8];
fn as_array_mut_mask32x8(self, a: &mut mask32x8<Self>) -> &mut [i32; 8];
fn store_array_mask32x8(self, a: mask32x8<Self>, dest: &mut [i32; 8]);
fn cvt_from_bytes_mask32x8(self, a: u8x32<Self>) -> mask32x8<Self>;
fn cvt_to_bytes_mask32x8(self, a: mask32x8<Self>) -> u8x32<Self>;
fn slide_mask32x8<const SHIFT: usize>(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x8<Self>;
fn slide_within_blocks_mask32x8<const SHIFT: usize>(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x8<Self>;
fn and_mask32x8(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x8<Self>;
fn or_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>;
fn xor_mask32x8(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x8<Self>;
fn not_mask32x8(self, a: mask32x8<Self>) -> mask32x8<Self>;
fn select_mask32x8(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
c: mask32x8<Self>,
) -> mask32x8<Self>;
fn simd_eq_mask32x8(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x8<Self>;
fn any_true_mask32x8(self, a: mask32x8<Self>) -> bool;
fn all_true_mask32x8(self, a: mask32x8<Self>) -> bool;
fn any_false_mask32x8(self, a: mask32x8<Self>) -> bool;
fn all_false_mask32x8(self, a: mask32x8<Self>) -> bool;
fn combine_mask32x8(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x16<Self>;
fn split_mask32x8(
self,
a: mask32x8<Self>,
) -> (mask32x4<Self>, mask32x4<Self>);
fn splat_f64x4(self, val: f64) -> f64x4<Self>;
fn load_array_f64x4(self, val: [f64; 4]) -> f64x4<Self>;
fn load_array_ref_f64x4(self, val: &[f64; 4]) -> f64x4<Self>;
fn as_array_f64x4(self, a: f64x4<Self>) -> [f64; 4];
fn as_array_ref_f64x4(self, a: &f64x4<Self>) -> &[f64; 4];
fn as_array_mut_f64x4(self, a: &mut f64x4<Self>) -> &mut [f64; 4];
fn store_array_f64x4(self, a: f64x4<Self>, dest: &mut [f64; 4]);
fn cvt_from_bytes_f64x4(self, a: u8x32<Self>) -> f64x4<Self>;
fn cvt_to_bytes_f64x4(self, a: f64x4<Self>) -> u8x32<Self>;
fn slide_f64x4<const SHIFT: usize>(
self,
a: f64x4<Self>,
b: f64x4<Self>,
) -> f64x4<Self>;
fn slide_within_blocks_f64x4<const SHIFT: usize>(
self,
a: f64x4<Self>,
b: f64x4<Self>,
) -> f64x4<Self>;
fn abs_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
fn neg_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
fn sqrt_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
fn add_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn sub_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn mul_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn div_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn copysign_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn simd_eq_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>;
fn simd_lt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>;
fn simd_le_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>;
fn simd_ge_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>;
fn simd_gt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>;
fn zip_low_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn zip_high_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn unzip_low_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn unzip_high_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn interleave_f64x4(
self,
a: f64x4<Self>,
b: f64x4<Self>,
) -> (f64x4<Self>, f64x4<Self>);
fn deinterleave_f64x4(
self,
a: f64x4<Self>,
b: f64x4<Self>,
) -> (f64x4<Self>, f64x4<Self>);
fn max_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn min_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn max_precise_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn min_precise_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>;
fn mul_add_f64x4(
self,
a: f64x4<Self>,
b: f64x4<Self>,
c: f64x4<Self>,
) -> f64x4<Self>;
fn mul_sub_f64x4(
self,
a: f64x4<Self>,
b: f64x4<Self>,
c: f64x4<Self>,
) -> f64x4<Self>;
fn floor_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
fn ceil_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
fn round_ties_even_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
fn fract_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
fn trunc_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
fn select_f64x4(
self,
a: mask64x4<Self>,
b: f64x4<Self>,
c: f64x4<Self>,
) -> f64x4<Self>;
fn combine_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x8<Self>;
fn split_f64x4(self, a: f64x4<Self>) -> (f64x2<Self>, f64x2<Self>);
fn reinterpret_f32_f64x4(self, a: f64x4<Self>) -> f32x8<Self>;
fn splat_mask64x4(self, val: i64) -> mask64x4<Self>;
fn load_array_mask64x4(self, val: [i64; 4]) -> mask64x4<Self>;
fn load_array_ref_mask64x4(self, val: &[i64; 4]) -> mask64x4<Self>;
fn as_array_mask64x4(self, a: mask64x4<Self>) -> [i64; 4];
fn as_array_ref_mask64x4(self, a: &mask64x4<Self>) -> &[i64; 4];
fn as_array_mut_mask64x4(self, a: &mut mask64x4<Self>) -> &mut [i64; 4];
fn store_array_mask64x4(self, a: mask64x4<Self>, dest: &mut [i64; 4]);
fn cvt_from_bytes_mask64x4(self, a: u8x32<Self>) -> mask64x4<Self>;
fn cvt_to_bytes_mask64x4(self, a: mask64x4<Self>) -> u8x32<Self>;
fn slide_mask64x4<const SHIFT: usize>(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x4<Self>;
fn slide_within_blocks_mask64x4<const SHIFT: usize>(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x4<Self>;
fn and_mask64x4(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x4<Self>;
fn or_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>;
fn xor_mask64x4(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x4<Self>;
fn not_mask64x4(self, a: mask64x4<Self>) -> mask64x4<Self>;
fn select_mask64x4(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
c: mask64x4<Self>,
) -> mask64x4<Self>;
fn simd_eq_mask64x4(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x4<Self>;
fn any_true_mask64x4(self, a: mask64x4<Self>) -> bool;
fn all_true_mask64x4(self, a: mask64x4<Self>) -> bool;
fn any_false_mask64x4(self, a: mask64x4<Self>) -> bool;
fn all_false_mask64x4(self, a: mask64x4<Self>) -> bool;
fn combine_mask64x4(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x8<Self>;
fn split_mask64x4(
self,
a: mask64x4<Self>,
) -> (mask64x2<Self>, mask64x2<Self>);
fn splat_f32x16(self, val: f32) -> f32x16<Self>;
fn load_array_f32x16(self, val: [f32; 16]) -> f32x16<Self>;
fn load_array_ref_f32x16(self, val: &[f32; 16]) -> f32x16<Self>;
fn as_array_f32x16(self, a: f32x16<Self>) -> [f32; 16];
fn as_array_ref_f32x16(self, a: &f32x16<Self>) -> &[f32; 16];
fn as_array_mut_f32x16(self, a: &mut f32x16<Self>) -> &mut [f32; 16];
fn store_array_f32x16(self, a: f32x16<Self>, dest: &mut [f32; 16]);
fn cvt_from_bytes_f32x16(self, a: u8x64<Self>) -> f32x16<Self>;
fn cvt_to_bytes_f32x16(self, a: f32x16<Self>) -> u8x64<Self>;
fn slide_f32x16<const SHIFT: usize>(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> f32x16<Self>;
fn slide_within_blocks_f32x16<const SHIFT: usize>(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> f32x16<Self>;
fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>;
fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>;
fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>;
fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>;
fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>;
fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn unzip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn interleave_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> (f32x16<Self>, f32x16<Self>);
fn deinterleave_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> (f32x16<Self>, f32x16<Self>);
fn max_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn min_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>;
fn max_precise_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> f32x16<Self>;
fn min_precise_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> f32x16<Self>;
fn mul_add_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
c: f32x16<Self>,
) -> f32x16<Self>;
fn mul_sub_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
c: f32x16<Self>,
) -> f32x16<Self>;
fn floor_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
fn ceil_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
fn round_ties_even_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
fn fract_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
fn trunc_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
fn select_f32x16(
self,
a: mask32x16<Self>,
b: f32x16<Self>,
c: f32x16<Self>,
) -> f32x16<Self>;
fn split_f32x16(self, a: f32x16<Self>) -> (f32x8<Self>, f32x8<Self>);
fn reinterpret_f64_f32x16(self, a: f32x16<Self>) -> f64x8<Self>;
fn reinterpret_i32_f32x16(self, a: f32x16<Self>) -> i32x16<Self>;
fn load_interleaved_128_f32x16(self, src: &[f32; 16]) -> f32x16<Self>;
fn store_interleaved_128_f32x16(self, a: f32x16<Self>, dest: &mut [f32; 16]);
fn reinterpret_u8_f32x16(self, a: f32x16<Self>) -> u8x64<Self>;
fn reinterpret_u32_f32x16(self, a: f32x16<Self>) -> u32x16<Self>;
fn cvt_u32_f32x16(self, a: f32x16<Self>) -> u32x16<Self>;
fn cvt_u32_precise_f32x16(self, a: f32x16<Self>) -> u32x16<Self>;
fn cvt_i32_f32x16(self, a: f32x16<Self>) -> i32x16<Self>;
fn cvt_i32_precise_f32x16(self, a: f32x16<Self>) -> i32x16<Self>;
fn splat_i8x64(self, val: i8) -> i8x64<Self>;
fn load_array_i8x64(self, val: [i8; 64]) -> i8x64<Self>;
fn load_array_ref_i8x64(self, val: &[i8; 64]) -> i8x64<Self>;
fn as_array_i8x64(self, a: i8x64<Self>) -> [i8; 64];
fn as_array_ref_i8x64(self, a: &i8x64<Self>) -> &[i8; 64];
fn as_array_mut_i8x64(self, a: &mut i8x64<Self>) -> &mut [i8; 64];
fn store_array_i8x64(self, a: i8x64<Self>, dest: &mut [i8; 64]);
fn cvt_from_bytes_i8x64(self, a: u8x64<Self>) -> i8x64<Self>;
fn cvt_to_bytes_i8x64(self, a: i8x64<Self>) -> u8x64<Self>;
fn slide_i8x64<const SHIFT: usize>(
self,
a: i8x64<Self>,
b: i8x64<Self>,
) -> i8x64<Self>;
fn slide_within_blocks_i8x64<const SHIFT: usize>(
self,
a: i8x64<Self>,
b: i8x64<Self>,
) -> i8x64<Self>;
fn add_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn sub_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn mul_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn and_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn or_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn xor_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn not_i8x64(self, a: i8x64<Self>) -> i8x64<Self>;
fn shl_i8x64(self, a: i8x64<Self>, shift: u32) -> i8x64<Self>;
fn shlv_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn shr_i8x64(self, a: i8x64<Self>, shift: u32) -> i8x64<Self>;
fn shrv_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn simd_eq_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>;
fn simd_lt_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>;
fn simd_le_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>;
fn simd_ge_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>;
fn simd_gt_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>;
fn zip_low_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn zip_high_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn unzip_low_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn unzip_high_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn interleave_i8x64(
self,
a: i8x64<Self>,
b: i8x64<Self>,
) -> (i8x64<Self>, i8x64<Self>);
fn deinterleave_i8x64(
self,
a: i8x64<Self>,
b: i8x64<Self>,
) -> (i8x64<Self>, i8x64<Self>);
fn select_i8x64(
self,
a: mask8x64<Self>,
b: i8x64<Self>,
c: i8x64<Self>,
) -> i8x64<Self>;
fn min_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn max_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
fn split_i8x64(self, a: i8x64<Self>) -> (i8x32<Self>, i8x32<Self>);
fn neg_i8x64(self, a: i8x64<Self>) -> i8x64<Self>;
fn reinterpret_u8_i8x64(self, a: i8x64<Self>) -> u8x64<Self>;
fn reinterpret_u32_i8x64(self, a: i8x64<Self>) -> u32x16<Self>;
fn splat_u8x64(self, val: u8) -> u8x64<Self>;
fn load_array_u8x64(self, val: [u8; 64]) -> u8x64<Self>;
fn load_array_ref_u8x64(self, val: &[u8; 64]) -> u8x64<Self>;
fn as_array_u8x64(self, a: u8x64<Self>) -> [u8; 64];
fn as_array_ref_u8x64(self, a: &u8x64<Self>) -> &[u8; 64];
fn as_array_mut_u8x64(self, a: &mut u8x64<Self>) -> &mut [u8; 64];
fn store_array_u8x64(self, a: u8x64<Self>, dest: &mut [u8; 64]);
fn cvt_from_bytes_u8x64(self, a: u8x64<Self>) -> u8x64<Self>;
fn cvt_to_bytes_u8x64(self, a: u8x64<Self>) -> u8x64<Self>;
fn slide_u8x64<const SHIFT: usize>(
self,
a: u8x64<Self>,
b: u8x64<Self>,
) -> u8x64<Self>;
fn slide_within_blocks_u8x64<const SHIFT: usize>(
self,
a: u8x64<Self>,
b: u8x64<Self>,
) -> u8x64<Self>;
fn add_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn sub_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn mul_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn and_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn or_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn xor_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn not_u8x64(self, a: u8x64<Self>) -> u8x64<Self>;
fn shl_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self>;
fn shlv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn shr_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self>;
fn shrv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn simd_eq_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>;
fn simd_lt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>;
fn simd_le_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>;
fn simd_ge_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>;
fn simd_gt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>;
fn zip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn zip_high_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn unzip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn unzip_high_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn interleave_u8x64(
self,
a: u8x64<Self>,
b: u8x64<Self>,
) -> (u8x64<Self>, u8x64<Self>);
fn deinterleave_u8x64(
self,
a: u8x64<Self>,
b: u8x64<Self>,
) -> (u8x64<Self>, u8x64<Self>);
fn select_u8x64(
self,
a: mask8x64<Self>,
b: u8x64<Self>,
c: u8x64<Self>,
) -> u8x64<Self>;
fn min_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn max_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
fn split_u8x64(self, a: u8x64<Self>) -> (u8x32<Self>, u8x32<Self>);
fn load_interleaved_128_u8x64(self, src: &[u8; 64]) -> u8x64<Self>;
fn store_interleaved_128_u8x64(self, a: u8x64<Self>, dest: &mut [u8; 64]);
fn reinterpret_u32_u8x64(self, a: u8x64<Self>) -> u32x16<Self>;
fn splat_mask8x64(self, val: i8) -> mask8x64<Self>;
fn load_array_mask8x64(self, val: [i8; 64]) -> mask8x64<Self>;
fn load_array_ref_mask8x64(self, val: &[i8; 64]) -> mask8x64<Self>;
fn as_array_mask8x64(self, a: mask8x64<Self>) -> [i8; 64];
fn as_array_ref_mask8x64(self, a: &mask8x64<Self>) -> &[i8; 64];
fn as_array_mut_mask8x64(self, a: &mut mask8x64<Self>) -> &mut [i8; 64];
fn store_array_mask8x64(self, a: mask8x64<Self>, dest: &mut [i8; 64]);
fn cvt_from_bytes_mask8x64(self, a: u8x64<Self>) -> mask8x64<Self>;
fn cvt_to_bytes_mask8x64(self, a: mask8x64<Self>) -> u8x64<Self>;
fn slide_mask8x64<const SHIFT: usize>(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
) -> mask8x64<Self>;
fn slide_within_blocks_mask8x64<const SHIFT: usize>(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
) -> mask8x64<Self>;
fn and_mask8x64(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
) -> mask8x64<Self>;
fn or_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>;
fn xor_mask8x64(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
) -> mask8x64<Self>;
fn not_mask8x64(self, a: mask8x64<Self>) -> mask8x64<Self>;
fn select_mask8x64(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
c: mask8x64<Self>,
) -> mask8x64<Self>;
fn simd_eq_mask8x64(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
) -> mask8x64<Self>;
fn any_true_mask8x64(self, a: mask8x64<Self>) -> bool;
fn all_true_mask8x64(self, a: mask8x64<Self>) -> bool;
fn any_false_mask8x64(self, a: mask8x64<Self>) -> bool;
fn all_false_mask8x64(self, a: mask8x64<Self>) -> bool;
fn split_mask8x64(
self,
a: mask8x64<Self>,
) -> (mask8x32<Self>, mask8x32<Self>);
fn splat_i16x32(self, val: i16) -> i16x32<Self>;
fn load_array_i16x32(self, val: [i16; 32]) -> i16x32<Self>;
fn load_array_ref_i16x32(self, val: &[i16; 32]) -> i16x32<Self>;
fn as_array_i16x32(self, a: i16x32<Self>) -> [i16; 32];
fn as_array_ref_i16x32(self, a: &i16x32<Self>) -> &[i16; 32];
fn as_array_mut_i16x32(self, a: &mut i16x32<Self>) -> &mut [i16; 32];
fn store_array_i16x32(self, a: i16x32<Self>, dest: &mut [i16; 32]);
fn cvt_from_bytes_i16x32(self, a: u8x64<Self>) -> i16x32<Self>;
fn cvt_to_bytes_i16x32(self, a: i16x32<Self>) -> u8x64<Self>;
fn slide_i16x32<const SHIFT: usize>(
self,
a: i16x32<Self>,
b: i16x32<Self>,
) -> i16x32<Self>;
fn slide_within_blocks_i16x32<const SHIFT: usize>(
self,
a: i16x32<Self>,
b: i16x32<Self>,
) -> i16x32<Self>;
fn add_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn sub_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn mul_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn and_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn or_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn xor_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn not_i16x32(self, a: i16x32<Self>) -> i16x32<Self>;
fn shl_i16x32(self, a: i16x32<Self>, shift: u32) -> i16x32<Self>;
fn shlv_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn shr_i16x32(self, a: i16x32<Self>, shift: u32) -> i16x32<Self>;
fn shrv_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn simd_eq_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>;
fn simd_lt_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>;
fn simd_le_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>;
fn simd_ge_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>;
fn simd_gt_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>;
fn zip_low_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn zip_high_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn unzip_low_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn unzip_high_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn interleave_i16x32(
self,
a: i16x32<Self>,
b: i16x32<Self>,
) -> (i16x32<Self>, i16x32<Self>);
fn deinterleave_i16x32(
self,
a: i16x32<Self>,
b: i16x32<Self>,
) -> (i16x32<Self>, i16x32<Self>);
fn select_i16x32(
self,
a: mask16x32<Self>,
b: i16x32<Self>,
c: i16x32<Self>,
) -> i16x32<Self>;
fn min_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn max_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
fn split_i16x32(self, a: i16x32<Self>) -> (i16x16<Self>, i16x16<Self>);
fn neg_i16x32(self, a: i16x32<Self>) -> i16x32<Self>;
fn reinterpret_u8_i16x32(self, a: i16x32<Self>) -> u8x64<Self>;
fn reinterpret_u32_i16x32(self, a: i16x32<Self>) -> u32x16<Self>;
fn splat_u16x32(self, val: u16) -> u16x32<Self>;
fn load_array_u16x32(self, val: [u16; 32]) -> u16x32<Self>;
fn load_array_ref_u16x32(self, val: &[u16; 32]) -> u16x32<Self>;
fn as_array_u16x32(self, a: u16x32<Self>) -> [u16; 32];
fn as_array_ref_u16x32(self, a: &u16x32<Self>) -> &[u16; 32];
fn as_array_mut_u16x32(self, a: &mut u16x32<Self>) -> &mut [u16; 32];
fn store_array_u16x32(self, a: u16x32<Self>, dest: &mut [u16; 32]);
fn cvt_from_bytes_u16x32(self, a: u8x64<Self>) -> u16x32<Self>;
fn cvt_to_bytes_u16x32(self, a: u16x32<Self>) -> u8x64<Self>;
fn slide_u16x32<const SHIFT: usize>(
self,
a: u16x32<Self>,
b: u16x32<Self>,
) -> u16x32<Self>;
fn slide_within_blocks_u16x32<const SHIFT: usize>(
self,
a: u16x32<Self>,
b: u16x32<Self>,
) -> u16x32<Self>;
fn add_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn sub_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn mul_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn and_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn or_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn xor_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn not_u16x32(self, a: u16x32<Self>) -> u16x32<Self>;
fn shl_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self>;
fn shlv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn shr_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self>;
fn shrv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn simd_eq_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>;
fn simd_lt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>;
fn simd_le_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>;
fn simd_ge_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>;
fn simd_gt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>;
fn zip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn zip_high_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn unzip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn unzip_high_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn interleave_u16x32(
self,
a: u16x32<Self>,
b: u16x32<Self>,
) -> (u16x32<Self>, u16x32<Self>);
fn deinterleave_u16x32(
self,
a: u16x32<Self>,
b: u16x32<Self>,
) -> (u16x32<Self>, u16x32<Self>);
fn select_u16x32(
self,
a: mask16x32<Self>,
b: u16x32<Self>,
c: u16x32<Self>,
) -> u16x32<Self>;
fn min_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn max_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
fn split_u16x32(self, a: u16x32<Self>) -> (u16x16<Self>, u16x16<Self>);
fn load_interleaved_128_u16x32(self, src: &[u16; 32]) -> u16x32<Self>;
fn store_interleaved_128_u16x32(self, a: u16x32<Self>, dest: &mut [u16; 32]);
fn narrow_u16x32(self, a: u16x32<Self>) -> u8x32<Self>;
fn reinterpret_u8_u16x32(self, a: u16x32<Self>) -> u8x64<Self>;
fn reinterpret_u32_u16x32(self, a: u16x32<Self>) -> u32x16<Self>;
fn splat_mask16x32(self, val: i16) -> mask16x32<Self>;
fn load_array_mask16x32(self, val: [i16; 32]) -> mask16x32<Self>;
fn load_array_ref_mask16x32(self, val: &[i16; 32]) -> mask16x32<Self>;
fn as_array_mask16x32(self, a: mask16x32<Self>) -> [i16; 32];
fn as_array_ref_mask16x32(self, a: &mask16x32<Self>) -> &[i16; 32];
fn as_array_mut_mask16x32(self, a: &mut mask16x32<Self>) -> &mut [i16; 32];
fn store_array_mask16x32(self, a: mask16x32<Self>, dest: &mut [i16; 32]);
fn cvt_from_bytes_mask16x32(self, a: u8x64<Self>) -> mask16x32<Self>;
fn cvt_to_bytes_mask16x32(self, a: mask16x32<Self>) -> u8x64<Self>;
fn slide_mask16x32<const SHIFT: usize>(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>;
fn slide_within_blocks_mask16x32<const SHIFT: usize>(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>;
fn and_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>;
fn or_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>;
fn xor_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>;
fn not_mask16x32(self, a: mask16x32<Self>) -> mask16x32<Self>;
fn select_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
c: mask16x32<Self>,
) -> mask16x32<Self>;
fn simd_eq_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>;
fn any_true_mask16x32(self, a: mask16x32<Self>) -> bool;
fn all_true_mask16x32(self, a: mask16x32<Self>) -> bool;
fn any_false_mask16x32(self, a: mask16x32<Self>) -> bool;
fn all_false_mask16x32(self, a: mask16x32<Self>) -> bool;
fn split_mask16x32(
self,
a: mask16x32<Self>,
) -> (mask16x16<Self>, mask16x16<Self>);
fn splat_i32x16(self, val: i32) -> i32x16<Self>;
fn load_array_i32x16(self, val: [i32; 16]) -> i32x16<Self>;
fn load_array_ref_i32x16(self, val: &[i32; 16]) -> i32x16<Self>;
fn as_array_i32x16(self, a: i32x16<Self>) -> [i32; 16];
fn as_array_ref_i32x16(self, a: &i32x16<Self>) -> &[i32; 16];
fn as_array_mut_i32x16(self, a: &mut i32x16<Self>) -> &mut [i32; 16];
fn store_array_i32x16(self, a: i32x16<Self>, dest: &mut [i32; 16]);
fn cvt_from_bytes_i32x16(self, a: u8x64<Self>) -> i32x16<Self>;
fn cvt_to_bytes_i32x16(self, a: i32x16<Self>) -> u8x64<Self>;
fn slide_i32x16<const SHIFT: usize>(
self,
a: i32x16<Self>,
b: i32x16<Self>,
) -> i32x16<Self>;
fn slide_within_blocks_i32x16<const SHIFT: usize>(
self,
a: i32x16<Self>,
b: i32x16<Self>,
) -> i32x16<Self>;
fn add_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn sub_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn mul_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn and_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn or_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn xor_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn not_i32x16(self, a: i32x16<Self>) -> i32x16<Self>;
fn shl_i32x16(self, a: i32x16<Self>, shift: u32) -> i32x16<Self>;
fn shlv_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn shr_i32x16(self, a: i32x16<Self>, shift: u32) -> i32x16<Self>;
fn shrv_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn simd_eq_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>;
fn simd_lt_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>;
fn simd_le_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>;
fn simd_ge_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>;
fn simd_gt_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>;
fn zip_low_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn zip_high_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn unzip_low_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn unzip_high_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn interleave_i32x16(
self,
a: i32x16<Self>,
b: i32x16<Self>,
) -> (i32x16<Self>, i32x16<Self>);
fn deinterleave_i32x16(
self,
a: i32x16<Self>,
b: i32x16<Self>,
) -> (i32x16<Self>, i32x16<Self>);
fn select_i32x16(
self,
a: mask32x16<Self>,
b: i32x16<Self>,
c: i32x16<Self>,
) -> i32x16<Self>;
fn min_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn max_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
fn split_i32x16(self, a: i32x16<Self>) -> (i32x8<Self>, i32x8<Self>);
fn neg_i32x16(self, a: i32x16<Self>) -> i32x16<Self>;
fn reinterpret_u8_i32x16(self, a: i32x16<Self>) -> u8x64<Self>;
fn reinterpret_u32_i32x16(self, a: i32x16<Self>) -> u32x16<Self>;
fn cvt_f32_i32x16(self, a: i32x16<Self>) -> f32x16<Self>;
fn splat_u32x16(self, val: u32) -> u32x16<Self>;
fn load_array_u32x16(self, val: [u32; 16]) -> u32x16<Self>;
fn load_array_ref_u32x16(self, val: &[u32; 16]) -> u32x16<Self>;
fn as_array_u32x16(self, a: u32x16<Self>) -> [u32; 16];
fn as_array_ref_u32x16(self, a: &u32x16<Self>) -> &[u32; 16];
fn as_array_mut_u32x16(self, a: &mut u32x16<Self>) -> &mut [u32; 16];
fn store_array_u32x16(self, a: u32x16<Self>, dest: &mut [u32; 16]);
fn cvt_from_bytes_u32x16(self, a: u8x64<Self>) -> u32x16<Self>;
fn cvt_to_bytes_u32x16(self, a: u32x16<Self>) -> u8x64<Self>;
fn slide_u32x16<const SHIFT: usize>(
self,
a: u32x16<Self>,
b: u32x16<Self>,
) -> u32x16<Self>;
fn slide_within_blocks_u32x16<const SHIFT: usize>(
self,
a: u32x16<Self>,
b: u32x16<Self>,
) -> u32x16<Self>;
fn add_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn sub_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn mul_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn and_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn or_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn xor_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn not_u32x16(self, a: u32x16<Self>) -> u32x16<Self>;
fn shl_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self>;
fn shlv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn shr_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self>;
fn shrv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn simd_eq_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>;
fn simd_lt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>;
fn simd_le_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>;
fn simd_ge_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>;
fn simd_gt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>;
fn zip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn zip_high_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn unzip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn unzip_high_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn interleave_u32x16(
self,
a: u32x16<Self>,
b: u32x16<Self>,
) -> (u32x16<Self>, u32x16<Self>);
fn deinterleave_u32x16(
self,
a: u32x16<Self>,
b: u32x16<Self>,
) -> (u32x16<Self>, u32x16<Self>);
fn select_u32x16(
self,
a: mask32x16<Self>,
b: u32x16<Self>,
c: u32x16<Self>,
) -> u32x16<Self>;
fn min_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn max_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
fn split_u32x16(self, a: u32x16<Self>) -> (u32x8<Self>, u32x8<Self>);
fn load_interleaved_128_u32x16(self, src: &[u32; 16]) -> u32x16<Self>;
fn store_interleaved_128_u32x16(self, a: u32x16<Self>, dest: &mut [u32; 16]);
fn reinterpret_u8_u32x16(self, a: u32x16<Self>) -> u8x64<Self>;
fn cvt_f32_u32x16(self, a: u32x16<Self>) -> f32x16<Self>;
fn splat_mask32x16(self, val: i32) -> mask32x16<Self>;
fn load_array_mask32x16(self, val: [i32; 16]) -> mask32x16<Self>;
fn load_array_ref_mask32x16(self, val: &[i32; 16]) -> mask32x16<Self>;
fn as_array_mask32x16(self, a: mask32x16<Self>) -> [i32; 16];
fn as_array_ref_mask32x16(self, a: &mask32x16<Self>) -> &[i32; 16];
fn as_array_mut_mask32x16(self, a: &mut mask32x16<Self>) -> &mut [i32; 16];
fn store_array_mask32x16(self, a: mask32x16<Self>, dest: &mut [i32; 16]);
fn cvt_from_bytes_mask32x16(self, a: u8x64<Self>) -> mask32x16<Self>;
fn cvt_to_bytes_mask32x16(self, a: mask32x16<Self>) -> u8x64<Self>;
fn slide_mask32x16<const SHIFT: usize>(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>;
fn slide_within_blocks_mask32x16<const SHIFT: usize>(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>;
fn and_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>;
fn or_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>;
fn xor_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>;
fn not_mask32x16(self, a: mask32x16<Self>) -> mask32x16<Self>;
fn select_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
c: mask32x16<Self>,
) -> mask32x16<Self>;
fn simd_eq_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>;
fn any_true_mask32x16(self, a: mask32x16<Self>) -> bool;
fn all_true_mask32x16(self, a: mask32x16<Self>) -> bool;
fn any_false_mask32x16(self, a: mask32x16<Self>) -> bool;
fn all_false_mask32x16(self, a: mask32x16<Self>) -> bool;
fn split_mask32x16(
self,
a: mask32x16<Self>,
) -> (mask32x8<Self>, mask32x8<Self>);
fn splat_f64x8(self, val: f64) -> f64x8<Self>;
fn load_array_f64x8(self, val: [f64; 8]) -> f64x8<Self>;
fn load_array_ref_f64x8(self, val: &[f64; 8]) -> f64x8<Self>;
fn as_array_f64x8(self, a: f64x8<Self>) -> [f64; 8];
fn as_array_ref_f64x8(self, a: &f64x8<Self>) -> &[f64; 8];
fn as_array_mut_f64x8(self, a: &mut f64x8<Self>) -> &mut [f64; 8];
fn store_array_f64x8(self, a: f64x8<Self>, dest: &mut [f64; 8]);
fn cvt_from_bytes_f64x8(self, a: u8x64<Self>) -> f64x8<Self>;
fn cvt_to_bytes_f64x8(self, a: f64x8<Self>) -> u8x64<Self>;
fn slide_f64x8<const SHIFT: usize>(
self,
a: f64x8<Self>,
b: f64x8<Self>,
) -> f64x8<Self>;
fn slide_within_blocks_f64x8<const SHIFT: usize>(
self,
a: f64x8<Self>,
b: f64x8<Self>,
) -> f64x8<Self>;
fn abs_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
fn neg_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
fn sqrt_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
fn add_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn sub_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn mul_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn div_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn copysign_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn simd_eq_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>;
fn simd_lt_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>;
fn simd_le_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>;
fn simd_ge_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>;
fn simd_gt_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>;
fn zip_low_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn zip_high_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn unzip_low_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn unzip_high_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn interleave_f64x8(
self,
a: f64x8<Self>,
b: f64x8<Self>,
) -> (f64x8<Self>, f64x8<Self>);
fn deinterleave_f64x8(
self,
a: f64x8<Self>,
b: f64x8<Self>,
) -> (f64x8<Self>, f64x8<Self>);
fn max_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn min_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn max_precise_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn min_precise_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>;
fn mul_add_f64x8(
self,
a: f64x8<Self>,
b: f64x8<Self>,
c: f64x8<Self>,
) -> f64x8<Self>;
fn mul_sub_f64x8(
self,
a: f64x8<Self>,
b: f64x8<Self>,
c: f64x8<Self>,
) -> f64x8<Self>;
fn floor_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
fn ceil_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
fn round_ties_even_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
fn fract_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
fn trunc_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
fn select_f64x8(
self,
a: mask64x8<Self>,
b: f64x8<Self>,
c: f64x8<Self>,
) -> f64x8<Self>;
fn split_f64x8(self, a: f64x8<Self>) -> (f64x4<Self>, f64x4<Self>);
fn reinterpret_f32_f64x8(self, a: f64x8<Self>) -> f32x16<Self>;
fn splat_mask64x8(self, val: i64) -> mask64x8<Self>;
fn load_array_mask64x8(self, val: [i64; 8]) -> mask64x8<Self>;
fn load_array_ref_mask64x8(self, val: &[i64; 8]) -> mask64x8<Self>;
fn as_array_mask64x8(self, a: mask64x8<Self>) -> [i64; 8];
fn as_array_ref_mask64x8(self, a: &mask64x8<Self>) -> &[i64; 8];
fn as_array_mut_mask64x8(self, a: &mut mask64x8<Self>) -> &mut [i64; 8];
fn store_array_mask64x8(self, a: mask64x8<Self>, dest: &mut [i64; 8]);
fn cvt_from_bytes_mask64x8(self, a: u8x64<Self>) -> mask64x8<Self>;
fn cvt_to_bytes_mask64x8(self, a: mask64x8<Self>) -> u8x64<Self>;
fn slide_mask64x8<const SHIFT: usize>(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
) -> mask64x8<Self>;
fn slide_within_blocks_mask64x8<const SHIFT: usize>(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
) -> mask64x8<Self>;
fn and_mask64x8(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
) -> mask64x8<Self>;
fn or_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>;
fn xor_mask64x8(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
) -> mask64x8<Self>;
fn not_mask64x8(self, a: mask64x8<Self>) -> mask64x8<Self>;
fn select_mask64x8(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
c: mask64x8<Self>,
) -> mask64x8<Self>;
fn simd_eq_mask64x8(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
) -> mask64x8<Self>;
fn any_true_mask64x8(self, a: mask64x8<Self>) -> bool;
fn all_true_mask64x8(self, a: mask64x8<Self>) -> bool;
fn any_false_mask64x8(self, a: mask64x8<Self>) -> bool;
fn all_false_mask64x8(self, a: mask64x8<Self>) -> bool;
fn split_mask64x8(
self,
a: mask64x8<Self>,
) -> (mask64x4<Self>, mask64x4<Self>);
}Expand description
The main SIMD trait, implemented by all SIMD token types.
Each implementor of this trait (e.g. Avx2, Sse4_2, Neon, Fallback) is a zero-sized “token” type
representing a specific SIMD instruction set. These tokens are obtained at runtime via Level and the
dispatch! macro, which selects the best available backend for the current CPU.
This trait defines all the low-level SIMD operations (e.g. add_f32x4,
mul_u32x4) that are implemented by each token type using platform-specific intrinsics.
However, you typically won’t call these methods directly. Instead, you’ll probably be using the methods
defined on the vector types themselves.
§Associated Types
The trait defines associated types for the highest “native” vector width of each scalar type (e.g. f32s,
u32s). These are always at least 128 bits, but may be larger. Currently, they are 128 bits everywhere but
AVX2, where they are 256 bits.
§Example
#[inline(always)]
fn add_vectors<S: Simd>(simd: S, a: f32x4<S>, b: f32x4<S>) -> f32x4<S> {
a + b // Uses operator overloading, which calls simd.add_f32x4 internally
}
let level = Level::new();
dispatch!(level, simd => {
let a = [1.0, 2.0, 3.0, 4.0].simd_into(simd);
let b = [5.0, 6.0, 7.0, 8.0].simd_into(simd);
let result = add_vectors(simd, a, b);
});Required Associated Types§
Sourcetype f32s: SimdFloat<Self, Element = f32, Block = f32x4<Self>, Mask = Self::mask32s, Bytes = <Self::u32s as Bytes>::Bytes> + SimdCvtFloat<Self::u32s> + SimdCvtFloat<Self::i32s>
type f32s: SimdFloat<Self, Element = f32, Block = f32x4<Self>, Mask = Self::mask32s, Bytes = <Self::u32s as Bytes>::Bytes> + SimdCvtFloat<Self::u32s> + SimdCvtFloat<Self::i32s>
A native-width SIMD vector of f32s.
Sourcetype f64s: SimdFloat<Self, Element = f64, Block = f64x2<Self>, Mask = Self::mask64s>
type f64s: SimdFloat<Self, Element = f64, Block = f64x2<Self>, Mask = Self::mask64s>
A native-width SIMD vector of f64s.
Sourcetype u8s: SimdInt<Self, Element = u8, Block = u8x16<Self>, Mask = Self::mask8s>
type u8s: SimdInt<Self, Element = u8, Block = u8x16<Self>, Mask = Self::mask8s>
A native-width SIMD vector of u8s.
Sourcetype i8s: SimdInt<Self, Element = i8, Block = i8x16<Self>, Mask = Self::mask8s, Bytes = <Self::u8s as Bytes>::Bytes> + Neg<Output = Self::i8s>
type i8s: SimdInt<Self, Element = i8, Block = i8x16<Self>, Mask = Self::mask8s, Bytes = <Self::u8s as Bytes>::Bytes> + Neg<Output = Self::i8s>
A native-width SIMD vector of i8s.
Sourcetype u16s: SimdInt<Self, Element = u16, Block = u16x8<Self>, Mask = Self::mask16s>
type u16s: SimdInt<Self, Element = u16, Block = u16x8<Self>, Mask = Self::mask16s>
A native-width SIMD vector of u16s.
Sourcetype i16s: SimdInt<Self, Element = i16, Block = i16x8<Self>, Mask = Self::mask16s, Bytes = <Self::u16s as Bytes>::Bytes> + Neg<Output = Self::i16s>
type i16s: SimdInt<Self, Element = i16, Block = i16x8<Self>, Mask = Self::mask16s, Bytes = <Self::u16s as Bytes>::Bytes> + Neg<Output = Self::i16s>
A native-width SIMD vector of i16s.
Sourcetype u32s: SimdInt<Self, Element = u32, Block = u32x4<Self>, Mask = Self::mask32s> + SimdCvtTruncate<Self::f32s>
type u32s: SimdInt<Self, Element = u32, Block = u32x4<Self>, Mask = Self::mask32s> + SimdCvtTruncate<Self::f32s>
A native-width SIMD vector of u32s.
Sourcetype i32s: SimdInt<Self, Element = i32, Block = i32x4<Self>, Mask = Self::mask32s, Bytes = <Self::u32s as Bytes>::Bytes> + SimdCvtTruncate<Self::f32s> + Neg<Output = Self::i32s>
type i32s: SimdInt<Self, Element = i32, Block = i32x4<Self>, Mask = Self::mask32s, Bytes = <Self::u32s as Bytes>::Bytes> + SimdCvtTruncate<Self::f32s> + Neg<Output = Self::i32s>
A native-width SIMD vector of i32s.
Sourcetype mask8s: SimdMask<Self, Element = i8, Block = mask8x16<Self>, Bytes = <Self::u8s as Bytes>::Bytes> + Select<Self::u8s> + Select<Self::i8s> + Select<Self::mask8s>
type mask8s: SimdMask<Self, Element = i8, Block = mask8x16<Self>, Bytes = <Self::u8s as Bytes>::Bytes> + Select<Self::u8s> + Select<Self::i8s> + Select<Self::mask8s>
A native-width SIMD mask with 8-bit lanes.
Sourcetype mask16s: SimdMask<Self, Element = i16, Block = mask16x8<Self>, Bytes = <Self::u16s as Bytes>::Bytes> + Select<Self::u16s> + Select<Self::i16s> + Select<Self::mask16s>
type mask16s: SimdMask<Self, Element = i16, Block = mask16x8<Self>, Bytes = <Self::u16s as Bytes>::Bytes> + Select<Self::u16s> + Select<Self::i16s> + Select<Self::mask16s>
A native-width SIMD mask with 16-bit lanes.
Required Methods§
Sourcefn vectorize<F: FnOnce() -> R, R>(self, f: F) -> R
fn vectorize<F: FnOnce() -> R, R>(self, f: F) -> R
Call function with CPU features enabled.
For performance, the provided function should be #[inline(always)].
Sourcefn splat_f32x4(self, val: f32) -> f32x4<Self>
fn splat_f32x4(self, val: f32) -> f32x4<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_f32x4(self, val: [f32; 4]) -> f32x4<Self>
fn load_array_f32x4(self, val: [f32; 4]) -> f32x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_f32x4(self, val: &[f32; 4]) -> f32x4<Self>
fn load_array_ref_f32x4(self, val: &[f32; 4]) -> f32x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_f32x4(self, a: f32x4<Self>) -> [f32; 4]
fn as_array_f32x4(self, a: f32x4<Self>) -> [f32; 4]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_f32x4(self, a: &f32x4<Self>) -> &[f32; 4]
fn as_array_ref_f32x4(self, a: &f32x4<Self>) -> &[f32; 4]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_f32x4(self, a: &mut f32x4<Self>) -> &mut [f32; 4]
fn as_array_mut_f32x4(self, a: &mut f32x4<Self>) -> &mut [f32; 4]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_f32x4(self, a: f32x4<Self>, dest: &mut [f32; 4])
fn store_array_f32x4(self, a: f32x4<Self>, dest: &mut [f32; 4])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_f32x4(self, a: u8x16<Self>) -> f32x4<Self>
fn cvt_from_bytes_f32x4(self, a: u8x16<Self>) -> f32x4<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_f32x4(self, a: f32x4<Self>) -> u8x16<Self>
fn cvt_to_bytes_f32x4(self, a: f32x4<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_f32x4<const SHIFT: usize>(
self,
a: f32x4<Self>,
b: f32x4<Self>,
) -> f32x4<Self>
fn slide_f32x4<const SHIFT: usize>( self, a: f32x4<Self>, b: f32x4<Self>, ) -> f32x4<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_f32x4<const SHIFT: usize>(
self,
a: f32x4<Self>,
b: f32x4<Self>,
) -> f32x4<Self>
fn slide_within_blocks_f32x4<const SHIFT: usize>( self, a: f32x4<Self>, b: f32x4<Self>, ) -> f32x4<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn sqrt_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
fn sqrt_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
Compute the square root of each element.
Negative elements other than -0.0 will become NaN.
Sourcefn add_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn add_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Add two vectors element-wise.
Sourcefn sub_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn sub_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Subtract two vectors element-wise.
Sourcefn mul_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn mul_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Multiply two vectors element-wise.
Sourcefn div_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn div_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Divide two vectors element-wise.
Sourcefn copysign_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn copysign_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Return a vector with the magnitude of a and the sign of b for each element.
This operation copies the sign bit, so if an input element is NaN, the output element will be a NaN with the same payload and a copied sign bit.
Sourcefn simd_eq_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
fn simd_eq_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
fn simd_lt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
fn simd_le_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
fn simd_ge_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
fn simd_gt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn zip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn zip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn unzip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn unzip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_f32x4(
self,
a: f32x4<Self>,
b: f32x4<Self>,
) -> (f32x4<Self>, f32x4<Self>)
fn interleave_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, ) -> (f32x4<Self>, f32x4<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_f32x4(
self,
a: f32x4<Self>,
b: f32x4<Self>,
) -> (f32x4<Self>, f32x4<Self>)
fn deinterleave_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, ) -> (f32x4<Self>, f32x4<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn max_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn max_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Return the element-wise maximum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See max_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn min_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn min_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Return the element-wise minimum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See min_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn max_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn max_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Return the element-wise maximum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn min_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
fn min_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>
Return the element-wise minimum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn mul_add_f32x4(
self,
a: f32x4<Self>,
b: f32x4<Self>,
c: f32x4<Self>,
) -> f32x4<Self>
fn mul_add_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, c: f32x4<Self>, ) -> f32x4<Self>
Compute (a * b) + c (fused multiply-add) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by an add, which will result in two rounding errors.
Sourcefn mul_sub_f32x4(
self,
a: f32x4<Self>,
b: f32x4<Self>,
c: f32x4<Self>,
) -> f32x4<Self>
fn mul_sub_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, c: f32x4<Self>, ) -> f32x4<Self>
Compute (a * b) - c (fused multiply-subtract) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by a subtract, which will result in two rounding errors.
Sourcefn floor_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
fn floor_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
Return the largest integer less than or equal to each element, that is, round towards negative infinity.
Sourcefn ceil_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
fn ceil_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.
Sourcefn round_ties_even_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
fn round_ties_even_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
Round each element to the nearest integer, with ties rounding to the nearest even integer.
There is no corresponding round operation. Rust’s round operation rounds ties away from zero, a behavior it inherited from C. That behavior is not implemented across all platforms, whereas round-ties-even is.
Sourcefn fract_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
fn fract_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
Return the fractional part of each element.
This is equivalent to a - a.trunc().
Sourcefn trunc_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
fn trunc_f32x4(self, a: f32x4<Self>) -> f32x4<Self>
Return the integer part of each element, rounding towards zero.
Sourcefn select_f32x4(
self,
a: mask32x4<Self>,
b: f32x4<Self>,
c: f32x4<Self>,
) -> f32x4<Self>
fn select_f32x4( self, a: mask32x4<Self>, b: f32x4<Self>, c: f32x4<Self>, ) -> f32x4<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn combine_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x8<Self>
fn combine_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x8<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn reinterpret_f64_f32x4(self, a: f32x4<Self>) -> f64x2<Self>
fn reinterpret_f64_f32x4(self, a: f32x4<Self>) -> f64x2<Self>
Reinterpret the bits of this vector as a vector of f64 elements.
The number of elements in the result is half that of the input.
Sourcefn reinterpret_i32_f32x4(self, a: f32x4<Self>) -> i32x4<Self>
fn reinterpret_i32_f32x4(self, a: f32x4<Self>) -> i32x4<Self>
Reinterpret the bits of this vector as a vector of i32 elements.
This is a bitwise reinterpretation only, and does not perform any conversions.
Sourcefn reinterpret_u8_f32x4(self, a: f32x4<Self>) -> u8x16<Self>
fn reinterpret_u8_f32x4(self, a: f32x4<Self>) -> u8x16<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_f32x4(self, a: f32x4<Self>) -> u32x4<Self>
fn reinterpret_u32_f32x4(self, a: f32x4<Self>) -> u32x4<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_u32_f32x4(self, a: f32x4<Self>) -> u32x4<Self>
fn cvt_u32_f32x4(self, a: f32x4<Self>) -> u32x4<Self>
Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.
Out-of-range values or NaN will produce implementation-defined results.
On x86 platforms, this operation will still be slower than converting to i32, because there is no native instruction for converting to u32 (at least until AVX-512, which is currently not supported).
If you know your values fit within range of an i32, you should convert to an i32 and cast to your desired datatype afterwards.
Sourcefn cvt_u32_precise_f32x4(self, a: f32x4<Self>) -> u32x4<Self>
fn cvt_u32_precise_f32x4(self, a: f32x4<Self>) -> u32x4<Self>
Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.
Out-of-range values are saturated to the closest in-range value. NaN becomes 0.
Sourcefn cvt_i32_f32x4(self, a: f32x4<Self>) -> i32x4<Self>
fn cvt_i32_f32x4(self, a: f32x4<Self>) -> i32x4<Self>
Convert each floating-point element to a signed 32-bit integer, truncating towards zero.
Out-of-range values or NaN will produce implementation-defined results.
Sourcefn cvt_i32_precise_f32x4(self, a: f32x4<Self>) -> i32x4<Self>
fn cvt_i32_precise_f32x4(self, a: f32x4<Self>) -> i32x4<Self>
Convert each floating-point element to a signed 32-bit integer, truncating towards zero.
Out-of-range values are saturated to the closest in-range value. NaN becomes 0.
Sourcefn splat_i8x16(self, val: i8) -> i8x16<Self>
fn splat_i8x16(self, val: i8) -> i8x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i8x16(self, val: [i8; 16]) -> i8x16<Self>
fn load_array_i8x16(self, val: [i8; 16]) -> i8x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i8x16(self, val: &[i8; 16]) -> i8x16<Self>
fn load_array_ref_i8x16(self, val: &[i8; 16]) -> i8x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i8x16(self, a: i8x16<Self>) -> [i8; 16]
fn as_array_i8x16(self, a: i8x16<Self>) -> [i8; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i8x16(self, a: &i8x16<Self>) -> &[i8; 16]
fn as_array_ref_i8x16(self, a: &i8x16<Self>) -> &[i8; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i8x16(self, a: &mut i8x16<Self>) -> &mut [i8; 16]
fn as_array_mut_i8x16(self, a: &mut i8x16<Self>) -> &mut [i8; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i8x16(self, a: i8x16<Self>, dest: &mut [i8; 16])
fn store_array_i8x16(self, a: i8x16<Self>, dest: &mut [i8; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i8x16(self, a: u8x16<Self>) -> i8x16<Self>
fn cvt_from_bytes_i8x16(self, a: u8x16<Self>) -> i8x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i8x16(self, a: i8x16<Self>) -> u8x16<Self>
fn cvt_to_bytes_i8x16(self, a: i8x16<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i8x16<const SHIFT: usize>(
self,
a: i8x16<Self>,
b: i8x16<Self>,
) -> i8x16<Self>
fn slide_i8x16<const SHIFT: usize>( self, a: i8x16<Self>, b: i8x16<Self>, ) -> i8x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i8x16<const SHIFT: usize>(
self,
a: i8x16<Self>,
b: i8x16<Self>,
) -> i8x16<Self>
fn slide_within_blocks_i8x16<const SHIFT: usize>( self, a: i8x16<Self>, b: i8x16<Self>, ) -> i8x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn add_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn sub_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn mul_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn and_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn or_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn xor_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self>
fn shl_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn shlv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self>
fn shr_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn shrv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
fn simd_eq_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
fn simd_lt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
fn simd_le_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
fn simd_ge_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
fn simd_gt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn zip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn zip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn unzip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn unzip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i8x16(
self,
a: i8x16<Self>,
b: i8x16<Self>,
) -> (i8x16<Self>, i8x16<Self>)
fn interleave_i8x16( self, a: i8x16<Self>, b: i8x16<Self>, ) -> (i8x16<Self>, i8x16<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i8x16(
self,
a: i8x16<Self>,
b: i8x16<Self>,
) -> (i8x16<Self>, i8x16<Self>)
fn deinterleave_i8x16( self, a: i8x16<Self>, b: i8x16<Self>, ) -> (i8x16<Self>, i8x16<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i8x16(
self,
a: mask8x16<Self>,
b: i8x16<Self>,
c: i8x16<Self>,
) -> i8x16<Self>
fn select_i8x16( self, a: mask8x16<Self>, b: i8x16<Self>, c: i8x16<Self>, ) -> i8x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn min_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
fn max_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x32<Self>
fn combine_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x32<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn neg_i8x16(self, a: i8x16<Self>) -> i8x16<Self>
fn neg_i8x16(self, a: i8x16<Self>) -> i8x16<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i8x16(self, a: i8x16<Self>) -> u8x16<Self>
fn reinterpret_u8_i8x16(self, a: i8x16<Self>) -> u8x16<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i8x16(self, a: i8x16<Self>) -> u32x4<Self>
fn reinterpret_u32_i8x16(self, a: i8x16<Self>) -> u32x4<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_u8x16(self, val: u8) -> u8x16<Self>
fn splat_u8x16(self, val: u8) -> u8x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u8x16(self, val: [u8; 16]) -> u8x16<Self>
fn load_array_u8x16(self, val: [u8; 16]) -> u8x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u8x16(self, val: &[u8; 16]) -> u8x16<Self>
fn load_array_ref_u8x16(self, val: &[u8; 16]) -> u8x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u8x16(self, a: u8x16<Self>) -> [u8; 16]
fn as_array_u8x16(self, a: u8x16<Self>) -> [u8; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u8x16(self, a: &u8x16<Self>) -> &[u8; 16]
fn as_array_ref_u8x16(self, a: &u8x16<Self>) -> &[u8; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u8x16(self, a: &mut u8x16<Self>) -> &mut [u8; 16]
fn as_array_mut_u8x16(self, a: &mut u8x16<Self>) -> &mut [u8; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u8x16(self, a: u8x16<Self>, dest: &mut [u8; 16])
fn store_array_u8x16(self, a: u8x16<Self>, dest: &mut [u8; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u8x16(self, a: u8x16<Self>) -> u8x16<Self>
fn cvt_from_bytes_u8x16(self, a: u8x16<Self>) -> u8x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u8x16(self, a: u8x16<Self>) -> u8x16<Self>
fn cvt_to_bytes_u8x16(self, a: u8x16<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u8x16<const SHIFT: usize>(
self,
a: u8x16<Self>,
b: u8x16<Self>,
) -> u8x16<Self>
fn slide_u8x16<const SHIFT: usize>( self, a: u8x16<Self>, b: u8x16<Self>, ) -> u8x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u8x16<const SHIFT: usize>(
self,
a: u8x16<Self>,
b: u8x16<Self>,
) -> u8x16<Self>
fn slide_within_blocks_u8x16<const SHIFT: usize>( self, a: u8x16<Self>, b: u8x16<Self>, ) -> u8x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn add_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn sub_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn mul_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn and_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn or_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn xor_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self>
fn shl_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn shlv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self>
fn shr_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn shrv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
fn simd_eq_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
fn simd_lt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
fn simd_le_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
fn simd_ge_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
fn simd_gt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn zip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn zip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn unzip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn unzip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u8x16(
self,
a: u8x16<Self>,
b: u8x16<Self>,
) -> (u8x16<Self>, u8x16<Self>)
fn interleave_u8x16( self, a: u8x16<Self>, b: u8x16<Self>, ) -> (u8x16<Self>, u8x16<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u8x16(
self,
a: u8x16<Self>,
b: u8x16<Self>,
) -> (u8x16<Self>, u8x16<Self>)
fn deinterleave_u8x16( self, a: u8x16<Self>, b: u8x16<Self>, ) -> (u8x16<Self>, u8x16<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u8x16(
self,
a: mask8x16<Self>,
b: u8x16<Self>,
c: u8x16<Self>,
) -> u8x16<Self>
fn select_u8x16( self, a: mask8x16<Self>, b: u8x16<Self>, c: u8x16<Self>, ) -> u8x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn min_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
fn max_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x32<Self>
fn combine_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x32<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn widen_u8x16(self, a: u8x16<Self>) -> u16x16<Self>
fn widen_u8x16(self, a: u8x16<Self>) -> u16x16<Self>
Zero-extend each element to a wider integer type.
The number of elements in the result is half that of the input.
Sourcefn reinterpret_u32_u8x16(self, a: u8x16<Self>) -> u32x4<Self>
fn reinterpret_u32_u8x16(self, a: u8x16<Self>) -> u32x4<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_mask8x16(self, val: i8) -> mask8x16<Self>
fn splat_mask8x16(self, val: i8) -> mask8x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask8x16(self, val: [i8; 16]) -> mask8x16<Self>
fn load_array_mask8x16(self, val: [i8; 16]) -> mask8x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask8x16(self, val: &[i8; 16]) -> mask8x16<Self>
fn load_array_ref_mask8x16(self, val: &[i8; 16]) -> mask8x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask8x16(self, a: mask8x16<Self>) -> [i8; 16]
fn as_array_mask8x16(self, a: mask8x16<Self>) -> [i8; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask8x16(self, a: &mask8x16<Self>) -> &[i8; 16]
fn as_array_ref_mask8x16(self, a: &mask8x16<Self>) -> &[i8; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask8x16(self, a: &mut mask8x16<Self>) -> &mut [i8; 16]
fn as_array_mut_mask8x16(self, a: &mut mask8x16<Self>) -> &mut [i8; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask8x16(self, a: mask8x16<Self>, dest: &mut [i8; 16])
fn store_array_mask8x16(self, a: mask8x16<Self>, dest: &mut [i8; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask8x16(self, a: u8x16<Self>) -> mask8x16<Self>
fn cvt_from_bytes_mask8x16(self, a: u8x16<Self>) -> mask8x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask8x16(self, a: mask8x16<Self>) -> u8x16<Self>
fn cvt_to_bytes_mask8x16(self, a: mask8x16<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask8x16<const SHIFT: usize>(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x16<Self>
fn slide_mask8x16<const SHIFT: usize>( self, a: mask8x16<Self>, b: mask8x16<Self>, ) -> mask8x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask8x16<const SHIFT: usize>(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x16<Self>
fn slide_within_blocks_mask8x16<const SHIFT: usize>( self, a: mask8x16<Self>, b: mask8x16<Self>, ) -> mask8x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>
fn and_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>
Compute the logical AND of two masks.
Sourcefn or_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>
fn or_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>
fn xor_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask8x16(self, a: mask8x16<Self>) -> mask8x16<Self>
fn not_mask8x16(self, a: mask8x16<Self>) -> mask8x16<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
c: mask8x16<Self>,
) -> mask8x16<Self>
fn select_mask8x16( self, a: mask8x16<Self>, b: mask8x16<Self>, c: mask8x16<Self>, ) -> mask8x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x16<Self>
fn simd_eq_mask8x16( self, a: mask8x16<Self>, b: mask8x16<Self>, ) -> mask8x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask8x16(self, a: mask8x16<Self>) -> bool
fn any_true_mask8x16(self, a: mask8x16<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask8x16(self, a: mask8x16<Self>) -> bool
fn all_true_mask8x16(self, a: mask8x16<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask8x16(self, a: mask8x16<Self>) -> bool
fn any_false_mask8x16(self, a: mask8x16<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask8x16(self, a: mask8x16<Self>) -> bool
fn all_false_mask8x16(self, a: mask8x16<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn combine_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
) -> mask8x32<Self>
fn combine_mask8x16( self, a: mask8x16<Self>, b: mask8x16<Self>, ) -> mask8x32<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn splat_i16x8(self, val: i16) -> i16x8<Self>
fn splat_i16x8(self, val: i16) -> i16x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i16x8(self, val: [i16; 8]) -> i16x8<Self>
fn load_array_i16x8(self, val: [i16; 8]) -> i16x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i16x8(self, val: &[i16; 8]) -> i16x8<Self>
fn load_array_ref_i16x8(self, val: &[i16; 8]) -> i16x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i16x8(self, a: i16x8<Self>) -> [i16; 8]
fn as_array_i16x8(self, a: i16x8<Self>) -> [i16; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i16x8(self, a: &i16x8<Self>) -> &[i16; 8]
fn as_array_ref_i16x8(self, a: &i16x8<Self>) -> &[i16; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i16x8(self, a: &mut i16x8<Self>) -> &mut [i16; 8]
fn as_array_mut_i16x8(self, a: &mut i16x8<Self>) -> &mut [i16; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i16x8(self, a: i16x8<Self>, dest: &mut [i16; 8])
fn store_array_i16x8(self, a: i16x8<Self>, dest: &mut [i16; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i16x8(self, a: u8x16<Self>) -> i16x8<Self>
fn cvt_from_bytes_i16x8(self, a: u8x16<Self>) -> i16x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i16x8(self, a: i16x8<Self>) -> u8x16<Self>
fn cvt_to_bytes_i16x8(self, a: i16x8<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i16x8<const SHIFT: usize>(
self,
a: i16x8<Self>,
b: i16x8<Self>,
) -> i16x8<Self>
fn slide_i16x8<const SHIFT: usize>( self, a: i16x8<Self>, b: i16x8<Self>, ) -> i16x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i16x8<const SHIFT: usize>(
self,
a: i16x8<Self>,
b: i16x8<Self>,
) -> i16x8<Self>
fn slide_within_blocks_i16x8<const SHIFT: usize>( self, a: i16x8<Self>, b: i16x8<Self>, ) -> i16x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn and_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn or_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn xor_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self>
fn shl_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn shlv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self>
fn shr_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn shrv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
fn simd_eq_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
fn simd_lt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
fn simd_le_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
fn simd_ge_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
fn simd_gt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn zip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn zip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn unzip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn unzip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i16x8(
self,
a: i16x8<Self>,
b: i16x8<Self>,
) -> (i16x8<Self>, i16x8<Self>)
fn interleave_i16x8( self, a: i16x8<Self>, b: i16x8<Self>, ) -> (i16x8<Self>, i16x8<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i16x8(
self,
a: i16x8<Self>,
b: i16x8<Self>,
) -> (i16x8<Self>, i16x8<Self>)
fn deinterleave_i16x8( self, a: i16x8<Self>, b: i16x8<Self>, ) -> (i16x8<Self>, i16x8<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i16x8(
self,
a: mask16x8<Self>,
b: i16x8<Self>,
c: i16x8<Self>,
) -> i16x8<Self>
fn select_i16x8( self, a: mask16x8<Self>, b: i16x8<Self>, c: i16x8<Self>, ) -> i16x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn min_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
fn max_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x16<Self>
fn combine_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x16<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn neg_i16x8(self, a: i16x8<Self>) -> i16x8<Self>
fn neg_i16x8(self, a: i16x8<Self>) -> i16x8<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i16x8(self, a: i16x8<Self>) -> u8x16<Self>
fn reinterpret_u8_i16x8(self, a: i16x8<Self>) -> u8x16<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i16x8(self, a: i16x8<Self>) -> u32x4<Self>
fn reinterpret_u32_i16x8(self, a: i16x8<Self>) -> u32x4<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_u16x8(self, val: u16) -> u16x8<Self>
fn splat_u16x8(self, val: u16) -> u16x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u16x8(self, val: [u16; 8]) -> u16x8<Self>
fn load_array_u16x8(self, val: [u16; 8]) -> u16x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u16x8(self, val: &[u16; 8]) -> u16x8<Self>
fn load_array_ref_u16x8(self, val: &[u16; 8]) -> u16x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u16x8(self, a: u16x8<Self>) -> [u16; 8]
fn as_array_u16x8(self, a: u16x8<Self>) -> [u16; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u16x8(self, a: &u16x8<Self>) -> &[u16; 8]
fn as_array_ref_u16x8(self, a: &u16x8<Self>) -> &[u16; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u16x8(self, a: &mut u16x8<Self>) -> &mut [u16; 8]
fn as_array_mut_u16x8(self, a: &mut u16x8<Self>) -> &mut [u16; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u16x8(self, a: u16x8<Self>, dest: &mut [u16; 8])
fn store_array_u16x8(self, a: u16x8<Self>, dest: &mut [u16; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u16x8(self, a: u8x16<Self>) -> u16x8<Self>
fn cvt_from_bytes_u16x8(self, a: u8x16<Self>) -> u16x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u16x8(self, a: u16x8<Self>) -> u8x16<Self>
fn cvt_to_bytes_u16x8(self, a: u16x8<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u16x8<const SHIFT: usize>(
self,
a: u16x8<Self>,
b: u16x8<Self>,
) -> u16x8<Self>
fn slide_u16x8<const SHIFT: usize>( self, a: u16x8<Self>, b: u16x8<Self>, ) -> u16x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u16x8<const SHIFT: usize>(
self,
a: u16x8<Self>,
b: u16x8<Self>,
) -> u16x8<Self>
fn slide_within_blocks_u16x8<const SHIFT: usize>( self, a: u16x8<Self>, b: u16x8<Self>, ) -> u16x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn add_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn sub_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn mul_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn and_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn or_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn xor_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self>
fn shl_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn shlv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self>
fn shr_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn shrv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
fn simd_eq_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
fn simd_lt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
fn simd_le_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
fn simd_ge_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
fn simd_gt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn zip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn zip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn unzip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn unzip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u16x8(
self,
a: u16x8<Self>,
b: u16x8<Self>,
) -> (u16x8<Self>, u16x8<Self>)
fn interleave_u16x8( self, a: u16x8<Self>, b: u16x8<Self>, ) -> (u16x8<Self>, u16x8<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u16x8(
self,
a: u16x8<Self>,
b: u16x8<Self>,
) -> (u16x8<Self>, u16x8<Self>)
fn deinterleave_u16x8( self, a: u16x8<Self>, b: u16x8<Self>, ) -> (u16x8<Self>, u16x8<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u16x8(
self,
a: mask16x8<Self>,
b: u16x8<Self>,
c: u16x8<Self>,
) -> u16x8<Self>
fn select_u16x8( self, a: mask16x8<Self>, b: u16x8<Self>, c: u16x8<Self>, ) -> u16x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn min_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
fn max_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x16<Self>
fn combine_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x16<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn reinterpret_u8_u16x8(self, a: u16x8<Self>) -> u8x16<Self>
fn reinterpret_u8_u16x8(self, a: u16x8<Self>) -> u8x16<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_u16x8(self, a: u16x8<Self>) -> u32x4<Self>
fn reinterpret_u32_u16x8(self, a: u16x8<Self>) -> u32x4<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_mask16x8(self, val: i16) -> mask16x8<Self>
fn splat_mask16x8(self, val: i16) -> mask16x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask16x8(self, val: [i16; 8]) -> mask16x8<Self>
fn load_array_mask16x8(self, val: [i16; 8]) -> mask16x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask16x8(self, val: &[i16; 8]) -> mask16x8<Self>
fn load_array_ref_mask16x8(self, val: &[i16; 8]) -> mask16x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask16x8(self, a: mask16x8<Self>) -> [i16; 8]
fn as_array_mask16x8(self, a: mask16x8<Self>) -> [i16; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask16x8(self, a: &mask16x8<Self>) -> &[i16; 8]
fn as_array_ref_mask16x8(self, a: &mask16x8<Self>) -> &[i16; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask16x8(self, a: &mut mask16x8<Self>) -> &mut [i16; 8]
fn as_array_mut_mask16x8(self, a: &mut mask16x8<Self>) -> &mut [i16; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask16x8(self, a: mask16x8<Self>, dest: &mut [i16; 8])
fn store_array_mask16x8(self, a: mask16x8<Self>, dest: &mut [i16; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask16x8(self, a: u8x16<Self>) -> mask16x8<Self>
fn cvt_from_bytes_mask16x8(self, a: u8x16<Self>) -> mask16x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask16x8(self, a: mask16x8<Self>) -> u8x16<Self>
fn cvt_to_bytes_mask16x8(self, a: mask16x8<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask16x8<const SHIFT: usize>(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x8<Self>
fn slide_mask16x8<const SHIFT: usize>( self, a: mask16x8<Self>, b: mask16x8<Self>, ) -> mask16x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask16x8<const SHIFT: usize>(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x8<Self>
fn slide_within_blocks_mask16x8<const SHIFT: usize>( self, a: mask16x8<Self>, b: mask16x8<Self>, ) -> mask16x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>
fn and_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>
Compute the logical AND of two masks.
Sourcefn or_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>
fn or_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>
fn xor_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask16x8(self, a: mask16x8<Self>) -> mask16x8<Self>
fn not_mask16x8(self, a: mask16x8<Self>) -> mask16x8<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
c: mask16x8<Self>,
) -> mask16x8<Self>
fn select_mask16x8( self, a: mask16x8<Self>, b: mask16x8<Self>, c: mask16x8<Self>, ) -> mask16x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x8<Self>
fn simd_eq_mask16x8( self, a: mask16x8<Self>, b: mask16x8<Self>, ) -> mask16x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask16x8(self, a: mask16x8<Self>) -> bool
fn any_true_mask16x8(self, a: mask16x8<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask16x8(self, a: mask16x8<Self>) -> bool
fn all_true_mask16x8(self, a: mask16x8<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask16x8(self, a: mask16x8<Self>) -> bool
fn any_false_mask16x8(self, a: mask16x8<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask16x8(self, a: mask16x8<Self>) -> bool
fn all_false_mask16x8(self, a: mask16x8<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn combine_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
) -> mask16x16<Self>
fn combine_mask16x8( self, a: mask16x8<Self>, b: mask16x8<Self>, ) -> mask16x16<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn splat_i32x4(self, val: i32) -> i32x4<Self>
fn splat_i32x4(self, val: i32) -> i32x4<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i32x4(self, val: [i32; 4]) -> i32x4<Self>
fn load_array_i32x4(self, val: [i32; 4]) -> i32x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i32x4(self, val: &[i32; 4]) -> i32x4<Self>
fn load_array_ref_i32x4(self, val: &[i32; 4]) -> i32x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i32x4(self, a: i32x4<Self>) -> [i32; 4]
fn as_array_i32x4(self, a: i32x4<Self>) -> [i32; 4]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i32x4(self, a: &i32x4<Self>) -> &[i32; 4]
fn as_array_ref_i32x4(self, a: &i32x4<Self>) -> &[i32; 4]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i32x4(self, a: &mut i32x4<Self>) -> &mut [i32; 4]
fn as_array_mut_i32x4(self, a: &mut i32x4<Self>) -> &mut [i32; 4]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i32x4(self, a: i32x4<Self>, dest: &mut [i32; 4])
fn store_array_i32x4(self, a: i32x4<Self>, dest: &mut [i32; 4])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i32x4(self, a: u8x16<Self>) -> i32x4<Self>
fn cvt_from_bytes_i32x4(self, a: u8x16<Self>) -> i32x4<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i32x4(self, a: i32x4<Self>) -> u8x16<Self>
fn cvt_to_bytes_i32x4(self, a: i32x4<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i32x4<const SHIFT: usize>(
self,
a: i32x4<Self>,
b: i32x4<Self>,
) -> i32x4<Self>
fn slide_i32x4<const SHIFT: usize>( self, a: i32x4<Self>, b: i32x4<Self>, ) -> i32x4<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i32x4<const SHIFT: usize>(
self,
a: i32x4<Self>,
b: i32x4<Self>,
) -> i32x4<Self>
fn slide_within_blocks_i32x4<const SHIFT: usize>( self, a: i32x4<Self>, b: i32x4<Self>, ) -> i32x4<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn add_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn sub_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn mul_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn and_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn or_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn xor_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self>
fn shl_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn shlv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self>
fn shr_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn shrv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
fn simd_eq_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
fn simd_lt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
fn simd_le_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
fn simd_ge_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
fn simd_gt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn zip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn zip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn unzip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn unzip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i32x4(
self,
a: i32x4<Self>,
b: i32x4<Self>,
) -> (i32x4<Self>, i32x4<Self>)
fn interleave_i32x4( self, a: i32x4<Self>, b: i32x4<Self>, ) -> (i32x4<Self>, i32x4<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i32x4(
self,
a: i32x4<Self>,
b: i32x4<Self>,
) -> (i32x4<Self>, i32x4<Self>)
fn deinterleave_i32x4( self, a: i32x4<Self>, b: i32x4<Self>, ) -> (i32x4<Self>, i32x4<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i32x4(
self,
a: mask32x4<Self>,
b: i32x4<Self>,
c: i32x4<Self>,
) -> i32x4<Self>
fn select_i32x4( self, a: mask32x4<Self>, b: i32x4<Self>, c: i32x4<Self>, ) -> i32x4<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn min_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
fn max_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x8<Self>
fn combine_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x8<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn neg_i32x4(self, a: i32x4<Self>) -> i32x4<Self>
fn neg_i32x4(self, a: i32x4<Self>) -> i32x4<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i32x4(self, a: i32x4<Self>) -> u8x16<Self>
fn reinterpret_u8_i32x4(self, a: i32x4<Self>) -> u8x16<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i32x4(self, a: i32x4<Self>) -> u32x4<Self>
fn reinterpret_u32_i32x4(self, a: i32x4<Self>) -> u32x4<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_f32_i32x4(self, a: i32x4<Self>) -> f32x4<Self>
fn cvt_f32_i32x4(self, a: i32x4<Self>) -> f32x4<Self>
Convert each signed 32-bit integer element to a floating-point value.
Values that cannot be exactly represented are rounded to the nearest representable value.
Sourcefn splat_u32x4(self, val: u32) -> u32x4<Self>
fn splat_u32x4(self, val: u32) -> u32x4<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u32x4(self, val: [u32; 4]) -> u32x4<Self>
fn load_array_u32x4(self, val: [u32; 4]) -> u32x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u32x4(self, val: &[u32; 4]) -> u32x4<Self>
fn load_array_ref_u32x4(self, val: &[u32; 4]) -> u32x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u32x4(self, a: u32x4<Self>) -> [u32; 4]
fn as_array_u32x4(self, a: u32x4<Self>) -> [u32; 4]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u32x4(self, a: &u32x4<Self>) -> &[u32; 4]
fn as_array_ref_u32x4(self, a: &u32x4<Self>) -> &[u32; 4]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u32x4(self, a: &mut u32x4<Self>) -> &mut [u32; 4]
fn as_array_mut_u32x4(self, a: &mut u32x4<Self>) -> &mut [u32; 4]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u32x4(self, a: u32x4<Self>, dest: &mut [u32; 4])
fn store_array_u32x4(self, a: u32x4<Self>, dest: &mut [u32; 4])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u32x4(self, a: u8x16<Self>) -> u32x4<Self>
fn cvt_from_bytes_u32x4(self, a: u8x16<Self>) -> u32x4<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u32x4(self, a: u32x4<Self>) -> u8x16<Self>
fn cvt_to_bytes_u32x4(self, a: u32x4<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u32x4<const SHIFT: usize>(
self,
a: u32x4<Self>,
b: u32x4<Self>,
) -> u32x4<Self>
fn slide_u32x4<const SHIFT: usize>( self, a: u32x4<Self>, b: u32x4<Self>, ) -> u32x4<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u32x4<const SHIFT: usize>(
self,
a: u32x4<Self>,
b: u32x4<Self>,
) -> u32x4<Self>
fn slide_within_blocks_u32x4<const SHIFT: usize>( self, a: u32x4<Self>, b: u32x4<Self>, ) -> u32x4<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn add_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn sub_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn mul_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn and_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn or_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn xor_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self>
fn shl_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn shlv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self>
fn shr_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn shrv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
fn simd_eq_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
fn simd_lt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
fn simd_le_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
fn simd_ge_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
fn simd_gt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn zip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn zip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn unzip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn unzip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u32x4(
self,
a: u32x4<Self>,
b: u32x4<Self>,
) -> (u32x4<Self>, u32x4<Self>)
fn interleave_u32x4( self, a: u32x4<Self>, b: u32x4<Self>, ) -> (u32x4<Self>, u32x4<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u32x4(
self,
a: u32x4<Self>,
b: u32x4<Self>,
) -> (u32x4<Self>, u32x4<Self>)
fn deinterleave_u32x4( self, a: u32x4<Self>, b: u32x4<Self>, ) -> (u32x4<Self>, u32x4<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u32x4(
self,
a: mask32x4<Self>,
b: u32x4<Self>,
c: u32x4<Self>,
) -> u32x4<Self>
fn select_u32x4( self, a: mask32x4<Self>, b: u32x4<Self>, c: u32x4<Self>, ) -> u32x4<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn min_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
fn max_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x8<Self>
fn combine_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x8<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn reinterpret_u8_u32x4(self, a: u32x4<Self>) -> u8x16<Self>
fn reinterpret_u8_u32x4(self, a: u32x4<Self>) -> u8x16<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_f32_u32x4(self, a: u32x4<Self>) -> f32x4<Self>
fn cvt_f32_u32x4(self, a: u32x4<Self>) -> f32x4<Self>
Convert each unsigned 32-bit integer element to a floating-point value.
Values that cannot be exactly represented are rounded to the nearest representable value.
Sourcefn splat_mask32x4(self, val: i32) -> mask32x4<Self>
fn splat_mask32x4(self, val: i32) -> mask32x4<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask32x4(self, val: [i32; 4]) -> mask32x4<Self>
fn load_array_mask32x4(self, val: [i32; 4]) -> mask32x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask32x4(self, val: &[i32; 4]) -> mask32x4<Self>
fn load_array_ref_mask32x4(self, val: &[i32; 4]) -> mask32x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask32x4(self, a: mask32x4<Self>) -> [i32; 4]
fn as_array_mask32x4(self, a: mask32x4<Self>) -> [i32; 4]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask32x4(self, a: &mask32x4<Self>) -> &[i32; 4]
fn as_array_ref_mask32x4(self, a: &mask32x4<Self>) -> &[i32; 4]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask32x4(self, a: &mut mask32x4<Self>) -> &mut [i32; 4]
fn as_array_mut_mask32x4(self, a: &mut mask32x4<Self>) -> &mut [i32; 4]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask32x4(self, a: mask32x4<Self>, dest: &mut [i32; 4])
fn store_array_mask32x4(self, a: mask32x4<Self>, dest: &mut [i32; 4])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask32x4(self, a: u8x16<Self>) -> mask32x4<Self>
fn cvt_from_bytes_mask32x4(self, a: u8x16<Self>) -> mask32x4<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask32x4(self, a: mask32x4<Self>) -> u8x16<Self>
fn cvt_to_bytes_mask32x4(self, a: mask32x4<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask32x4<const SHIFT: usize>(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x4<Self>
fn slide_mask32x4<const SHIFT: usize>( self, a: mask32x4<Self>, b: mask32x4<Self>, ) -> mask32x4<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask32x4<const SHIFT: usize>(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x4<Self>
fn slide_within_blocks_mask32x4<const SHIFT: usize>( self, a: mask32x4<Self>, b: mask32x4<Self>, ) -> mask32x4<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>
fn and_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>
Compute the logical AND of two masks.
Sourcefn or_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>
fn or_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>
fn xor_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask32x4(self, a: mask32x4<Self>) -> mask32x4<Self>
fn not_mask32x4(self, a: mask32x4<Self>) -> mask32x4<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
c: mask32x4<Self>,
) -> mask32x4<Self>
fn select_mask32x4( self, a: mask32x4<Self>, b: mask32x4<Self>, c: mask32x4<Self>, ) -> mask32x4<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x4<Self>
fn simd_eq_mask32x4( self, a: mask32x4<Self>, b: mask32x4<Self>, ) -> mask32x4<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask32x4(self, a: mask32x4<Self>) -> bool
fn any_true_mask32x4(self, a: mask32x4<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask32x4(self, a: mask32x4<Self>) -> bool
fn all_true_mask32x4(self, a: mask32x4<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask32x4(self, a: mask32x4<Self>) -> bool
fn any_false_mask32x4(self, a: mask32x4<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask32x4(self, a: mask32x4<Self>) -> bool
fn all_false_mask32x4(self, a: mask32x4<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn combine_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
) -> mask32x8<Self>
fn combine_mask32x4( self, a: mask32x4<Self>, b: mask32x4<Self>, ) -> mask32x8<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn splat_f64x2(self, val: f64) -> f64x2<Self>
fn splat_f64x2(self, val: f64) -> f64x2<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_f64x2(self, val: [f64; 2]) -> f64x2<Self>
fn load_array_f64x2(self, val: [f64; 2]) -> f64x2<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_f64x2(self, val: &[f64; 2]) -> f64x2<Self>
fn load_array_ref_f64x2(self, val: &[f64; 2]) -> f64x2<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_f64x2(self, a: f64x2<Self>) -> [f64; 2]
fn as_array_f64x2(self, a: f64x2<Self>) -> [f64; 2]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_f64x2(self, a: &f64x2<Self>) -> &[f64; 2]
fn as_array_ref_f64x2(self, a: &f64x2<Self>) -> &[f64; 2]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_f64x2(self, a: &mut f64x2<Self>) -> &mut [f64; 2]
fn as_array_mut_f64x2(self, a: &mut f64x2<Self>) -> &mut [f64; 2]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_f64x2(self, a: f64x2<Self>, dest: &mut [f64; 2])
fn store_array_f64x2(self, a: f64x2<Self>, dest: &mut [f64; 2])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_f64x2(self, a: u8x16<Self>) -> f64x2<Self>
fn cvt_from_bytes_f64x2(self, a: u8x16<Self>) -> f64x2<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_f64x2(self, a: f64x2<Self>) -> u8x16<Self>
fn cvt_to_bytes_f64x2(self, a: f64x2<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_f64x2<const SHIFT: usize>(
self,
a: f64x2<Self>,
b: f64x2<Self>,
) -> f64x2<Self>
fn slide_f64x2<const SHIFT: usize>( self, a: f64x2<Self>, b: f64x2<Self>, ) -> f64x2<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_f64x2<const SHIFT: usize>(
self,
a: f64x2<Self>,
b: f64x2<Self>,
) -> f64x2<Self>
fn slide_within_blocks_f64x2<const SHIFT: usize>( self, a: f64x2<Self>, b: f64x2<Self>, ) -> f64x2<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn sqrt_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
fn sqrt_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
Compute the square root of each element.
Negative elements other than -0.0 will become NaN.
Sourcefn add_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn add_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Add two vectors element-wise.
Sourcefn sub_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn sub_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Subtract two vectors element-wise.
Sourcefn mul_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn mul_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Multiply two vectors element-wise.
Sourcefn div_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn div_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Divide two vectors element-wise.
Sourcefn copysign_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn copysign_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Return a vector with the magnitude of a and the sign of b for each element.
This operation copies the sign bit, so if an input element is NaN, the output element will be a NaN with the same payload and a copied sign bit.
Sourcefn simd_eq_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
fn simd_eq_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
fn simd_lt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
fn simd_le_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
fn simd_ge_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
fn simd_gt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn zip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn zip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn unzip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn unzip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_f64x2(
self,
a: f64x2<Self>,
b: f64x2<Self>,
) -> (f64x2<Self>, f64x2<Self>)
fn interleave_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, ) -> (f64x2<Self>, f64x2<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_f64x2(
self,
a: f64x2<Self>,
b: f64x2<Self>,
) -> (f64x2<Self>, f64x2<Self>)
fn deinterleave_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, ) -> (f64x2<Self>, f64x2<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn max_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn max_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Return the element-wise maximum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See max_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn min_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn min_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Return the element-wise minimum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See min_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn max_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn max_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Return the element-wise maximum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn min_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
fn min_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>
Return the element-wise minimum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn mul_add_f64x2(
self,
a: f64x2<Self>,
b: f64x2<Self>,
c: f64x2<Self>,
) -> f64x2<Self>
fn mul_add_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, c: f64x2<Self>, ) -> f64x2<Self>
Compute (a * b) + c (fused multiply-add) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by an add, which will result in two rounding errors.
Sourcefn mul_sub_f64x2(
self,
a: f64x2<Self>,
b: f64x2<Self>,
c: f64x2<Self>,
) -> f64x2<Self>
fn mul_sub_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, c: f64x2<Self>, ) -> f64x2<Self>
Compute (a * b) - c (fused multiply-subtract) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by a subtract, which will result in two rounding errors.
Sourcefn floor_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
fn floor_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
Return the largest integer less than or equal to each element, that is, round towards negative infinity.
Sourcefn ceil_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
fn ceil_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.
Sourcefn round_ties_even_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
fn round_ties_even_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
Round each element to the nearest integer, with ties rounding to the nearest even integer.
There is no corresponding round operation. Rust’s round operation rounds ties away from zero, a behavior it inherited from C. That behavior is not implemented across all platforms, whereas round-ties-even is.
Sourcefn fract_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
fn fract_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
Return the fractional part of each element.
This is equivalent to a - a.trunc().
Sourcefn trunc_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
fn trunc_f64x2(self, a: f64x2<Self>) -> f64x2<Self>
Return the integer part of each element, rounding towards zero.
Sourcefn select_f64x2(
self,
a: mask64x2<Self>,
b: f64x2<Self>,
c: f64x2<Self>,
) -> f64x2<Self>
fn select_f64x2( self, a: mask64x2<Self>, b: f64x2<Self>, c: f64x2<Self>, ) -> f64x2<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn combine_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x4<Self>
fn combine_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x4<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn reinterpret_f32_f64x2(self, a: f64x2<Self>) -> f32x4<Self>
fn reinterpret_f32_f64x2(self, a: f64x2<Self>) -> f32x4<Self>
Reinterpret the bits of this vector as a vector of f32 elements.
The number of elements in the result is twice that of the input.
Sourcefn splat_mask64x2(self, val: i64) -> mask64x2<Self>
fn splat_mask64x2(self, val: i64) -> mask64x2<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask64x2(self, val: [i64; 2]) -> mask64x2<Self>
fn load_array_mask64x2(self, val: [i64; 2]) -> mask64x2<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask64x2(self, val: &[i64; 2]) -> mask64x2<Self>
fn load_array_ref_mask64x2(self, val: &[i64; 2]) -> mask64x2<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask64x2(self, a: mask64x2<Self>) -> [i64; 2]
fn as_array_mask64x2(self, a: mask64x2<Self>) -> [i64; 2]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask64x2(self, a: &mask64x2<Self>) -> &[i64; 2]
fn as_array_ref_mask64x2(self, a: &mask64x2<Self>) -> &[i64; 2]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask64x2(self, a: &mut mask64x2<Self>) -> &mut [i64; 2]
fn as_array_mut_mask64x2(self, a: &mut mask64x2<Self>) -> &mut [i64; 2]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask64x2(self, a: mask64x2<Self>, dest: &mut [i64; 2])
fn store_array_mask64x2(self, a: mask64x2<Self>, dest: &mut [i64; 2])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask64x2(self, a: u8x16<Self>) -> mask64x2<Self>
fn cvt_from_bytes_mask64x2(self, a: u8x16<Self>) -> mask64x2<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask64x2(self, a: mask64x2<Self>) -> u8x16<Self>
fn cvt_to_bytes_mask64x2(self, a: mask64x2<Self>) -> u8x16<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask64x2<const SHIFT: usize>(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x2<Self>
fn slide_mask64x2<const SHIFT: usize>( self, a: mask64x2<Self>, b: mask64x2<Self>, ) -> mask64x2<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask64x2<const SHIFT: usize>(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x2<Self>
fn slide_within_blocks_mask64x2<const SHIFT: usize>( self, a: mask64x2<Self>, b: mask64x2<Self>, ) -> mask64x2<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>
fn and_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>
Compute the logical AND of two masks.
Sourcefn or_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>
fn or_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>
fn xor_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask64x2(self, a: mask64x2<Self>) -> mask64x2<Self>
fn not_mask64x2(self, a: mask64x2<Self>) -> mask64x2<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
c: mask64x2<Self>,
) -> mask64x2<Self>
fn select_mask64x2( self, a: mask64x2<Self>, b: mask64x2<Self>, c: mask64x2<Self>, ) -> mask64x2<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x2<Self>
fn simd_eq_mask64x2( self, a: mask64x2<Self>, b: mask64x2<Self>, ) -> mask64x2<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask64x2(self, a: mask64x2<Self>) -> bool
fn any_true_mask64x2(self, a: mask64x2<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask64x2(self, a: mask64x2<Self>) -> bool
fn all_true_mask64x2(self, a: mask64x2<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask64x2(self, a: mask64x2<Self>) -> bool
fn any_false_mask64x2(self, a: mask64x2<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask64x2(self, a: mask64x2<Self>) -> bool
fn all_false_mask64x2(self, a: mask64x2<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn combine_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
) -> mask64x4<Self>
fn combine_mask64x2( self, a: mask64x2<Self>, b: mask64x2<Self>, ) -> mask64x4<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn splat_f32x8(self, val: f32) -> f32x8<Self>
fn splat_f32x8(self, val: f32) -> f32x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_f32x8(self, val: [f32; 8]) -> f32x8<Self>
fn load_array_f32x8(self, val: [f32; 8]) -> f32x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_f32x8(self, val: &[f32; 8]) -> f32x8<Self>
fn load_array_ref_f32x8(self, val: &[f32; 8]) -> f32x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_f32x8(self, a: f32x8<Self>) -> [f32; 8]
fn as_array_f32x8(self, a: f32x8<Self>) -> [f32; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_f32x8(self, a: &f32x8<Self>) -> &[f32; 8]
fn as_array_ref_f32x8(self, a: &f32x8<Self>) -> &[f32; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_f32x8(self, a: &mut f32x8<Self>) -> &mut [f32; 8]
fn as_array_mut_f32x8(self, a: &mut f32x8<Self>) -> &mut [f32; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_f32x8(self, a: f32x8<Self>, dest: &mut [f32; 8])
fn store_array_f32x8(self, a: f32x8<Self>, dest: &mut [f32; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_f32x8(self, a: u8x32<Self>) -> f32x8<Self>
fn cvt_from_bytes_f32x8(self, a: u8x32<Self>) -> f32x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_f32x8(self, a: f32x8<Self>) -> u8x32<Self>
fn cvt_to_bytes_f32x8(self, a: f32x8<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_f32x8<const SHIFT: usize>(
self,
a: f32x8<Self>,
b: f32x8<Self>,
) -> f32x8<Self>
fn slide_f32x8<const SHIFT: usize>( self, a: f32x8<Self>, b: f32x8<Self>, ) -> f32x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_f32x8<const SHIFT: usize>(
self,
a: f32x8<Self>,
b: f32x8<Self>,
) -> f32x8<Self>
fn slide_within_blocks_f32x8<const SHIFT: usize>( self, a: f32x8<Self>, b: f32x8<Self>, ) -> f32x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn sqrt_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
fn sqrt_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
Compute the square root of each element.
Negative elements other than -0.0 will become NaN.
Sourcefn add_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn add_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Add two vectors element-wise.
Sourcefn sub_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn sub_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Subtract two vectors element-wise.
Sourcefn mul_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn mul_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Multiply two vectors element-wise.
Sourcefn div_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn div_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Divide two vectors element-wise.
Sourcefn copysign_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn copysign_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Return a vector with the magnitude of a and the sign of b for each element.
This operation copies the sign bit, so if an input element is NaN, the output element will be a NaN with the same payload and a copied sign bit.
Sourcefn simd_eq_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
fn simd_eq_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
fn simd_lt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
fn simd_le_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
fn simd_ge_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
fn simd_gt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn zip_low_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn zip_high_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn unzip_low_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn unzip_high_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_f32x8(
self,
a: f32x8<Self>,
b: f32x8<Self>,
) -> (f32x8<Self>, f32x8<Self>)
fn interleave_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, ) -> (f32x8<Self>, f32x8<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_f32x8(
self,
a: f32x8<Self>,
b: f32x8<Self>,
) -> (f32x8<Self>, f32x8<Self>)
fn deinterleave_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, ) -> (f32x8<Self>, f32x8<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn max_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn max_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Return the element-wise maximum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See max_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn min_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn min_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Return the element-wise minimum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See min_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn max_precise_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn max_precise_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Return the element-wise maximum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn min_precise_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
fn min_precise_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>
Return the element-wise minimum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn mul_add_f32x8(
self,
a: f32x8<Self>,
b: f32x8<Self>,
c: f32x8<Self>,
) -> f32x8<Self>
fn mul_add_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, c: f32x8<Self>, ) -> f32x8<Self>
Compute (a * b) + c (fused multiply-add) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by an add, which will result in two rounding errors.
Sourcefn mul_sub_f32x8(
self,
a: f32x8<Self>,
b: f32x8<Self>,
c: f32x8<Self>,
) -> f32x8<Self>
fn mul_sub_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, c: f32x8<Self>, ) -> f32x8<Self>
Compute (a * b) - c (fused multiply-subtract) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by a subtract, which will result in two rounding errors.
Sourcefn floor_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
fn floor_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
Return the largest integer less than or equal to each element, that is, round towards negative infinity.
Sourcefn ceil_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
fn ceil_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.
Sourcefn round_ties_even_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
fn round_ties_even_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
Round each element to the nearest integer, with ties rounding to the nearest even integer.
There is no corresponding round operation. Rust’s round operation rounds ties away from zero, a behavior it inherited from C. That behavior is not implemented across all platforms, whereas round-ties-even is.
Sourcefn fract_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
fn fract_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
Return the fractional part of each element.
This is equivalent to a - a.trunc().
Sourcefn trunc_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
fn trunc_f32x8(self, a: f32x8<Self>) -> f32x8<Self>
Return the integer part of each element, rounding towards zero.
Sourcefn select_f32x8(
self,
a: mask32x8<Self>,
b: f32x8<Self>,
c: f32x8<Self>,
) -> f32x8<Self>
fn select_f32x8( self, a: mask32x8<Self>, b: f32x8<Self>, c: f32x8<Self>, ) -> f32x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn combine_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x16<Self>
fn combine_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x16<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_f32x8(self, a: f32x8<Self>) -> (f32x4<Self>, f32x4<Self>)
fn split_f32x8(self, a: f32x8<Self>) -> (f32x4<Self>, f32x4<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn reinterpret_f64_f32x8(self, a: f32x8<Self>) -> f64x4<Self>
fn reinterpret_f64_f32x8(self, a: f32x8<Self>) -> f64x4<Self>
Reinterpret the bits of this vector as a vector of f64 elements.
The number of elements in the result is half that of the input.
Sourcefn reinterpret_i32_f32x8(self, a: f32x8<Self>) -> i32x8<Self>
fn reinterpret_i32_f32x8(self, a: f32x8<Self>) -> i32x8<Self>
Reinterpret the bits of this vector as a vector of i32 elements.
This is a bitwise reinterpretation only, and does not perform any conversions.
Sourcefn reinterpret_u8_f32x8(self, a: f32x8<Self>) -> u8x32<Self>
fn reinterpret_u8_f32x8(self, a: f32x8<Self>) -> u8x32<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_f32x8(self, a: f32x8<Self>) -> u32x8<Self>
fn reinterpret_u32_f32x8(self, a: f32x8<Self>) -> u32x8<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_u32_f32x8(self, a: f32x8<Self>) -> u32x8<Self>
fn cvt_u32_f32x8(self, a: f32x8<Self>) -> u32x8<Self>
Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.
Out-of-range values or NaN will produce implementation-defined results.
On x86 platforms, this operation will still be slower than converting to i32, because there is no native instruction for converting to u32 (at least until AVX-512, which is currently not supported).
If you know your values fit within range of an i32, you should convert to an i32 and cast to your desired datatype afterwards.
Sourcefn cvt_u32_precise_f32x8(self, a: f32x8<Self>) -> u32x8<Self>
fn cvt_u32_precise_f32x8(self, a: f32x8<Self>) -> u32x8<Self>
Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.
Out-of-range values are saturated to the closest in-range value. NaN becomes 0.
Sourcefn cvt_i32_f32x8(self, a: f32x8<Self>) -> i32x8<Self>
fn cvt_i32_f32x8(self, a: f32x8<Self>) -> i32x8<Self>
Convert each floating-point element to a signed 32-bit integer, truncating towards zero.
Out-of-range values or NaN will produce implementation-defined results.
Sourcefn cvt_i32_precise_f32x8(self, a: f32x8<Self>) -> i32x8<Self>
fn cvt_i32_precise_f32x8(self, a: f32x8<Self>) -> i32x8<Self>
Convert each floating-point element to a signed 32-bit integer, truncating towards zero.
Out-of-range values are saturated to the closest in-range value. NaN becomes 0.
Sourcefn splat_i8x32(self, val: i8) -> i8x32<Self>
fn splat_i8x32(self, val: i8) -> i8x32<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i8x32(self, val: [i8; 32]) -> i8x32<Self>
fn load_array_i8x32(self, val: [i8; 32]) -> i8x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i8x32(self, val: &[i8; 32]) -> i8x32<Self>
fn load_array_ref_i8x32(self, val: &[i8; 32]) -> i8x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i8x32(self, a: i8x32<Self>) -> [i8; 32]
fn as_array_i8x32(self, a: i8x32<Self>) -> [i8; 32]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i8x32(self, a: &i8x32<Self>) -> &[i8; 32]
fn as_array_ref_i8x32(self, a: &i8x32<Self>) -> &[i8; 32]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i8x32(self, a: &mut i8x32<Self>) -> &mut [i8; 32]
fn as_array_mut_i8x32(self, a: &mut i8x32<Self>) -> &mut [i8; 32]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i8x32(self, a: i8x32<Self>, dest: &mut [i8; 32])
fn store_array_i8x32(self, a: i8x32<Self>, dest: &mut [i8; 32])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i8x32(self, a: u8x32<Self>) -> i8x32<Self>
fn cvt_from_bytes_i8x32(self, a: u8x32<Self>) -> i8x32<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i8x32(self, a: i8x32<Self>) -> u8x32<Self>
fn cvt_to_bytes_i8x32(self, a: i8x32<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i8x32<const SHIFT: usize>(
self,
a: i8x32<Self>,
b: i8x32<Self>,
) -> i8x32<Self>
fn slide_i8x32<const SHIFT: usize>( self, a: i8x32<Self>, b: i8x32<Self>, ) -> i8x32<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i8x32<const SHIFT: usize>(
self,
a: i8x32<Self>,
b: i8x32<Self>,
) -> i8x32<Self>
fn slide_within_blocks_i8x32<const SHIFT: usize>( self, a: i8x32<Self>, b: i8x32<Self>, ) -> i8x32<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn mul_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn and_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn or_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn xor_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self>
fn shl_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn shlv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self>
fn shr_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn shrv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
fn simd_eq_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
fn simd_lt_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
fn simd_le_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
fn simd_ge_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
fn simd_gt_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn zip_low_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn zip_high_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn unzip_low_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn unzip_high_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i8x32(
self,
a: i8x32<Self>,
b: i8x32<Self>,
) -> (i8x32<Self>, i8x32<Self>)
fn interleave_i8x32( self, a: i8x32<Self>, b: i8x32<Self>, ) -> (i8x32<Self>, i8x32<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i8x32(
self,
a: i8x32<Self>,
b: i8x32<Self>,
) -> (i8x32<Self>, i8x32<Self>)
fn deinterleave_i8x32( self, a: i8x32<Self>, b: i8x32<Self>, ) -> (i8x32<Self>, i8x32<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i8x32(
self,
a: mask8x32<Self>,
b: i8x32<Self>,
c: i8x32<Self>,
) -> i8x32<Self>
fn select_i8x32( self, a: mask8x32<Self>, b: i8x32<Self>, c: i8x32<Self>, ) -> i8x32<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn min_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
fn max_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x64<Self>
fn combine_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x64<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_i8x32(self, a: i8x32<Self>) -> (i8x16<Self>, i8x16<Self>)
fn split_i8x32(self, a: i8x32<Self>) -> (i8x16<Self>, i8x16<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn neg_i8x32(self, a: i8x32<Self>) -> i8x32<Self>
fn neg_i8x32(self, a: i8x32<Self>) -> i8x32<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i8x32(self, a: i8x32<Self>) -> u8x32<Self>
fn reinterpret_u8_i8x32(self, a: i8x32<Self>) -> u8x32<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i8x32(self, a: i8x32<Self>) -> u32x8<Self>
fn reinterpret_u32_i8x32(self, a: i8x32<Self>) -> u32x8<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_u8x32(self, val: u8) -> u8x32<Self>
fn splat_u8x32(self, val: u8) -> u8x32<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u8x32(self, val: [u8; 32]) -> u8x32<Self>
fn load_array_u8x32(self, val: [u8; 32]) -> u8x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u8x32(self, val: &[u8; 32]) -> u8x32<Self>
fn load_array_ref_u8x32(self, val: &[u8; 32]) -> u8x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u8x32(self, a: u8x32<Self>) -> [u8; 32]
fn as_array_u8x32(self, a: u8x32<Self>) -> [u8; 32]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u8x32(self, a: &u8x32<Self>) -> &[u8; 32]
fn as_array_ref_u8x32(self, a: &u8x32<Self>) -> &[u8; 32]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u8x32(self, a: &mut u8x32<Self>) -> &mut [u8; 32]
fn as_array_mut_u8x32(self, a: &mut u8x32<Self>) -> &mut [u8; 32]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u8x32(self, a: u8x32<Self>, dest: &mut [u8; 32])
fn store_array_u8x32(self, a: u8x32<Self>, dest: &mut [u8; 32])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u8x32(self, a: u8x32<Self>) -> u8x32<Self>
fn cvt_from_bytes_u8x32(self, a: u8x32<Self>) -> u8x32<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u8x32(self, a: u8x32<Self>) -> u8x32<Self>
fn cvt_to_bytes_u8x32(self, a: u8x32<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u8x32<const SHIFT: usize>(
self,
a: u8x32<Self>,
b: u8x32<Self>,
) -> u8x32<Self>
fn slide_u8x32<const SHIFT: usize>( self, a: u8x32<Self>, b: u8x32<Self>, ) -> u8x32<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u8x32<const SHIFT: usize>(
self,
a: u8x32<Self>,
b: u8x32<Self>,
) -> u8x32<Self>
fn slide_within_blocks_u8x32<const SHIFT: usize>( self, a: u8x32<Self>, b: u8x32<Self>, ) -> u8x32<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn add_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn sub_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn mul_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn and_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn or_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn xor_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_u8x32(self, a: u8x32<Self>, shift: u32) -> u8x32<Self>
fn shl_u8x32(self, a: u8x32<Self>, shift: u32) -> u8x32<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn shlv_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u8x32(self, a: u8x32<Self>, shift: u32) -> u8x32<Self>
fn shr_u8x32(self, a: u8x32<Self>, shift: u32) -> u8x32<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn shrv_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
fn simd_eq_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
fn simd_lt_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
fn simd_le_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
fn simd_ge_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
fn simd_gt_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn zip_low_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn zip_high_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn unzip_low_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn unzip_high_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u8x32(
self,
a: u8x32<Self>,
b: u8x32<Self>,
) -> (u8x32<Self>, u8x32<Self>)
fn interleave_u8x32( self, a: u8x32<Self>, b: u8x32<Self>, ) -> (u8x32<Self>, u8x32<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u8x32(
self,
a: u8x32<Self>,
b: u8x32<Self>,
) -> (u8x32<Self>, u8x32<Self>)
fn deinterleave_u8x32( self, a: u8x32<Self>, b: u8x32<Self>, ) -> (u8x32<Self>, u8x32<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u8x32(
self,
a: mask8x32<Self>,
b: u8x32<Self>,
c: u8x32<Self>,
) -> u8x32<Self>
fn select_u8x32( self, a: mask8x32<Self>, b: u8x32<Self>, c: u8x32<Self>, ) -> u8x32<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn min_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
fn max_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x64<Self>
fn combine_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x64<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_u8x32(self, a: u8x32<Self>) -> (u8x16<Self>, u8x16<Self>)
fn split_u8x32(self, a: u8x32<Self>) -> (u8x16<Self>, u8x16<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn widen_u8x32(self, a: u8x32<Self>) -> u16x32<Self>
fn widen_u8x32(self, a: u8x32<Self>) -> u16x32<Self>
Zero-extend each element to a wider integer type.
The number of elements in the result is half that of the input.
Sourcefn reinterpret_u32_u8x32(self, a: u8x32<Self>) -> u32x8<Self>
fn reinterpret_u32_u8x32(self, a: u8x32<Self>) -> u32x8<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_mask8x32(self, val: i8) -> mask8x32<Self>
fn splat_mask8x32(self, val: i8) -> mask8x32<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask8x32(self, val: [i8; 32]) -> mask8x32<Self>
fn load_array_mask8x32(self, val: [i8; 32]) -> mask8x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask8x32(self, val: &[i8; 32]) -> mask8x32<Self>
fn load_array_ref_mask8x32(self, val: &[i8; 32]) -> mask8x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask8x32(self, a: mask8x32<Self>) -> [i8; 32]
fn as_array_mask8x32(self, a: mask8x32<Self>) -> [i8; 32]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask8x32(self, a: &mask8x32<Self>) -> &[i8; 32]
fn as_array_ref_mask8x32(self, a: &mask8x32<Self>) -> &[i8; 32]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask8x32(self, a: &mut mask8x32<Self>) -> &mut [i8; 32]
fn as_array_mut_mask8x32(self, a: &mut mask8x32<Self>) -> &mut [i8; 32]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask8x32(self, a: mask8x32<Self>, dest: &mut [i8; 32])
fn store_array_mask8x32(self, a: mask8x32<Self>, dest: &mut [i8; 32])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask8x32(self, a: u8x32<Self>) -> mask8x32<Self>
fn cvt_from_bytes_mask8x32(self, a: u8x32<Self>) -> mask8x32<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask8x32(self, a: mask8x32<Self>) -> u8x32<Self>
fn cvt_to_bytes_mask8x32(self, a: mask8x32<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask8x32<const SHIFT: usize>(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x32<Self>
fn slide_mask8x32<const SHIFT: usize>( self, a: mask8x32<Self>, b: mask8x32<Self>, ) -> mask8x32<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask8x32<const SHIFT: usize>(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x32<Self>
fn slide_within_blocks_mask8x32<const SHIFT: usize>( self, a: mask8x32<Self>, b: mask8x32<Self>, ) -> mask8x32<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>
fn and_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>
Compute the logical AND of two masks.
Sourcefn or_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>
fn or_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>
fn xor_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask8x32(self, a: mask8x32<Self>) -> mask8x32<Self>
fn not_mask8x32(self, a: mask8x32<Self>) -> mask8x32<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask8x32(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
c: mask8x32<Self>,
) -> mask8x32<Self>
fn select_mask8x32( self, a: mask8x32<Self>, b: mask8x32<Self>, c: mask8x32<Self>, ) -> mask8x32<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask8x32(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x32<Self>
fn simd_eq_mask8x32( self, a: mask8x32<Self>, b: mask8x32<Self>, ) -> mask8x32<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask8x32(self, a: mask8x32<Self>) -> bool
fn any_true_mask8x32(self, a: mask8x32<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask8x32(self, a: mask8x32<Self>) -> bool
fn all_true_mask8x32(self, a: mask8x32<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask8x32(self, a: mask8x32<Self>) -> bool
fn any_false_mask8x32(self, a: mask8x32<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask8x32(self, a: mask8x32<Self>) -> bool
fn all_false_mask8x32(self, a: mask8x32<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn combine_mask8x32(
self,
a: mask8x32<Self>,
b: mask8x32<Self>,
) -> mask8x64<Self>
fn combine_mask8x32( self, a: mask8x32<Self>, b: mask8x32<Self>, ) -> mask8x64<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_mask8x32(self, a: mask8x32<Self>) -> (mask8x16<Self>, mask8x16<Self>)
fn split_mask8x32(self, a: mask8x32<Self>) -> (mask8x16<Self>, mask8x16<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn splat_i16x16(self, val: i16) -> i16x16<Self>
fn splat_i16x16(self, val: i16) -> i16x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i16x16(self, val: [i16; 16]) -> i16x16<Self>
fn load_array_i16x16(self, val: [i16; 16]) -> i16x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i16x16(self, val: &[i16; 16]) -> i16x16<Self>
fn load_array_ref_i16x16(self, val: &[i16; 16]) -> i16x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i16x16(self, a: i16x16<Self>) -> [i16; 16]
fn as_array_i16x16(self, a: i16x16<Self>) -> [i16; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i16x16(self, a: &i16x16<Self>) -> &[i16; 16]
fn as_array_ref_i16x16(self, a: &i16x16<Self>) -> &[i16; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i16x16(self, a: &mut i16x16<Self>) -> &mut [i16; 16]
fn as_array_mut_i16x16(self, a: &mut i16x16<Self>) -> &mut [i16; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i16x16(self, a: i16x16<Self>, dest: &mut [i16; 16])
fn store_array_i16x16(self, a: i16x16<Self>, dest: &mut [i16; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i16x16(self, a: u8x32<Self>) -> i16x16<Self>
fn cvt_from_bytes_i16x16(self, a: u8x32<Self>) -> i16x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i16x16(self, a: i16x16<Self>) -> u8x32<Self>
fn cvt_to_bytes_i16x16(self, a: i16x16<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i16x16<const SHIFT: usize>(
self,
a: i16x16<Self>,
b: i16x16<Self>,
) -> i16x16<Self>
fn slide_i16x16<const SHIFT: usize>( self, a: i16x16<Self>, b: i16x16<Self>, ) -> i16x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i16x16<const SHIFT: usize>(
self,
a: i16x16<Self>,
b: i16x16<Self>,
) -> i16x16<Self>
fn slide_within_blocks_i16x16<const SHIFT: usize>( self, a: i16x16<Self>, b: i16x16<Self>, ) -> i16x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn mul_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn and_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn or_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn xor_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Compute the bitwise XOR of two vectors.
Sourcefn not_i16x16(self, a: i16x16<Self>) -> i16x16<Self>
fn not_i16x16(self, a: i16x16<Self>) -> i16x16<Self>
Compute the bitwise NOT of the vector.
Sourcefn shl_i16x16(self, a: i16x16<Self>, shift: u32) -> i16x16<Self>
fn shl_i16x16(self, a: i16x16<Self>, shift: u32) -> i16x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn shlv_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i16x16(self, a: i16x16<Self>, shift: u32) -> i16x16<Self>
fn shr_i16x16(self, a: i16x16<Self>, shift: u32) -> i16x16<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn shrv_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
fn simd_eq_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
fn simd_lt_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
fn simd_le_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
fn simd_ge_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
fn simd_gt_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn zip_low_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn zip_high_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn unzip_low_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn unzip_high_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i16x16(
self,
a: i16x16<Self>,
b: i16x16<Self>,
) -> (i16x16<Self>, i16x16<Self>)
fn interleave_i16x16( self, a: i16x16<Self>, b: i16x16<Self>, ) -> (i16x16<Self>, i16x16<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i16x16(
self,
a: i16x16<Self>,
b: i16x16<Self>,
) -> (i16x16<Self>, i16x16<Self>)
fn deinterleave_i16x16( self, a: i16x16<Self>, b: i16x16<Self>, ) -> (i16x16<Self>, i16x16<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i16x16(
self,
a: mask16x16<Self>,
b: i16x16<Self>,
c: i16x16<Self>,
) -> i16x16<Self>
fn select_i16x16( self, a: mask16x16<Self>, b: i16x16<Self>, c: i16x16<Self>, ) -> i16x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn min_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
fn max_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x32<Self>
fn combine_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x32<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_i16x16(self, a: i16x16<Self>) -> (i16x8<Self>, i16x8<Self>)
fn split_i16x16(self, a: i16x16<Self>) -> (i16x8<Self>, i16x8<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn neg_i16x16(self, a: i16x16<Self>) -> i16x16<Self>
fn neg_i16x16(self, a: i16x16<Self>) -> i16x16<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i16x16(self, a: i16x16<Self>) -> u8x32<Self>
fn reinterpret_u8_i16x16(self, a: i16x16<Self>) -> u8x32<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i16x16(self, a: i16x16<Self>) -> u32x8<Self>
fn reinterpret_u32_i16x16(self, a: i16x16<Self>) -> u32x8<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_u16x16(self, val: u16) -> u16x16<Self>
fn splat_u16x16(self, val: u16) -> u16x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u16x16(self, val: [u16; 16]) -> u16x16<Self>
fn load_array_u16x16(self, val: [u16; 16]) -> u16x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u16x16(self, val: &[u16; 16]) -> u16x16<Self>
fn load_array_ref_u16x16(self, val: &[u16; 16]) -> u16x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u16x16(self, a: u16x16<Self>) -> [u16; 16]
fn as_array_u16x16(self, a: u16x16<Self>) -> [u16; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u16x16(self, a: &u16x16<Self>) -> &[u16; 16]
fn as_array_ref_u16x16(self, a: &u16x16<Self>) -> &[u16; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u16x16(self, a: &mut u16x16<Self>) -> &mut [u16; 16]
fn as_array_mut_u16x16(self, a: &mut u16x16<Self>) -> &mut [u16; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u16x16(self, a: u16x16<Self>, dest: &mut [u16; 16])
fn store_array_u16x16(self, a: u16x16<Self>, dest: &mut [u16; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u16x16(self, a: u8x32<Self>) -> u16x16<Self>
fn cvt_from_bytes_u16x16(self, a: u8x32<Self>) -> u16x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u16x16(self, a: u16x16<Self>) -> u8x32<Self>
fn cvt_to_bytes_u16x16(self, a: u16x16<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u16x16<const SHIFT: usize>(
self,
a: u16x16<Self>,
b: u16x16<Self>,
) -> u16x16<Self>
fn slide_u16x16<const SHIFT: usize>( self, a: u16x16<Self>, b: u16x16<Self>, ) -> u16x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u16x16<const SHIFT: usize>(
self,
a: u16x16<Self>,
b: u16x16<Self>,
) -> u16x16<Self>
fn slide_within_blocks_u16x16<const SHIFT: usize>( self, a: u16x16<Self>, b: u16x16<Self>, ) -> u16x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn add_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn sub_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn mul_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn and_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn or_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn xor_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Compute the bitwise XOR of two vectors.
Sourcefn not_u16x16(self, a: u16x16<Self>) -> u16x16<Self>
fn not_u16x16(self, a: u16x16<Self>) -> u16x16<Self>
Compute the bitwise NOT of the vector.
Sourcefn shl_u16x16(self, a: u16x16<Self>, shift: u32) -> u16x16<Self>
fn shl_u16x16(self, a: u16x16<Self>, shift: u32) -> u16x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn shlv_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u16x16(self, a: u16x16<Self>, shift: u32) -> u16x16<Self>
fn shr_u16x16(self, a: u16x16<Self>, shift: u32) -> u16x16<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn shrv_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
fn simd_eq_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
fn simd_lt_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
fn simd_le_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
fn simd_ge_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
fn simd_gt_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn zip_low_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn zip_high_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn unzip_low_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn unzip_high_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u16x16(
self,
a: u16x16<Self>,
b: u16x16<Self>,
) -> (u16x16<Self>, u16x16<Self>)
fn interleave_u16x16( self, a: u16x16<Self>, b: u16x16<Self>, ) -> (u16x16<Self>, u16x16<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u16x16(
self,
a: u16x16<Self>,
b: u16x16<Self>,
) -> (u16x16<Self>, u16x16<Self>)
fn deinterleave_u16x16( self, a: u16x16<Self>, b: u16x16<Self>, ) -> (u16x16<Self>, u16x16<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u16x16(
self,
a: mask16x16<Self>,
b: u16x16<Self>,
c: u16x16<Self>,
) -> u16x16<Self>
fn select_u16x16( self, a: mask16x16<Self>, b: u16x16<Self>, c: u16x16<Self>, ) -> u16x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn min_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
fn max_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x32<Self>
fn combine_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x32<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_u16x16(self, a: u16x16<Self>) -> (u16x8<Self>, u16x8<Self>)
fn split_u16x16(self, a: u16x16<Self>) -> (u16x8<Self>, u16x8<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn narrow_u16x16(self, a: u16x16<Self>) -> u8x16<Self>
fn narrow_u16x16(self, a: u16x16<Self>) -> u8x16<Self>
Truncate each element to a narrower integer type.
The number of elements in the result is twice that of the input.
Sourcefn reinterpret_u8_u16x16(self, a: u16x16<Self>) -> u8x32<Self>
fn reinterpret_u8_u16x16(self, a: u16x16<Self>) -> u8x32<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_u16x16(self, a: u16x16<Self>) -> u32x8<Self>
fn reinterpret_u32_u16x16(self, a: u16x16<Self>) -> u32x8<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_mask16x16(self, val: i16) -> mask16x16<Self>
fn splat_mask16x16(self, val: i16) -> mask16x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask16x16(self, val: [i16; 16]) -> mask16x16<Self>
fn load_array_mask16x16(self, val: [i16; 16]) -> mask16x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask16x16(self, val: &[i16; 16]) -> mask16x16<Self>
fn load_array_ref_mask16x16(self, val: &[i16; 16]) -> mask16x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask16x16(self, a: mask16x16<Self>) -> [i16; 16]
fn as_array_mask16x16(self, a: mask16x16<Self>) -> [i16; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask16x16(self, a: &mask16x16<Self>) -> &[i16; 16]
fn as_array_ref_mask16x16(self, a: &mask16x16<Self>) -> &[i16; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask16x16(self, a: &mut mask16x16<Self>) -> &mut [i16; 16]
fn as_array_mut_mask16x16(self, a: &mut mask16x16<Self>) -> &mut [i16; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask16x16(self, a: mask16x16<Self>, dest: &mut [i16; 16])
fn store_array_mask16x16(self, a: mask16x16<Self>, dest: &mut [i16; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask16x16(self, a: u8x32<Self>) -> mask16x16<Self>
fn cvt_from_bytes_mask16x16(self, a: u8x32<Self>) -> mask16x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask16x16(self, a: mask16x16<Self>) -> u8x32<Self>
fn cvt_to_bytes_mask16x16(self, a: mask16x16<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask16x16<const SHIFT: usize>(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>
fn slide_mask16x16<const SHIFT: usize>( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask16x16<const SHIFT: usize>(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>
fn slide_within_blocks_mask16x16<const SHIFT: usize>( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>
fn and_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>
Compute the logical AND of two masks.
Sourcefn or_mask16x16(self, a: mask16x16<Self>, b: mask16x16<Self>) -> mask16x16<Self>
fn or_mask16x16(self, a: mask16x16<Self>, b: mask16x16<Self>) -> mask16x16<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>
fn xor_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask16x16(self, a: mask16x16<Self>) -> mask16x16<Self>
fn not_mask16x16(self, a: mask16x16<Self>) -> mask16x16<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
c: mask16x16<Self>,
) -> mask16x16<Self>
fn select_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, c: mask16x16<Self>, ) -> mask16x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x16<Self>
fn simd_eq_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask16x16(self, a: mask16x16<Self>) -> bool
fn any_true_mask16x16(self, a: mask16x16<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask16x16(self, a: mask16x16<Self>) -> bool
fn all_true_mask16x16(self, a: mask16x16<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask16x16(self, a: mask16x16<Self>) -> bool
fn any_false_mask16x16(self, a: mask16x16<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask16x16(self, a: mask16x16<Self>) -> bool
fn all_false_mask16x16(self, a: mask16x16<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn combine_mask16x16(
self,
a: mask16x16<Self>,
b: mask16x16<Self>,
) -> mask16x32<Self>
fn combine_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x32<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_mask16x16(self, a: mask16x16<Self>) -> (mask16x8<Self>, mask16x8<Self>)
fn split_mask16x16(self, a: mask16x16<Self>) -> (mask16x8<Self>, mask16x8<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn splat_i32x8(self, val: i32) -> i32x8<Self>
fn splat_i32x8(self, val: i32) -> i32x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i32x8(self, val: [i32; 8]) -> i32x8<Self>
fn load_array_i32x8(self, val: [i32; 8]) -> i32x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i32x8(self, val: &[i32; 8]) -> i32x8<Self>
fn load_array_ref_i32x8(self, val: &[i32; 8]) -> i32x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i32x8(self, a: i32x8<Self>) -> [i32; 8]
fn as_array_i32x8(self, a: i32x8<Self>) -> [i32; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i32x8(self, a: &i32x8<Self>) -> &[i32; 8]
fn as_array_ref_i32x8(self, a: &i32x8<Self>) -> &[i32; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i32x8(self, a: &mut i32x8<Self>) -> &mut [i32; 8]
fn as_array_mut_i32x8(self, a: &mut i32x8<Self>) -> &mut [i32; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i32x8(self, a: i32x8<Self>, dest: &mut [i32; 8])
fn store_array_i32x8(self, a: i32x8<Self>, dest: &mut [i32; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i32x8(self, a: u8x32<Self>) -> i32x8<Self>
fn cvt_from_bytes_i32x8(self, a: u8x32<Self>) -> i32x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i32x8(self, a: i32x8<Self>) -> u8x32<Self>
fn cvt_to_bytes_i32x8(self, a: i32x8<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i32x8<const SHIFT: usize>(
self,
a: i32x8<Self>,
b: i32x8<Self>,
) -> i32x8<Self>
fn slide_i32x8<const SHIFT: usize>( self, a: i32x8<Self>, b: i32x8<Self>, ) -> i32x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i32x8<const SHIFT: usize>(
self,
a: i32x8<Self>,
b: i32x8<Self>,
) -> i32x8<Self>
fn slide_within_blocks_i32x8<const SHIFT: usize>( self, a: i32x8<Self>, b: i32x8<Self>, ) -> i32x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn mul_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn and_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn or_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn xor_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self>
fn shl_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn shlv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self>
fn shr_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn shrv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
fn simd_eq_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
fn simd_lt_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
fn simd_le_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
fn simd_ge_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
fn simd_gt_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn zip_low_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn zip_high_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn unzip_low_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn unzip_high_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i32x8(
self,
a: i32x8<Self>,
b: i32x8<Self>,
) -> (i32x8<Self>, i32x8<Self>)
fn interleave_i32x8( self, a: i32x8<Self>, b: i32x8<Self>, ) -> (i32x8<Self>, i32x8<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i32x8(
self,
a: i32x8<Self>,
b: i32x8<Self>,
) -> (i32x8<Self>, i32x8<Self>)
fn deinterleave_i32x8( self, a: i32x8<Self>, b: i32x8<Self>, ) -> (i32x8<Self>, i32x8<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i32x8(
self,
a: mask32x8<Self>,
b: i32x8<Self>,
c: i32x8<Self>,
) -> i32x8<Self>
fn select_i32x8( self, a: mask32x8<Self>, b: i32x8<Self>, c: i32x8<Self>, ) -> i32x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn min_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
fn max_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x16<Self>
fn combine_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x16<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_i32x8(self, a: i32x8<Self>) -> (i32x4<Self>, i32x4<Self>)
fn split_i32x8(self, a: i32x8<Self>) -> (i32x4<Self>, i32x4<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn neg_i32x8(self, a: i32x8<Self>) -> i32x8<Self>
fn neg_i32x8(self, a: i32x8<Self>) -> i32x8<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i32x8(self, a: i32x8<Self>) -> u8x32<Self>
fn reinterpret_u8_i32x8(self, a: i32x8<Self>) -> u8x32<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i32x8(self, a: i32x8<Self>) -> u32x8<Self>
fn reinterpret_u32_i32x8(self, a: i32x8<Self>) -> u32x8<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_f32_i32x8(self, a: i32x8<Self>) -> f32x8<Self>
fn cvt_f32_i32x8(self, a: i32x8<Self>) -> f32x8<Self>
Convert each signed 32-bit integer element to a floating-point value.
Values that cannot be exactly represented are rounded to the nearest representable value.
Sourcefn splat_u32x8(self, val: u32) -> u32x8<Self>
fn splat_u32x8(self, val: u32) -> u32x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u32x8(self, val: [u32; 8]) -> u32x8<Self>
fn load_array_u32x8(self, val: [u32; 8]) -> u32x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u32x8(self, val: &[u32; 8]) -> u32x8<Self>
fn load_array_ref_u32x8(self, val: &[u32; 8]) -> u32x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u32x8(self, a: u32x8<Self>) -> [u32; 8]
fn as_array_u32x8(self, a: u32x8<Self>) -> [u32; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u32x8(self, a: &u32x8<Self>) -> &[u32; 8]
fn as_array_ref_u32x8(self, a: &u32x8<Self>) -> &[u32; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u32x8(self, a: &mut u32x8<Self>) -> &mut [u32; 8]
fn as_array_mut_u32x8(self, a: &mut u32x8<Self>) -> &mut [u32; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u32x8(self, a: u32x8<Self>, dest: &mut [u32; 8])
fn store_array_u32x8(self, a: u32x8<Self>, dest: &mut [u32; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u32x8(self, a: u8x32<Self>) -> u32x8<Self>
fn cvt_from_bytes_u32x8(self, a: u8x32<Self>) -> u32x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u32x8(self, a: u32x8<Self>) -> u8x32<Self>
fn cvt_to_bytes_u32x8(self, a: u32x8<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u32x8<const SHIFT: usize>(
self,
a: u32x8<Self>,
b: u32x8<Self>,
) -> u32x8<Self>
fn slide_u32x8<const SHIFT: usize>( self, a: u32x8<Self>, b: u32x8<Self>, ) -> u32x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u32x8<const SHIFT: usize>(
self,
a: u32x8<Self>,
b: u32x8<Self>,
) -> u32x8<Self>
fn slide_within_blocks_u32x8<const SHIFT: usize>( self, a: u32x8<Self>, b: u32x8<Self>, ) -> u32x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn add_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn sub_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn mul_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn and_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn or_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn xor_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_u32x8(self, a: u32x8<Self>, shift: u32) -> u32x8<Self>
fn shl_u32x8(self, a: u32x8<Self>, shift: u32) -> u32x8<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn shlv_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u32x8(self, a: u32x8<Self>, shift: u32) -> u32x8<Self>
fn shr_u32x8(self, a: u32x8<Self>, shift: u32) -> u32x8<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn shrv_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
fn simd_eq_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
fn simd_lt_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
fn simd_le_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
fn simd_ge_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
fn simd_gt_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn zip_low_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn zip_high_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn unzip_low_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn unzip_high_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u32x8(
self,
a: u32x8<Self>,
b: u32x8<Self>,
) -> (u32x8<Self>, u32x8<Self>)
fn interleave_u32x8( self, a: u32x8<Self>, b: u32x8<Self>, ) -> (u32x8<Self>, u32x8<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u32x8(
self,
a: u32x8<Self>,
b: u32x8<Self>,
) -> (u32x8<Self>, u32x8<Self>)
fn deinterleave_u32x8( self, a: u32x8<Self>, b: u32x8<Self>, ) -> (u32x8<Self>, u32x8<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u32x8(
self,
a: mask32x8<Self>,
b: u32x8<Self>,
c: u32x8<Self>,
) -> u32x8<Self>
fn select_u32x8( self, a: mask32x8<Self>, b: u32x8<Self>, c: u32x8<Self>, ) -> u32x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn min_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
fn max_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>
Return the element-wise maximum of two vectors.
Sourcefn combine_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x16<Self>
fn combine_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x16<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_u32x8(self, a: u32x8<Self>) -> (u32x4<Self>, u32x4<Self>)
fn split_u32x8(self, a: u32x8<Self>) -> (u32x4<Self>, u32x4<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn reinterpret_u8_u32x8(self, a: u32x8<Self>) -> u8x32<Self>
fn reinterpret_u8_u32x8(self, a: u32x8<Self>) -> u8x32<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_f32_u32x8(self, a: u32x8<Self>) -> f32x8<Self>
fn cvt_f32_u32x8(self, a: u32x8<Self>) -> f32x8<Self>
Convert each unsigned 32-bit integer element to a floating-point value.
Values that cannot be exactly represented are rounded to the nearest representable value.
Sourcefn splat_mask32x8(self, val: i32) -> mask32x8<Self>
fn splat_mask32x8(self, val: i32) -> mask32x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask32x8(self, val: [i32; 8]) -> mask32x8<Self>
fn load_array_mask32x8(self, val: [i32; 8]) -> mask32x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask32x8(self, val: &[i32; 8]) -> mask32x8<Self>
fn load_array_ref_mask32x8(self, val: &[i32; 8]) -> mask32x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask32x8(self, a: mask32x8<Self>) -> [i32; 8]
fn as_array_mask32x8(self, a: mask32x8<Self>) -> [i32; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask32x8(self, a: &mask32x8<Self>) -> &[i32; 8]
fn as_array_ref_mask32x8(self, a: &mask32x8<Self>) -> &[i32; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask32x8(self, a: &mut mask32x8<Self>) -> &mut [i32; 8]
fn as_array_mut_mask32x8(self, a: &mut mask32x8<Self>) -> &mut [i32; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask32x8(self, a: mask32x8<Self>, dest: &mut [i32; 8])
fn store_array_mask32x8(self, a: mask32x8<Self>, dest: &mut [i32; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask32x8(self, a: u8x32<Self>) -> mask32x8<Self>
fn cvt_from_bytes_mask32x8(self, a: u8x32<Self>) -> mask32x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask32x8(self, a: mask32x8<Self>) -> u8x32<Self>
fn cvt_to_bytes_mask32x8(self, a: mask32x8<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask32x8<const SHIFT: usize>(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x8<Self>
fn slide_mask32x8<const SHIFT: usize>( self, a: mask32x8<Self>, b: mask32x8<Self>, ) -> mask32x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask32x8<const SHIFT: usize>(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x8<Self>
fn slide_within_blocks_mask32x8<const SHIFT: usize>( self, a: mask32x8<Self>, b: mask32x8<Self>, ) -> mask32x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>
fn and_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>
Compute the logical AND of two masks.
Sourcefn or_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>
fn or_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>
fn xor_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask32x8(self, a: mask32x8<Self>) -> mask32x8<Self>
fn not_mask32x8(self, a: mask32x8<Self>) -> mask32x8<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask32x8(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
c: mask32x8<Self>,
) -> mask32x8<Self>
fn select_mask32x8( self, a: mask32x8<Self>, b: mask32x8<Self>, c: mask32x8<Self>, ) -> mask32x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask32x8(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x8<Self>
fn simd_eq_mask32x8( self, a: mask32x8<Self>, b: mask32x8<Self>, ) -> mask32x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask32x8(self, a: mask32x8<Self>) -> bool
fn any_true_mask32x8(self, a: mask32x8<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask32x8(self, a: mask32x8<Self>) -> bool
fn all_true_mask32x8(self, a: mask32x8<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask32x8(self, a: mask32x8<Self>) -> bool
fn any_false_mask32x8(self, a: mask32x8<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask32x8(self, a: mask32x8<Self>) -> bool
fn all_false_mask32x8(self, a: mask32x8<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn combine_mask32x8(
self,
a: mask32x8<Self>,
b: mask32x8<Self>,
) -> mask32x16<Self>
fn combine_mask32x8( self, a: mask32x8<Self>, b: mask32x8<Self>, ) -> mask32x16<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_mask32x8(self, a: mask32x8<Self>) -> (mask32x4<Self>, mask32x4<Self>)
fn split_mask32x8(self, a: mask32x8<Self>) -> (mask32x4<Self>, mask32x4<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn splat_f64x4(self, val: f64) -> f64x4<Self>
fn splat_f64x4(self, val: f64) -> f64x4<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_f64x4(self, val: [f64; 4]) -> f64x4<Self>
fn load_array_f64x4(self, val: [f64; 4]) -> f64x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_f64x4(self, val: &[f64; 4]) -> f64x4<Self>
fn load_array_ref_f64x4(self, val: &[f64; 4]) -> f64x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_f64x4(self, a: f64x4<Self>) -> [f64; 4]
fn as_array_f64x4(self, a: f64x4<Self>) -> [f64; 4]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_f64x4(self, a: &f64x4<Self>) -> &[f64; 4]
fn as_array_ref_f64x4(self, a: &f64x4<Self>) -> &[f64; 4]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_f64x4(self, a: &mut f64x4<Self>) -> &mut [f64; 4]
fn as_array_mut_f64x4(self, a: &mut f64x4<Self>) -> &mut [f64; 4]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_f64x4(self, a: f64x4<Self>, dest: &mut [f64; 4])
fn store_array_f64x4(self, a: f64x4<Self>, dest: &mut [f64; 4])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_f64x4(self, a: u8x32<Self>) -> f64x4<Self>
fn cvt_from_bytes_f64x4(self, a: u8x32<Self>) -> f64x4<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_f64x4(self, a: f64x4<Self>) -> u8x32<Self>
fn cvt_to_bytes_f64x4(self, a: f64x4<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_f64x4<const SHIFT: usize>(
self,
a: f64x4<Self>,
b: f64x4<Self>,
) -> f64x4<Self>
fn slide_f64x4<const SHIFT: usize>( self, a: f64x4<Self>, b: f64x4<Self>, ) -> f64x4<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_f64x4<const SHIFT: usize>(
self,
a: f64x4<Self>,
b: f64x4<Self>,
) -> f64x4<Self>
fn slide_within_blocks_f64x4<const SHIFT: usize>( self, a: f64x4<Self>, b: f64x4<Self>, ) -> f64x4<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn sqrt_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
fn sqrt_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
Compute the square root of each element.
Negative elements other than -0.0 will become NaN.
Sourcefn add_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn add_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Add two vectors element-wise.
Sourcefn sub_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn sub_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Subtract two vectors element-wise.
Sourcefn mul_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn mul_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Multiply two vectors element-wise.
Sourcefn div_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn div_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Divide two vectors element-wise.
Sourcefn copysign_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn copysign_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Return a vector with the magnitude of a and the sign of b for each element.
This operation copies the sign bit, so if an input element is NaN, the output element will be a NaN with the same payload and a copied sign bit.
Sourcefn simd_eq_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
fn simd_eq_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
fn simd_lt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
fn simd_le_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
fn simd_ge_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
fn simd_gt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn zip_low_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn zip_high_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn unzip_low_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn unzip_high_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_f64x4(
self,
a: f64x4<Self>,
b: f64x4<Self>,
) -> (f64x4<Self>, f64x4<Self>)
fn interleave_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, ) -> (f64x4<Self>, f64x4<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_f64x4(
self,
a: f64x4<Self>,
b: f64x4<Self>,
) -> (f64x4<Self>, f64x4<Self>)
fn deinterleave_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, ) -> (f64x4<Self>, f64x4<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn max_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn max_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Return the element-wise maximum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See max_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn min_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn min_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Return the element-wise minimum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See min_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn max_precise_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn max_precise_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Return the element-wise maximum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn min_precise_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
fn min_precise_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>
Return the element-wise minimum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn mul_add_f64x4(
self,
a: f64x4<Self>,
b: f64x4<Self>,
c: f64x4<Self>,
) -> f64x4<Self>
fn mul_add_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, c: f64x4<Self>, ) -> f64x4<Self>
Compute (a * b) + c (fused multiply-add) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by an add, which will result in two rounding errors.
Sourcefn mul_sub_f64x4(
self,
a: f64x4<Self>,
b: f64x4<Self>,
c: f64x4<Self>,
) -> f64x4<Self>
fn mul_sub_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, c: f64x4<Self>, ) -> f64x4<Self>
Compute (a * b) - c (fused multiply-subtract) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by a subtract, which will result in two rounding errors.
Sourcefn floor_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
fn floor_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
Return the largest integer less than or equal to each element, that is, round towards negative infinity.
Sourcefn ceil_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
fn ceil_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.
Sourcefn round_ties_even_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
fn round_ties_even_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
Round each element to the nearest integer, with ties rounding to the nearest even integer.
There is no corresponding round operation. Rust’s round operation rounds ties away from zero, a behavior it inherited from C. That behavior is not implemented across all platforms, whereas round-ties-even is.
Sourcefn fract_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
fn fract_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
Return the fractional part of each element.
This is equivalent to a - a.trunc().
Sourcefn trunc_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
fn trunc_f64x4(self, a: f64x4<Self>) -> f64x4<Self>
Return the integer part of each element, rounding towards zero.
Sourcefn select_f64x4(
self,
a: mask64x4<Self>,
b: f64x4<Self>,
c: f64x4<Self>,
) -> f64x4<Self>
fn select_f64x4( self, a: mask64x4<Self>, b: f64x4<Self>, c: f64x4<Self>, ) -> f64x4<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn combine_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x8<Self>
fn combine_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x8<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_f64x4(self, a: f64x4<Self>) -> (f64x2<Self>, f64x2<Self>)
fn split_f64x4(self, a: f64x4<Self>) -> (f64x2<Self>, f64x2<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn reinterpret_f32_f64x4(self, a: f64x4<Self>) -> f32x8<Self>
fn reinterpret_f32_f64x4(self, a: f64x4<Self>) -> f32x8<Self>
Reinterpret the bits of this vector as a vector of f32 elements.
The number of elements in the result is twice that of the input.
Sourcefn splat_mask64x4(self, val: i64) -> mask64x4<Self>
fn splat_mask64x4(self, val: i64) -> mask64x4<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask64x4(self, val: [i64; 4]) -> mask64x4<Self>
fn load_array_mask64x4(self, val: [i64; 4]) -> mask64x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask64x4(self, val: &[i64; 4]) -> mask64x4<Self>
fn load_array_ref_mask64x4(self, val: &[i64; 4]) -> mask64x4<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask64x4(self, a: mask64x4<Self>) -> [i64; 4]
fn as_array_mask64x4(self, a: mask64x4<Self>) -> [i64; 4]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask64x4(self, a: &mask64x4<Self>) -> &[i64; 4]
fn as_array_ref_mask64x4(self, a: &mask64x4<Self>) -> &[i64; 4]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask64x4(self, a: &mut mask64x4<Self>) -> &mut [i64; 4]
fn as_array_mut_mask64x4(self, a: &mut mask64x4<Self>) -> &mut [i64; 4]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask64x4(self, a: mask64x4<Self>, dest: &mut [i64; 4])
fn store_array_mask64x4(self, a: mask64x4<Self>, dest: &mut [i64; 4])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask64x4(self, a: u8x32<Self>) -> mask64x4<Self>
fn cvt_from_bytes_mask64x4(self, a: u8x32<Self>) -> mask64x4<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask64x4(self, a: mask64x4<Self>) -> u8x32<Self>
fn cvt_to_bytes_mask64x4(self, a: mask64x4<Self>) -> u8x32<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask64x4<const SHIFT: usize>(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x4<Self>
fn slide_mask64x4<const SHIFT: usize>( self, a: mask64x4<Self>, b: mask64x4<Self>, ) -> mask64x4<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask64x4<const SHIFT: usize>(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x4<Self>
fn slide_within_blocks_mask64x4<const SHIFT: usize>( self, a: mask64x4<Self>, b: mask64x4<Self>, ) -> mask64x4<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>
fn and_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>
Compute the logical AND of two masks.
Sourcefn or_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>
fn or_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>
fn xor_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask64x4(self, a: mask64x4<Self>) -> mask64x4<Self>
fn not_mask64x4(self, a: mask64x4<Self>) -> mask64x4<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask64x4(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
c: mask64x4<Self>,
) -> mask64x4<Self>
fn select_mask64x4( self, a: mask64x4<Self>, b: mask64x4<Self>, c: mask64x4<Self>, ) -> mask64x4<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask64x4(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x4<Self>
fn simd_eq_mask64x4( self, a: mask64x4<Self>, b: mask64x4<Self>, ) -> mask64x4<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask64x4(self, a: mask64x4<Self>) -> bool
fn any_true_mask64x4(self, a: mask64x4<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask64x4(self, a: mask64x4<Self>) -> bool
fn all_true_mask64x4(self, a: mask64x4<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask64x4(self, a: mask64x4<Self>) -> bool
fn any_false_mask64x4(self, a: mask64x4<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask64x4(self, a: mask64x4<Self>) -> bool
fn all_false_mask64x4(self, a: mask64x4<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn combine_mask64x4(
self,
a: mask64x4<Self>,
b: mask64x4<Self>,
) -> mask64x8<Self>
fn combine_mask64x4( self, a: mask64x4<Self>, b: mask64x4<Self>, ) -> mask64x8<Self>
Combine two vectors into a single vector with twice the width.
a provides the lower elements and b provides the upper elements.
Sourcefn split_mask64x4(self, a: mask64x4<Self>) -> (mask64x2<Self>, mask64x2<Self>)
fn split_mask64x4(self, a: mask64x4<Self>) -> (mask64x2<Self>, mask64x2<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn splat_f32x16(self, val: f32) -> f32x16<Self>
fn splat_f32x16(self, val: f32) -> f32x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_f32x16(self, val: [f32; 16]) -> f32x16<Self>
fn load_array_f32x16(self, val: [f32; 16]) -> f32x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_f32x16(self, val: &[f32; 16]) -> f32x16<Self>
fn load_array_ref_f32x16(self, val: &[f32; 16]) -> f32x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_f32x16(self, a: f32x16<Self>) -> [f32; 16]
fn as_array_f32x16(self, a: f32x16<Self>) -> [f32; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_f32x16(self, a: &f32x16<Self>) -> &[f32; 16]
fn as_array_ref_f32x16(self, a: &f32x16<Self>) -> &[f32; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_f32x16(self, a: &mut f32x16<Self>) -> &mut [f32; 16]
fn as_array_mut_f32x16(self, a: &mut f32x16<Self>) -> &mut [f32; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_f32x16(self, a: f32x16<Self>, dest: &mut [f32; 16])
fn store_array_f32x16(self, a: f32x16<Self>, dest: &mut [f32; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_f32x16(self, a: u8x64<Self>) -> f32x16<Self>
fn cvt_from_bytes_f32x16(self, a: u8x64<Self>) -> f32x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_f32x16(self, a: f32x16<Self>) -> u8x64<Self>
fn cvt_to_bytes_f32x16(self, a: f32x16<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_f32x16<const SHIFT: usize>(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> f32x16<Self>
fn slide_f32x16<const SHIFT: usize>( self, a: f32x16<Self>, b: f32x16<Self>, ) -> f32x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_f32x16<const SHIFT: usize>(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> f32x16<Self>
fn slide_within_blocks_f32x16<const SHIFT: usize>( self, a: f32x16<Self>, b: f32x16<Self>, ) -> f32x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
Compute the absolute value of each element.
Sourcefn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
Negate each element of the vector.
Sourcefn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
Compute the square root of each element.
Negative elements other than -0.0 will become NaN.
Sourcefn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Add two vectors element-wise.
Sourcefn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Subtract two vectors element-wise.
Sourcefn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Multiply two vectors element-wise.
Sourcefn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Divide two vectors element-wise.
Sourcefn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Return a vector with the magnitude of a and the sign of b for each element.
This operation copies the sign bit, so if an input element is NaN, the output element will be a NaN with the same payload and a copied sign bit.
Sourcefn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn unzip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> (f32x16<Self>, f32x16<Self>)
fn interleave_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, ) -> (f32x16<Self>, f32x16<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
) -> (f32x16<Self>, f32x16<Self>)
fn deinterleave_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, ) -> (f32x16<Self>, f32x16<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn max_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn max_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Return the element-wise maximum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See max_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn min_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn min_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Return the element-wise minimum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See min_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn max_precise_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn max_precise_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Return the element-wise maximum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn min_precise_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
fn min_precise_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>
Return the element-wise minimum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn mul_add_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
c: f32x16<Self>,
) -> f32x16<Self>
fn mul_add_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, c: f32x16<Self>, ) -> f32x16<Self>
Compute (a * b) + c (fused multiply-add) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by an add, which will result in two rounding errors.
Sourcefn mul_sub_f32x16(
self,
a: f32x16<Self>,
b: f32x16<Self>,
c: f32x16<Self>,
) -> f32x16<Self>
fn mul_sub_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, c: f32x16<Self>, ) -> f32x16<Self>
Compute (a * b) - c (fused multiply-subtract) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by a subtract, which will result in two rounding errors.
Sourcefn floor_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
fn floor_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
Return the largest integer less than or equal to each element, that is, round towards negative infinity.
Sourcefn ceil_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
fn ceil_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.
Sourcefn round_ties_even_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
fn round_ties_even_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
Round each element to the nearest integer, with ties rounding to the nearest even integer.
There is no corresponding round operation. Rust’s round operation rounds ties away from zero, a behavior it inherited from C. That behavior is not implemented across all platforms, whereas round-ties-even is.
Sourcefn fract_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
fn fract_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
Return the fractional part of each element.
This is equivalent to a - a.trunc().
Sourcefn trunc_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
fn trunc_f32x16(self, a: f32x16<Self>) -> f32x16<Self>
Return the integer part of each element, rounding towards zero.
Sourcefn select_f32x16(
self,
a: mask32x16<Self>,
b: f32x16<Self>,
c: f32x16<Self>,
) -> f32x16<Self>
fn select_f32x16( self, a: mask32x16<Self>, b: f32x16<Self>, c: f32x16<Self>, ) -> f32x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn split_f32x16(self, a: f32x16<Self>) -> (f32x8<Self>, f32x8<Self>)
fn split_f32x16(self, a: f32x16<Self>) -> (f32x8<Self>, f32x8<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn reinterpret_f64_f32x16(self, a: f32x16<Self>) -> f64x8<Self>
fn reinterpret_f64_f32x16(self, a: f32x16<Self>) -> f64x8<Self>
Reinterpret the bits of this vector as a vector of f64 elements.
The number of elements in the result is half that of the input.
Sourcefn reinterpret_i32_f32x16(self, a: f32x16<Self>) -> i32x16<Self>
fn reinterpret_i32_f32x16(self, a: f32x16<Self>) -> i32x16<Self>
Reinterpret the bits of this vector as a vector of i32 elements.
This is a bitwise reinterpretation only, and does not perform any conversions.
Sourcefn load_interleaved_128_f32x16(self, src: &[f32; 16]) -> f32x16<Self>
fn load_interleaved_128_f32x16(self, src: &[f32; 16]) -> f32x16<Self>
Load elements from an array with 4-way interleaving.
Reads consecutive elements and deinterleaves them into a single vector.
Sourcefn store_interleaved_128_f32x16(self, a: f32x16<Self>, dest: &mut [f32; 16])
fn store_interleaved_128_f32x16(self, a: f32x16<Self>, dest: &mut [f32; 16])
Store elements to an array with 4-way interleaving.
Interleaves the vector elements and writes them consecutively to memory.
Sourcefn reinterpret_u8_f32x16(self, a: f32x16<Self>) -> u8x64<Self>
fn reinterpret_u8_f32x16(self, a: f32x16<Self>) -> u8x64<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_f32x16(self, a: f32x16<Self>) -> u32x16<Self>
fn reinterpret_u32_f32x16(self, a: f32x16<Self>) -> u32x16<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_u32_f32x16(self, a: f32x16<Self>) -> u32x16<Self>
fn cvt_u32_f32x16(self, a: f32x16<Self>) -> u32x16<Self>
Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.
Out-of-range values or NaN will produce implementation-defined results.
On x86 platforms, this operation will still be slower than converting to i32, because there is no native instruction for converting to u32 (at least until AVX-512, which is currently not supported).
If you know your values fit within range of an i32, you should convert to an i32 and cast to your desired datatype afterwards.
Sourcefn cvt_u32_precise_f32x16(self, a: f32x16<Self>) -> u32x16<Self>
fn cvt_u32_precise_f32x16(self, a: f32x16<Self>) -> u32x16<Self>
Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.
Out-of-range values are saturated to the closest in-range value. NaN becomes 0.
Sourcefn cvt_i32_f32x16(self, a: f32x16<Self>) -> i32x16<Self>
fn cvt_i32_f32x16(self, a: f32x16<Self>) -> i32x16<Self>
Convert each floating-point element to a signed 32-bit integer, truncating towards zero.
Out-of-range values or NaN will produce implementation-defined results.
Sourcefn cvt_i32_precise_f32x16(self, a: f32x16<Self>) -> i32x16<Self>
fn cvt_i32_precise_f32x16(self, a: f32x16<Self>) -> i32x16<Self>
Convert each floating-point element to a signed 32-bit integer, truncating towards zero.
Out-of-range values are saturated to the closest in-range value. NaN becomes 0.
Sourcefn splat_i8x64(self, val: i8) -> i8x64<Self>
fn splat_i8x64(self, val: i8) -> i8x64<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i8x64(self, val: [i8; 64]) -> i8x64<Self>
fn load_array_i8x64(self, val: [i8; 64]) -> i8x64<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i8x64(self, val: &[i8; 64]) -> i8x64<Self>
fn load_array_ref_i8x64(self, val: &[i8; 64]) -> i8x64<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i8x64(self, a: i8x64<Self>) -> [i8; 64]
fn as_array_i8x64(self, a: i8x64<Self>) -> [i8; 64]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i8x64(self, a: &i8x64<Self>) -> &[i8; 64]
fn as_array_ref_i8x64(self, a: &i8x64<Self>) -> &[i8; 64]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i8x64(self, a: &mut i8x64<Self>) -> &mut [i8; 64]
fn as_array_mut_i8x64(self, a: &mut i8x64<Self>) -> &mut [i8; 64]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i8x64(self, a: i8x64<Self>, dest: &mut [i8; 64])
fn store_array_i8x64(self, a: i8x64<Self>, dest: &mut [i8; 64])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i8x64(self, a: u8x64<Self>) -> i8x64<Self>
fn cvt_from_bytes_i8x64(self, a: u8x64<Self>) -> i8x64<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i8x64(self, a: i8x64<Self>) -> u8x64<Self>
fn cvt_to_bytes_i8x64(self, a: i8x64<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i8x64<const SHIFT: usize>(
self,
a: i8x64<Self>,
b: i8x64<Self>,
) -> i8x64<Self>
fn slide_i8x64<const SHIFT: usize>( self, a: i8x64<Self>, b: i8x64<Self>, ) -> i8x64<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i8x64<const SHIFT: usize>(
self,
a: i8x64<Self>,
b: i8x64<Self>,
) -> i8x64<Self>
fn slide_within_blocks_i8x64<const SHIFT: usize>( self, a: i8x64<Self>, b: i8x64<Self>, ) -> i8x64<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn add_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn sub_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn mul_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn and_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn or_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn xor_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_i8x64(self, a: i8x64<Self>, shift: u32) -> i8x64<Self>
fn shl_i8x64(self, a: i8x64<Self>, shift: u32) -> i8x64<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn shlv_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i8x64(self, a: i8x64<Self>, shift: u32) -> i8x64<Self>
fn shr_i8x64(self, a: i8x64<Self>, shift: u32) -> i8x64<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn shrv_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
fn simd_eq_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
fn simd_lt_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
fn simd_le_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
fn simd_ge_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
fn simd_gt_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn zip_low_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn zip_high_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn unzip_low_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn unzip_high_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i8x64(
self,
a: i8x64<Self>,
b: i8x64<Self>,
) -> (i8x64<Self>, i8x64<Self>)
fn interleave_i8x64( self, a: i8x64<Self>, b: i8x64<Self>, ) -> (i8x64<Self>, i8x64<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i8x64(
self,
a: i8x64<Self>,
b: i8x64<Self>,
) -> (i8x64<Self>, i8x64<Self>)
fn deinterleave_i8x64( self, a: i8x64<Self>, b: i8x64<Self>, ) -> (i8x64<Self>, i8x64<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i8x64(
self,
a: mask8x64<Self>,
b: i8x64<Self>,
c: i8x64<Self>,
) -> i8x64<Self>
fn select_i8x64( self, a: mask8x64<Self>, b: i8x64<Self>, c: i8x64<Self>, ) -> i8x64<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn min_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
fn max_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>
Return the element-wise maximum of two vectors.
Sourcefn split_i8x64(self, a: i8x64<Self>) -> (i8x32<Self>, i8x32<Self>)
fn split_i8x64(self, a: i8x64<Self>) -> (i8x32<Self>, i8x32<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn neg_i8x64(self, a: i8x64<Self>) -> i8x64<Self>
fn neg_i8x64(self, a: i8x64<Self>) -> i8x64<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i8x64(self, a: i8x64<Self>) -> u8x64<Self>
fn reinterpret_u8_i8x64(self, a: i8x64<Self>) -> u8x64<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i8x64(self, a: i8x64<Self>) -> u32x16<Self>
fn reinterpret_u32_i8x64(self, a: i8x64<Self>) -> u32x16<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_u8x64(self, val: u8) -> u8x64<Self>
fn splat_u8x64(self, val: u8) -> u8x64<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u8x64(self, val: [u8; 64]) -> u8x64<Self>
fn load_array_u8x64(self, val: [u8; 64]) -> u8x64<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u8x64(self, val: &[u8; 64]) -> u8x64<Self>
fn load_array_ref_u8x64(self, val: &[u8; 64]) -> u8x64<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u8x64(self, a: u8x64<Self>) -> [u8; 64]
fn as_array_u8x64(self, a: u8x64<Self>) -> [u8; 64]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u8x64(self, a: &u8x64<Self>) -> &[u8; 64]
fn as_array_ref_u8x64(self, a: &u8x64<Self>) -> &[u8; 64]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u8x64(self, a: &mut u8x64<Self>) -> &mut [u8; 64]
fn as_array_mut_u8x64(self, a: &mut u8x64<Self>) -> &mut [u8; 64]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u8x64(self, a: u8x64<Self>, dest: &mut [u8; 64])
fn store_array_u8x64(self, a: u8x64<Self>, dest: &mut [u8; 64])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u8x64(self, a: u8x64<Self>) -> u8x64<Self>
fn cvt_from_bytes_u8x64(self, a: u8x64<Self>) -> u8x64<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u8x64(self, a: u8x64<Self>) -> u8x64<Self>
fn cvt_to_bytes_u8x64(self, a: u8x64<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u8x64<const SHIFT: usize>(
self,
a: u8x64<Self>,
b: u8x64<Self>,
) -> u8x64<Self>
fn slide_u8x64<const SHIFT: usize>( self, a: u8x64<Self>, b: u8x64<Self>, ) -> u8x64<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u8x64<const SHIFT: usize>(
self,
a: u8x64<Self>,
b: u8x64<Self>,
) -> u8x64<Self>
fn slide_within_blocks_u8x64<const SHIFT: usize>( self, a: u8x64<Self>, b: u8x64<Self>, ) -> u8x64<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn add_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn sub_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn mul_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn and_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn or_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn xor_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Compute the bitwise XOR of two vectors.
Sourcefn shl_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self>
fn shl_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn shlv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self>
fn shr_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn shrv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
fn simd_eq_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
fn simd_lt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
fn simd_le_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
fn simd_ge_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
fn simd_gt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn zip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn zip_high_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn unzip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn unzip_high_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u8x64(
self,
a: u8x64<Self>,
b: u8x64<Self>,
) -> (u8x64<Self>, u8x64<Self>)
fn interleave_u8x64( self, a: u8x64<Self>, b: u8x64<Self>, ) -> (u8x64<Self>, u8x64<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u8x64(
self,
a: u8x64<Self>,
b: u8x64<Self>,
) -> (u8x64<Self>, u8x64<Self>)
fn deinterleave_u8x64( self, a: u8x64<Self>, b: u8x64<Self>, ) -> (u8x64<Self>, u8x64<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u8x64(
self,
a: mask8x64<Self>,
b: u8x64<Self>,
c: u8x64<Self>,
) -> u8x64<Self>
fn select_u8x64( self, a: mask8x64<Self>, b: u8x64<Self>, c: u8x64<Self>, ) -> u8x64<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn min_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
fn max_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>
Return the element-wise maximum of two vectors.
Sourcefn split_u8x64(self, a: u8x64<Self>) -> (u8x32<Self>, u8x32<Self>)
fn split_u8x64(self, a: u8x64<Self>) -> (u8x32<Self>, u8x32<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn load_interleaved_128_u8x64(self, src: &[u8; 64]) -> u8x64<Self>
fn load_interleaved_128_u8x64(self, src: &[u8; 64]) -> u8x64<Self>
Load elements from an array with 4-way interleaving.
Reads consecutive elements and deinterleaves them into a single vector.
Sourcefn store_interleaved_128_u8x64(self, a: u8x64<Self>, dest: &mut [u8; 64])
fn store_interleaved_128_u8x64(self, a: u8x64<Self>, dest: &mut [u8; 64])
Store elements to an array with 4-way interleaving.
Interleaves the vector elements and writes them consecutively to memory.
Sourcefn reinterpret_u32_u8x64(self, a: u8x64<Self>) -> u32x16<Self>
fn reinterpret_u32_u8x64(self, a: u8x64<Self>) -> u32x16<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_mask8x64(self, val: i8) -> mask8x64<Self>
fn splat_mask8x64(self, val: i8) -> mask8x64<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask8x64(self, val: [i8; 64]) -> mask8x64<Self>
fn load_array_mask8x64(self, val: [i8; 64]) -> mask8x64<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask8x64(self, val: &[i8; 64]) -> mask8x64<Self>
fn load_array_ref_mask8x64(self, val: &[i8; 64]) -> mask8x64<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask8x64(self, a: mask8x64<Self>) -> [i8; 64]
fn as_array_mask8x64(self, a: mask8x64<Self>) -> [i8; 64]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask8x64(self, a: &mask8x64<Self>) -> &[i8; 64]
fn as_array_ref_mask8x64(self, a: &mask8x64<Self>) -> &[i8; 64]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask8x64(self, a: &mut mask8x64<Self>) -> &mut [i8; 64]
fn as_array_mut_mask8x64(self, a: &mut mask8x64<Self>) -> &mut [i8; 64]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask8x64(self, a: mask8x64<Self>, dest: &mut [i8; 64])
fn store_array_mask8x64(self, a: mask8x64<Self>, dest: &mut [i8; 64])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask8x64(self, a: u8x64<Self>) -> mask8x64<Self>
fn cvt_from_bytes_mask8x64(self, a: u8x64<Self>) -> mask8x64<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask8x64(self, a: mask8x64<Self>) -> u8x64<Self>
fn cvt_to_bytes_mask8x64(self, a: mask8x64<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask8x64<const SHIFT: usize>(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
) -> mask8x64<Self>
fn slide_mask8x64<const SHIFT: usize>( self, a: mask8x64<Self>, b: mask8x64<Self>, ) -> mask8x64<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask8x64<const SHIFT: usize>(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
) -> mask8x64<Self>
fn slide_within_blocks_mask8x64<const SHIFT: usize>( self, a: mask8x64<Self>, b: mask8x64<Self>, ) -> mask8x64<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>
fn and_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>
Compute the logical AND of two masks.
Sourcefn or_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>
fn or_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>
fn xor_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask8x64(self, a: mask8x64<Self>) -> mask8x64<Self>
fn not_mask8x64(self, a: mask8x64<Self>) -> mask8x64<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask8x64(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
c: mask8x64<Self>,
) -> mask8x64<Self>
fn select_mask8x64( self, a: mask8x64<Self>, b: mask8x64<Self>, c: mask8x64<Self>, ) -> mask8x64<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask8x64(
self,
a: mask8x64<Self>,
b: mask8x64<Self>,
) -> mask8x64<Self>
fn simd_eq_mask8x64( self, a: mask8x64<Self>, b: mask8x64<Self>, ) -> mask8x64<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask8x64(self, a: mask8x64<Self>) -> bool
fn any_true_mask8x64(self, a: mask8x64<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask8x64(self, a: mask8x64<Self>) -> bool
fn all_true_mask8x64(self, a: mask8x64<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask8x64(self, a: mask8x64<Self>) -> bool
fn any_false_mask8x64(self, a: mask8x64<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask8x64(self, a: mask8x64<Self>) -> bool
fn all_false_mask8x64(self, a: mask8x64<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn split_mask8x64(self, a: mask8x64<Self>) -> (mask8x32<Self>, mask8x32<Self>)
fn split_mask8x64(self, a: mask8x64<Self>) -> (mask8x32<Self>, mask8x32<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn splat_i16x32(self, val: i16) -> i16x32<Self>
fn splat_i16x32(self, val: i16) -> i16x32<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i16x32(self, val: [i16; 32]) -> i16x32<Self>
fn load_array_i16x32(self, val: [i16; 32]) -> i16x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i16x32(self, val: &[i16; 32]) -> i16x32<Self>
fn load_array_ref_i16x32(self, val: &[i16; 32]) -> i16x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i16x32(self, a: i16x32<Self>) -> [i16; 32]
fn as_array_i16x32(self, a: i16x32<Self>) -> [i16; 32]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i16x32(self, a: &i16x32<Self>) -> &[i16; 32]
fn as_array_ref_i16x32(self, a: &i16x32<Self>) -> &[i16; 32]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i16x32(self, a: &mut i16x32<Self>) -> &mut [i16; 32]
fn as_array_mut_i16x32(self, a: &mut i16x32<Self>) -> &mut [i16; 32]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i16x32(self, a: i16x32<Self>, dest: &mut [i16; 32])
fn store_array_i16x32(self, a: i16x32<Self>, dest: &mut [i16; 32])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i16x32(self, a: u8x64<Self>) -> i16x32<Self>
fn cvt_from_bytes_i16x32(self, a: u8x64<Self>) -> i16x32<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i16x32(self, a: i16x32<Self>) -> u8x64<Self>
fn cvt_to_bytes_i16x32(self, a: i16x32<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i16x32<const SHIFT: usize>(
self,
a: i16x32<Self>,
b: i16x32<Self>,
) -> i16x32<Self>
fn slide_i16x32<const SHIFT: usize>( self, a: i16x32<Self>, b: i16x32<Self>, ) -> i16x32<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i16x32<const SHIFT: usize>(
self,
a: i16x32<Self>,
b: i16x32<Self>,
) -> i16x32<Self>
fn slide_within_blocks_i16x32<const SHIFT: usize>( self, a: i16x32<Self>, b: i16x32<Self>, ) -> i16x32<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn add_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn sub_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn mul_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn and_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn or_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn xor_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Compute the bitwise XOR of two vectors.
Sourcefn not_i16x32(self, a: i16x32<Self>) -> i16x32<Self>
fn not_i16x32(self, a: i16x32<Self>) -> i16x32<Self>
Compute the bitwise NOT of the vector.
Sourcefn shl_i16x32(self, a: i16x32<Self>, shift: u32) -> i16x32<Self>
fn shl_i16x32(self, a: i16x32<Self>, shift: u32) -> i16x32<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn shlv_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i16x32(self, a: i16x32<Self>, shift: u32) -> i16x32<Self>
fn shr_i16x32(self, a: i16x32<Self>, shift: u32) -> i16x32<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn shrv_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
fn simd_eq_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
fn simd_lt_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
fn simd_le_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
fn simd_ge_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
fn simd_gt_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn zip_low_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn zip_high_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn unzip_low_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn unzip_high_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i16x32(
self,
a: i16x32<Self>,
b: i16x32<Self>,
) -> (i16x32<Self>, i16x32<Self>)
fn interleave_i16x32( self, a: i16x32<Self>, b: i16x32<Self>, ) -> (i16x32<Self>, i16x32<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i16x32(
self,
a: i16x32<Self>,
b: i16x32<Self>,
) -> (i16x32<Self>, i16x32<Self>)
fn deinterleave_i16x32( self, a: i16x32<Self>, b: i16x32<Self>, ) -> (i16x32<Self>, i16x32<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i16x32(
self,
a: mask16x32<Self>,
b: i16x32<Self>,
c: i16x32<Self>,
) -> i16x32<Self>
fn select_i16x32( self, a: mask16x32<Self>, b: i16x32<Self>, c: i16x32<Self>, ) -> i16x32<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn min_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
fn max_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>
Return the element-wise maximum of two vectors.
Sourcefn split_i16x32(self, a: i16x32<Self>) -> (i16x16<Self>, i16x16<Self>)
fn split_i16x32(self, a: i16x32<Self>) -> (i16x16<Self>, i16x16<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn neg_i16x32(self, a: i16x32<Self>) -> i16x32<Self>
fn neg_i16x32(self, a: i16x32<Self>) -> i16x32<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i16x32(self, a: i16x32<Self>) -> u8x64<Self>
fn reinterpret_u8_i16x32(self, a: i16x32<Self>) -> u8x64<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i16x32(self, a: i16x32<Self>) -> u32x16<Self>
fn reinterpret_u32_i16x32(self, a: i16x32<Self>) -> u32x16<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_u16x32(self, val: u16) -> u16x32<Self>
fn splat_u16x32(self, val: u16) -> u16x32<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u16x32(self, val: [u16; 32]) -> u16x32<Self>
fn load_array_u16x32(self, val: [u16; 32]) -> u16x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u16x32(self, val: &[u16; 32]) -> u16x32<Self>
fn load_array_ref_u16x32(self, val: &[u16; 32]) -> u16x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u16x32(self, a: u16x32<Self>) -> [u16; 32]
fn as_array_u16x32(self, a: u16x32<Self>) -> [u16; 32]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u16x32(self, a: &u16x32<Self>) -> &[u16; 32]
fn as_array_ref_u16x32(self, a: &u16x32<Self>) -> &[u16; 32]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u16x32(self, a: &mut u16x32<Self>) -> &mut [u16; 32]
fn as_array_mut_u16x32(self, a: &mut u16x32<Self>) -> &mut [u16; 32]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u16x32(self, a: u16x32<Self>, dest: &mut [u16; 32])
fn store_array_u16x32(self, a: u16x32<Self>, dest: &mut [u16; 32])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u16x32(self, a: u8x64<Self>) -> u16x32<Self>
fn cvt_from_bytes_u16x32(self, a: u8x64<Self>) -> u16x32<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u16x32(self, a: u16x32<Self>) -> u8x64<Self>
fn cvt_to_bytes_u16x32(self, a: u16x32<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u16x32<const SHIFT: usize>(
self,
a: u16x32<Self>,
b: u16x32<Self>,
) -> u16x32<Self>
fn slide_u16x32<const SHIFT: usize>( self, a: u16x32<Self>, b: u16x32<Self>, ) -> u16x32<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u16x32<const SHIFT: usize>(
self,
a: u16x32<Self>,
b: u16x32<Self>,
) -> u16x32<Self>
fn slide_within_blocks_u16x32<const SHIFT: usize>( self, a: u16x32<Self>, b: u16x32<Self>, ) -> u16x32<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn add_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn sub_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn mul_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn and_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn or_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn xor_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Compute the bitwise XOR of two vectors.
Sourcefn not_u16x32(self, a: u16x32<Self>) -> u16x32<Self>
fn not_u16x32(self, a: u16x32<Self>) -> u16x32<Self>
Compute the bitwise NOT of the vector.
Sourcefn shl_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self>
fn shl_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn shlv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self>
fn shr_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn shrv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
fn simd_eq_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
fn simd_lt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
fn simd_le_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
fn simd_ge_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
fn simd_gt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn zip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn zip_high_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn unzip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn unzip_high_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u16x32(
self,
a: u16x32<Self>,
b: u16x32<Self>,
) -> (u16x32<Self>, u16x32<Self>)
fn interleave_u16x32( self, a: u16x32<Self>, b: u16x32<Self>, ) -> (u16x32<Self>, u16x32<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u16x32(
self,
a: u16x32<Self>,
b: u16x32<Self>,
) -> (u16x32<Self>, u16x32<Self>)
fn deinterleave_u16x32( self, a: u16x32<Self>, b: u16x32<Self>, ) -> (u16x32<Self>, u16x32<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u16x32(
self,
a: mask16x32<Self>,
b: u16x32<Self>,
c: u16x32<Self>,
) -> u16x32<Self>
fn select_u16x32( self, a: mask16x32<Self>, b: u16x32<Self>, c: u16x32<Self>, ) -> u16x32<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn min_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
fn max_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>
Return the element-wise maximum of two vectors.
Sourcefn split_u16x32(self, a: u16x32<Self>) -> (u16x16<Self>, u16x16<Self>)
fn split_u16x32(self, a: u16x32<Self>) -> (u16x16<Self>, u16x16<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn load_interleaved_128_u16x32(self, src: &[u16; 32]) -> u16x32<Self>
fn load_interleaved_128_u16x32(self, src: &[u16; 32]) -> u16x32<Self>
Load elements from an array with 4-way interleaving.
Reads consecutive elements and deinterleaves them into a single vector.
Sourcefn store_interleaved_128_u16x32(self, a: u16x32<Self>, dest: &mut [u16; 32])
fn store_interleaved_128_u16x32(self, a: u16x32<Self>, dest: &mut [u16; 32])
Store elements to an array with 4-way interleaving.
Interleaves the vector elements and writes them consecutively to memory.
Sourcefn narrow_u16x32(self, a: u16x32<Self>) -> u8x32<Self>
fn narrow_u16x32(self, a: u16x32<Self>) -> u8x32<Self>
Truncate each element to a narrower integer type.
The number of elements in the result is twice that of the input.
Sourcefn reinterpret_u8_u16x32(self, a: u16x32<Self>) -> u8x64<Self>
fn reinterpret_u8_u16x32(self, a: u16x32<Self>) -> u8x64<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_u16x32(self, a: u16x32<Self>) -> u32x16<Self>
fn reinterpret_u32_u16x32(self, a: u16x32<Self>) -> u32x16<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn splat_mask16x32(self, val: i16) -> mask16x32<Self>
fn splat_mask16x32(self, val: i16) -> mask16x32<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask16x32(self, val: [i16; 32]) -> mask16x32<Self>
fn load_array_mask16x32(self, val: [i16; 32]) -> mask16x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask16x32(self, val: &[i16; 32]) -> mask16x32<Self>
fn load_array_ref_mask16x32(self, val: &[i16; 32]) -> mask16x32<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask16x32(self, a: mask16x32<Self>) -> [i16; 32]
fn as_array_mask16x32(self, a: mask16x32<Self>) -> [i16; 32]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask16x32(self, a: &mask16x32<Self>) -> &[i16; 32]
fn as_array_ref_mask16x32(self, a: &mask16x32<Self>) -> &[i16; 32]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask16x32(self, a: &mut mask16x32<Self>) -> &mut [i16; 32]
fn as_array_mut_mask16x32(self, a: &mut mask16x32<Self>) -> &mut [i16; 32]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask16x32(self, a: mask16x32<Self>, dest: &mut [i16; 32])
fn store_array_mask16x32(self, a: mask16x32<Self>, dest: &mut [i16; 32])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask16x32(self, a: u8x64<Self>) -> mask16x32<Self>
fn cvt_from_bytes_mask16x32(self, a: u8x64<Self>) -> mask16x32<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask16x32(self, a: mask16x32<Self>) -> u8x64<Self>
fn cvt_to_bytes_mask16x32(self, a: mask16x32<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask16x32<const SHIFT: usize>(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>
fn slide_mask16x32<const SHIFT: usize>( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask16x32<const SHIFT: usize>(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>
fn slide_within_blocks_mask16x32<const SHIFT: usize>( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>
fn and_mask16x32( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>
Compute the logical AND of two masks.
Sourcefn or_mask16x32(self, a: mask16x32<Self>, b: mask16x32<Self>) -> mask16x32<Self>
fn or_mask16x32(self, a: mask16x32<Self>, b: mask16x32<Self>) -> mask16x32<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>
fn xor_mask16x32( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask16x32(self, a: mask16x32<Self>) -> mask16x32<Self>
fn not_mask16x32(self, a: mask16x32<Self>) -> mask16x32<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
c: mask16x32<Self>,
) -> mask16x32<Self>
fn select_mask16x32( self, a: mask16x32<Self>, b: mask16x32<Self>, c: mask16x32<Self>, ) -> mask16x32<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask16x32(
self,
a: mask16x32<Self>,
b: mask16x32<Self>,
) -> mask16x32<Self>
fn simd_eq_mask16x32( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask16x32(self, a: mask16x32<Self>) -> bool
fn any_true_mask16x32(self, a: mask16x32<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask16x32(self, a: mask16x32<Self>) -> bool
fn all_true_mask16x32(self, a: mask16x32<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask16x32(self, a: mask16x32<Self>) -> bool
fn any_false_mask16x32(self, a: mask16x32<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask16x32(self, a: mask16x32<Self>) -> bool
fn all_false_mask16x32(self, a: mask16x32<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn split_mask16x32(
self,
a: mask16x32<Self>,
) -> (mask16x16<Self>, mask16x16<Self>)
fn split_mask16x32( self, a: mask16x32<Self>, ) -> (mask16x16<Self>, mask16x16<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn splat_i32x16(self, val: i32) -> i32x16<Self>
fn splat_i32x16(self, val: i32) -> i32x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_i32x16(self, val: [i32; 16]) -> i32x16<Self>
fn load_array_i32x16(self, val: [i32; 16]) -> i32x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_i32x16(self, val: &[i32; 16]) -> i32x16<Self>
fn load_array_ref_i32x16(self, val: &[i32; 16]) -> i32x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_i32x16(self, a: i32x16<Self>) -> [i32; 16]
fn as_array_i32x16(self, a: i32x16<Self>) -> [i32; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_i32x16(self, a: &i32x16<Self>) -> &[i32; 16]
fn as_array_ref_i32x16(self, a: &i32x16<Self>) -> &[i32; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_i32x16(self, a: &mut i32x16<Self>) -> &mut [i32; 16]
fn as_array_mut_i32x16(self, a: &mut i32x16<Self>) -> &mut [i32; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_i32x16(self, a: i32x16<Self>, dest: &mut [i32; 16])
fn store_array_i32x16(self, a: i32x16<Self>, dest: &mut [i32; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_i32x16(self, a: u8x64<Self>) -> i32x16<Self>
fn cvt_from_bytes_i32x16(self, a: u8x64<Self>) -> i32x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_i32x16(self, a: i32x16<Self>) -> u8x64<Self>
fn cvt_to_bytes_i32x16(self, a: i32x16<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_i32x16<const SHIFT: usize>(
self,
a: i32x16<Self>,
b: i32x16<Self>,
) -> i32x16<Self>
fn slide_i32x16<const SHIFT: usize>( self, a: i32x16<Self>, b: i32x16<Self>, ) -> i32x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_i32x16<const SHIFT: usize>(
self,
a: i32x16<Self>,
b: i32x16<Self>,
) -> i32x16<Self>
fn slide_within_blocks_i32x16<const SHIFT: usize>( self, a: i32x16<Self>, b: i32x16<Self>, ) -> i32x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn add_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn sub_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn mul_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn and_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn or_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn xor_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Compute the bitwise XOR of two vectors.
Sourcefn not_i32x16(self, a: i32x16<Self>) -> i32x16<Self>
fn not_i32x16(self, a: i32x16<Self>) -> i32x16<Self>
Compute the bitwise NOT of the vector.
Sourcefn shl_i32x16(self, a: i32x16<Self>, shift: u32) -> i32x16<Self>
fn shl_i32x16(self, a: i32x16<Self>, shift: u32) -> i32x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn shlv_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_i32x16(self, a: i32x16<Self>, shift: u32) -> i32x16<Self>
fn shr_i32x16(self, a: i32x16<Self>, shift: u32) -> i32x16<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn shrv_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
fn simd_eq_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
fn simd_lt_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
fn simd_le_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
fn simd_ge_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
fn simd_gt_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn zip_low_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn zip_high_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn unzip_low_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn unzip_high_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_i32x16(
self,
a: i32x16<Self>,
b: i32x16<Self>,
) -> (i32x16<Self>, i32x16<Self>)
fn interleave_i32x16( self, a: i32x16<Self>, b: i32x16<Self>, ) -> (i32x16<Self>, i32x16<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_i32x16(
self,
a: i32x16<Self>,
b: i32x16<Self>,
) -> (i32x16<Self>, i32x16<Self>)
fn deinterleave_i32x16( self, a: i32x16<Self>, b: i32x16<Self>, ) -> (i32x16<Self>, i32x16<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_i32x16(
self,
a: mask32x16<Self>,
b: i32x16<Self>,
c: i32x16<Self>,
) -> i32x16<Self>
fn select_i32x16( self, a: mask32x16<Self>, b: i32x16<Self>, c: i32x16<Self>, ) -> i32x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn min_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
fn max_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>
Return the element-wise maximum of two vectors.
Sourcefn split_i32x16(self, a: i32x16<Self>) -> (i32x8<Self>, i32x8<Self>)
fn split_i32x16(self, a: i32x16<Self>) -> (i32x8<Self>, i32x8<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn neg_i32x16(self, a: i32x16<Self>) -> i32x16<Self>
fn neg_i32x16(self, a: i32x16<Self>) -> i32x16<Self>
Negate each element of the vector, wrapping on overflow.
Sourcefn reinterpret_u8_i32x16(self, a: i32x16<Self>) -> u8x64<Self>
fn reinterpret_u8_i32x16(self, a: i32x16<Self>) -> u8x64<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn reinterpret_u32_i32x16(self, a: i32x16<Self>) -> u32x16<Self>
fn reinterpret_u32_i32x16(self, a: i32x16<Self>) -> u32x16<Self>
Reinterpret the bits of this vector as a vector of u32 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_f32_i32x16(self, a: i32x16<Self>) -> f32x16<Self>
fn cvt_f32_i32x16(self, a: i32x16<Self>) -> f32x16<Self>
Convert each signed 32-bit integer element to a floating-point value.
Values that cannot be exactly represented are rounded to the nearest representable value.
Sourcefn splat_u32x16(self, val: u32) -> u32x16<Self>
fn splat_u32x16(self, val: u32) -> u32x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_u32x16(self, val: [u32; 16]) -> u32x16<Self>
fn load_array_u32x16(self, val: [u32; 16]) -> u32x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_u32x16(self, val: &[u32; 16]) -> u32x16<Self>
fn load_array_ref_u32x16(self, val: &[u32; 16]) -> u32x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_u32x16(self, a: u32x16<Self>) -> [u32; 16]
fn as_array_u32x16(self, a: u32x16<Self>) -> [u32; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_u32x16(self, a: &u32x16<Self>) -> &[u32; 16]
fn as_array_ref_u32x16(self, a: &u32x16<Self>) -> &[u32; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_u32x16(self, a: &mut u32x16<Self>) -> &mut [u32; 16]
fn as_array_mut_u32x16(self, a: &mut u32x16<Self>) -> &mut [u32; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_u32x16(self, a: u32x16<Self>, dest: &mut [u32; 16])
fn store_array_u32x16(self, a: u32x16<Self>, dest: &mut [u32; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_u32x16(self, a: u8x64<Self>) -> u32x16<Self>
fn cvt_from_bytes_u32x16(self, a: u8x64<Self>) -> u32x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_u32x16(self, a: u32x16<Self>) -> u8x64<Self>
fn cvt_to_bytes_u32x16(self, a: u32x16<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_u32x16<const SHIFT: usize>(
self,
a: u32x16<Self>,
b: u32x16<Self>,
) -> u32x16<Self>
fn slide_u32x16<const SHIFT: usize>( self, a: u32x16<Self>, b: u32x16<Self>, ) -> u32x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_u32x16<const SHIFT: usize>(
self,
a: u32x16<Self>,
b: u32x16<Self>,
) -> u32x16<Self>
fn slide_within_blocks_u32x16<const SHIFT: usize>( self, a: u32x16<Self>, b: u32x16<Self>, ) -> u32x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn add_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn add_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Add two vectors element-wise, wrapping on overflow.
Sourcefn sub_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn sub_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Subtract two vectors element-wise, wrapping on overflow.
Sourcefn mul_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn mul_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Multiply two vectors element-wise, wrapping on overflow.
Sourcefn and_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn and_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Compute the bitwise AND of two vectors.
Sourcefn or_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn or_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Compute the bitwise OR of two vectors.
Sourcefn xor_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn xor_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Compute the bitwise XOR of two vectors.
Sourcefn not_u32x16(self, a: u32x16<Self>) -> u32x16<Self>
fn not_u32x16(self, a: u32x16<Self>) -> u32x16<Self>
Compute the bitwise NOT of the vector.
Sourcefn shl_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self>
fn shl_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
Sourcefn shlv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn shlv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Shift each element left by the given number of bits.
Bits shifted out of the left side are discarded, and zeros are shifted in on the right.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn shr_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self>
fn shr_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self>
Shift each element right by the given number of bits.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
Sourcefn shrv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn shrv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Shift each element right by the corresponding element in another vector.
For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.
This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.
Sourcefn simd_eq_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
fn simd_eq_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
fn simd_lt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
fn simd_le_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
fn simd_ge_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
fn simd_gt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn zip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn zip_high_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn unzip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn unzip_high_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_u32x16(
self,
a: u32x16<Self>,
b: u32x16<Self>,
) -> (u32x16<Self>, u32x16<Self>)
fn interleave_u32x16( self, a: u32x16<Self>, b: u32x16<Self>, ) -> (u32x16<Self>, u32x16<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_u32x16(
self,
a: u32x16<Self>,
b: u32x16<Self>,
) -> (u32x16<Self>, u32x16<Self>)
fn deinterleave_u32x16( self, a: u32x16<Self>, b: u32x16<Self>, ) -> (u32x16<Self>, u32x16<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn select_u32x16(
self,
a: mask32x16<Self>,
b: u32x16<Self>,
c: u32x16<Self>,
) -> u32x16<Self>
fn select_u32x16( self, a: mask32x16<Self>, b: u32x16<Self>, c: u32x16<Self>, ) -> u32x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn min_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn min_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Return the element-wise minimum of two vectors.
Sourcefn max_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
fn max_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>
Return the element-wise maximum of two vectors.
Sourcefn split_u32x16(self, a: u32x16<Self>) -> (u32x8<Self>, u32x8<Self>)
fn split_u32x16(self, a: u32x16<Self>) -> (u32x8<Self>, u32x8<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn load_interleaved_128_u32x16(self, src: &[u32; 16]) -> u32x16<Self>
fn load_interleaved_128_u32x16(self, src: &[u32; 16]) -> u32x16<Self>
Load elements from an array with 4-way interleaving.
Reads consecutive elements and deinterleaves them into a single vector.
Sourcefn store_interleaved_128_u32x16(self, a: u32x16<Self>, dest: &mut [u32; 16])
fn store_interleaved_128_u32x16(self, a: u32x16<Self>, dest: &mut [u32; 16])
Store elements to an array with 4-way interleaving.
Interleaves the vector elements and writes them consecutively to memory.
Sourcefn reinterpret_u8_u32x16(self, a: u32x16<Self>) -> u8x64<Self>
fn reinterpret_u8_u32x16(self, a: u32x16<Self>) -> u8x64<Self>
Reinterpret the bits of this vector as a vector of u8 elements.
The total bit width is preserved; the number of elements changes accordingly.
Sourcefn cvt_f32_u32x16(self, a: u32x16<Self>) -> f32x16<Self>
fn cvt_f32_u32x16(self, a: u32x16<Self>) -> f32x16<Self>
Convert each unsigned 32-bit integer element to a floating-point value.
Values that cannot be exactly represented are rounded to the nearest representable value.
Sourcefn splat_mask32x16(self, val: i32) -> mask32x16<Self>
fn splat_mask32x16(self, val: i32) -> mask32x16<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask32x16(self, val: [i32; 16]) -> mask32x16<Self>
fn load_array_mask32x16(self, val: [i32; 16]) -> mask32x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask32x16(self, val: &[i32; 16]) -> mask32x16<Self>
fn load_array_ref_mask32x16(self, val: &[i32; 16]) -> mask32x16<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask32x16(self, a: mask32x16<Self>) -> [i32; 16]
fn as_array_mask32x16(self, a: mask32x16<Self>) -> [i32; 16]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask32x16(self, a: &mask32x16<Self>) -> &[i32; 16]
fn as_array_ref_mask32x16(self, a: &mask32x16<Self>) -> &[i32; 16]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask32x16(self, a: &mut mask32x16<Self>) -> &mut [i32; 16]
fn as_array_mut_mask32x16(self, a: &mut mask32x16<Self>) -> &mut [i32; 16]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask32x16(self, a: mask32x16<Self>, dest: &mut [i32; 16])
fn store_array_mask32x16(self, a: mask32x16<Self>, dest: &mut [i32; 16])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask32x16(self, a: u8x64<Self>) -> mask32x16<Self>
fn cvt_from_bytes_mask32x16(self, a: u8x64<Self>) -> mask32x16<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask32x16(self, a: mask32x16<Self>) -> u8x64<Self>
fn cvt_to_bytes_mask32x16(self, a: mask32x16<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask32x16<const SHIFT: usize>(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>
fn slide_mask32x16<const SHIFT: usize>( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask32x16<const SHIFT: usize>(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>
fn slide_within_blocks_mask32x16<const SHIFT: usize>( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>
fn and_mask32x16( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>
Compute the logical AND of two masks.
Sourcefn or_mask32x16(self, a: mask32x16<Self>, b: mask32x16<Self>) -> mask32x16<Self>
fn or_mask32x16(self, a: mask32x16<Self>, b: mask32x16<Self>) -> mask32x16<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>
fn xor_mask32x16( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask32x16(self, a: mask32x16<Self>) -> mask32x16<Self>
fn not_mask32x16(self, a: mask32x16<Self>) -> mask32x16<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
c: mask32x16<Self>,
) -> mask32x16<Self>
fn select_mask32x16( self, a: mask32x16<Self>, b: mask32x16<Self>, c: mask32x16<Self>, ) -> mask32x16<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask32x16(
self,
a: mask32x16<Self>,
b: mask32x16<Self>,
) -> mask32x16<Self>
fn simd_eq_mask32x16( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask32x16(self, a: mask32x16<Self>) -> bool
fn any_true_mask32x16(self, a: mask32x16<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask32x16(self, a: mask32x16<Self>) -> bool
fn all_true_mask32x16(self, a: mask32x16<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask32x16(self, a: mask32x16<Self>) -> bool
fn any_false_mask32x16(self, a: mask32x16<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask32x16(self, a: mask32x16<Self>) -> bool
fn all_false_mask32x16(self, a: mask32x16<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn split_mask32x16(self, a: mask32x16<Self>) -> (mask32x8<Self>, mask32x8<Self>)
fn split_mask32x16(self, a: mask32x16<Self>) -> (mask32x8<Self>, mask32x8<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn splat_f64x8(self, val: f64) -> f64x8<Self>
fn splat_f64x8(self, val: f64) -> f64x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_f64x8(self, val: [f64; 8]) -> f64x8<Self>
fn load_array_f64x8(self, val: [f64; 8]) -> f64x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_f64x8(self, val: &[f64; 8]) -> f64x8<Self>
fn load_array_ref_f64x8(self, val: &[f64; 8]) -> f64x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_f64x8(self, a: f64x8<Self>) -> [f64; 8]
fn as_array_f64x8(self, a: f64x8<Self>) -> [f64; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_f64x8(self, a: &f64x8<Self>) -> &[f64; 8]
fn as_array_ref_f64x8(self, a: &f64x8<Self>) -> &[f64; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_f64x8(self, a: &mut f64x8<Self>) -> &mut [f64; 8]
fn as_array_mut_f64x8(self, a: &mut f64x8<Self>) -> &mut [f64; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_f64x8(self, a: f64x8<Self>, dest: &mut [f64; 8])
fn store_array_f64x8(self, a: f64x8<Self>, dest: &mut [f64; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_f64x8(self, a: u8x64<Self>) -> f64x8<Self>
fn cvt_from_bytes_f64x8(self, a: u8x64<Self>) -> f64x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_f64x8(self, a: f64x8<Self>) -> u8x64<Self>
fn cvt_to_bytes_f64x8(self, a: f64x8<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_f64x8<const SHIFT: usize>(
self,
a: f64x8<Self>,
b: f64x8<Self>,
) -> f64x8<Self>
fn slide_f64x8<const SHIFT: usize>( self, a: f64x8<Self>, b: f64x8<Self>, ) -> f64x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_f64x8<const SHIFT: usize>(
self,
a: f64x8<Self>,
b: f64x8<Self>,
) -> f64x8<Self>
fn slide_within_blocks_f64x8<const SHIFT: usize>( self, a: f64x8<Self>, b: f64x8<Self>, ) -> f64x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn sqrt_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
fn sqrt_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
Compute the square root of each element.
Negative elements other than -0.0 will become NaN.
Sourcefn add_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn add_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Add two vectors element-wise.
Sourcefn sub_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn sub_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Subtract two vectors element-wise.
Sourcefn mul_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn mul_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Multiply two vectors element-wise.
Sourcefn div_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn div_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Divide two vectors element-wise.
Sourcefn copysign_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn copysign_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Return a vector with the magnitude of a and the sign of b for each element.
This operation copies the sign bit, so if an input element is NaN, the output element will be a NaN with the same payload and a copied sign bit.
Sourcefn simd_eq_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
fn simd_eq_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn simd_lt_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
fn simd_lt_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
Compare two vectors element-wise for less than.
Returns a mask where each element is all ones if a is less than b, and all zeroes if not.
Sourcefn simd_le_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
fn simd_le_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
Compare two vectors element-wise for less than or equal.
Returns a mask where each element is all ones if a is less than or equal to b, and all zeroes if not.
Sourcefn simd_ge_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
fn simd_ge_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
Compare two vectors element-wise for greater than or equal.
Returns a mask where each element is all ones if a is greater than or equal to b, and all zeroes if not.
Sourcefn simd_gt_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
fn simd_gt_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>
Compare two vectors element-wise for greater than.
Returns a mask where each element is all ones if a is greater than b, and all zeroes if not.
Sourcefn zip_low_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn zip_low_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Interleave the lower half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, b0, a1, b1].
Note: This operation is only useful if you need to discard elements a2, a3, b2, b3.
For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn zip_high_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn zip_high_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Interleave the upper half elements of two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a2, b2, a3, b3].
Note: This operation is only useful if you need to discard elements a0, a1, b0, b1.For fully interleaving two vectors prefer interleave,
which is faster than zip_low followed by zip_high on some platforms.
Sourcefn unzip_low_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn unzip_low_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Extract even-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a0, a2, b0, b2].
Note: This operation is only useful if you need to discard elements a1, a3, b1, b3.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn unzip_high_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn unzip_high_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Extract odd-indexed elements from two vectors.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns [a1, a3, b1, b3].
Note: This operation is only useful if you need to discard elements a0, a2, b0, b2.For fully deinterleaving two vectors prefer deinterleave,
which is faster than unzip_low followed by unzip_high on some platforms.
Sourcefn interleave_f64x8(
self,
a: f64x8<Self>,
b: f64x8<Self>,
) -> (f64x8<Self>, f64x8<Self>)
fn interleave_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, ) -> (f64x8<Self>, f64x8<Self>)
Interleave two vectors.
The resulting vectors contain elements taken alternately from a and b, first filling the first result, and then the second.
The reverse of this operation is deinterleave.
For vectors [a0, a1, a2, a3] and [b0, b1, b2, b3], returns ([a0, b0, a1, b1], [a2, b2, a3, b3]).
Sourcefn deinterleave_f64x8(
self,
a: f64x8<Self>,
b: f64x8<Self>,
) -> (f64x8<Self>, f64x8<Self>)
fn deinterleave_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, ) -> (f64x8<Self>, f64x8<Self>)
Deinterleave two vectors.
The first result contains all even-indexed elements from a followed by all even-indexed elements from b. The second result contains all odd-indexed elements from a followed by all odd-indexed elements from b.
The reverse of this operation is interleave.
For vectors [a0, b0, a1, b1] and [a2, b2, a3, b3], returns ([a0, a1, a2, a3], [b0, b1, b2, b3]).
Sourcefn max_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn max_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Return the element-wise maximum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See max_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn min_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn min_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Return the element-wise minimum of two vectors.
If either operand is NaN, the result for that lane is implementation-defined– it could be either the first or second operand. See min_precise for a version that returns the non-NaN operand if only one is NaN.
If one operand is positive zero and the other is negative zero, the result is also implementation-defined, and it could be either one.
Sourcefn max_precise_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn max_precise_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Return the element-wise maximum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn min_precise_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
fn min_precise_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>
Return the element-wise minimum of two vectors.
If one operand is a quiet NaN and the other is not, this operation will choose the non-NaN operand.
If one operand is positive zero and the other is negative zero, the result is implementation-defined, and it could be either one.
If an operand is a signaling NaN, the result is not just implementation-defined, but fully non-deterministic: it may be either NaN or the non-NaN operand. Signaling NaN values are not produced by floating-point math operations, only from manual initialization with specific bit patterns. You probably don’t need to worry about them.
Sourcefn mul_add_f64x8(
self,
a: f64x8<Self>,
b: f64x8<Self>,
c: f64x8<Self>,
) -> f64x8<Self>
fn mul_add_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, c: f64x8<Self>, ) -> f64x8<Self>
Compute (a * b) + c (fused multiply-add) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by an add, which will result in two rounding errors.
Sourcefn mul_sub_f64x8(
self,
a: f64x8<Self>,
b: f64x8<Self>,
c: f64x8<Self>,
) -> f64x8<Self>
fn mul_sub_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, c: f64x8<Self>, ) -> f64x8<Self>
Compute (a * b) - c (fused multiply-subtract) for each element.
Depending on hardware support, the result may be computed with only one rounding error, or may be implemented as a regular multiply followed by a subtract, which will result in two rounding errors.
Sourcefn floor_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
fn floor_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
Return the largest integer less than or equal to each element, that is, round towards negative infinity.
Sourcefn ceil_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
fn ceil_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.
Sourcefn round_ties_even_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
fn round_ties_even_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
Round each element to the nearest integer, with ties rounding to the nearest even integer.
There is no corresponding round operation. Rust’s round operation rounds ties away from zero, a behavior it inherited from C. That behavior is not implemented across all platforms, whereas round-ties-even is.
Sourcefn fract_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
fn fract_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
Return the fractional part of each element.
This is equivalent to a - a.trunc().
Sourcefn trunc_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
fn trunc_f64x8(self, a: f64x8<Self>) -> f64x8<Self>
Return the integer part of each element, rounding towards zero.
Sourcefn select_f64x8(
self,
a: mask64x8<Self>,
b: f64x8<Self>,
c: f64x8<Self>,
) -> f64x8<Self>
fn select_f64x8( self, a: mask64x8<Self>, b: f64x8<Self>, c: f64x8<Self>, ) -> f64x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn split_f64x8(self, a: f64x8<Self>) -> (f64x4<Self>, f64x4<Self>)
fn split_f64x8(self, a: f64x8<Self>) -> (f64x4<Self>, f64x4<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Sourcefn reinterpret_f32_f64x8(self, a: f64x8<Self>) -> f32x16<Self>
fn reinterpret_f32_f64x8(self, a: f64x8<Self>) -> f32x16<Self>
Reinterpret the bits of this vector as a vector of f32 elements.
The number of elements in the result is twice that of the input.
Sourcefn splat_mask64x8(self, val: i64) -> mask64x8<Self>
fn splat_mask64x8(self, val: i64) -> mask64x8<Self>
Create a SIMD vector with all elements set to the given value.
Sourcefn load_array_mask64x8(self, val: [i64; 8]) -> mask64x8<Self>
fn load_array_mask64x8(self, val: [i64; 8]) -> mask64x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn load_array_ref_mask64x8(self, val: &[i64; 8]) -> mask64x8<Self>
fn load_array_ref_mask64x8(self, val: &[i64; 8]) -> mask64x8<Self>
Create a SIMD vector from an array of the same length.
Sourcefn as_array_mask64x8(self, a: mask64x8<Self>) -> [i64; 8]
fn as_array_mask64x8(self, a: mask64x8<Self>) -> [i64; 8]
Convert a SIMD vector to an array.
Sourcefn as_array_ref_mask64x8(self, a: &mask64x8<Self>) -> &[i64; 8]
fn as_array_ref_mask64x8(self, a: &mask64x8<Self>) -> &[i64; 8]
Project a reference to a SIMD vector to a reference to the equivalent array.
Sourcefn as_array_mut_mask64x8(self, a: &mut mask64x8<Self>) -> &mut [i64; 8]
fn as_array_mut_mask64x8(self, a: &mut mask64x8<Self>) -> &mut [i64; 8]
Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.
Sourcefn store_array_mask64x8(self, a: mask64x8<Self>, dest: &mut [i64; 8])
fn store_array_mask64x8(self, a: mask64x8<Self>, dest: &mut [i64; 8])
Store a SIMD vector into an array of the same length.
Sourcefn cvt_from_bytes_mask64x8(self, a: u8x64<Self>) -> mask64x8<Self>
fn cvt_from_bytes_mask64x8(self, a: u8x64<Self>) -> mask64x8<Self>
Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.
Sourcefn cvt_to_bytes_mask64x8(self, a: mask64x8<Self>) -> u8x64<Self>
fn cvt_to_bytes_mask64x8(self, a: mask64x8<Self>) -> u8x64<Self>
Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.
Sourcefn slide_mask64x8<const SHIFT: usize>(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
) -> mask64x8<Self>
fn slide_mask64x8<const SHIFT: usize>( self, a: mask64x8<Self>, b: mask64x8<Self>, ) -> mask64x8<Self>
Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.
SHIFT must be within [0, Self::N].
This can be used to implement a “shift items” operation by providing all zeroes as one operand. For a left shift, the right-hand side should be all zeroes. For a right shift by M items, the left-hand side should be all zeroes, and the shift amount will be Self::N - M.
This can also be used to rotate items within a vector by providing the same vector as both operands.
slide::<1>([a b c d], [e f g h]) == [b c d e]
Sourcefn slide_within_blocks_mask64x8<const SHIFT: usize>(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
) -> mask64x8<Self>
fn slide_within_blocks_mask64x8<const SHIFT: usize>( self, a: mask64x8<Self>, b: mask64x8<Self>, ) -> mask64x8<Self>
Like slide, but operates independently on each 128-bit block.
Sourcefn and_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>
fn and_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>
Compute the logical AND of two masks.
Sourcefn or_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>
fn or_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>
Compute the logical OR of two masks.
Sourcefn xor_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>
fn xor_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>
Compute the logical XOR of two masks.
Sourcefn not_mask64x8(self, a: mask64x8<Self>) -> mask64x8<Self>
fn not_mask64x8(self, a: mask64x8<Self>) -> mask64x8<Self>
Compute the logical NOT of the mask.
Sourcefn select_mask64x8(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
c: mask64x8<Self>,
) -> mask64x8<Self>
fn select_mask64x8( self, a: mask64x8<Self>, b: mask64x8<Self>, c: mask64x8<Self>, ) -> mask64x8<Self>
Select elements from b and c based on the mask operand a.
This operation’s behavior is unspecified if each lane of a is not the all-zeroes or all-ones bit pattern. See the Select trait’s documentation for more information.
Sourcefn simd_eq_mask64x8(
self,
a: mask64x8<Self>,
b: mask64x8<Self>,
) -> mask64x8<Self>
fn simd_eq_mask64x8( self, a: mask64x8<Self>, b: mask64x8<Self>, ) -> mask64x8<Self>
Compare two vectors element-wise for equality.
Returns a mask where each element is all ones if the corresponding elements are equal, and all zeroes if not.
Sourcefn any_true_mask64x8(self, a: mask64x8<Self>) -> bool
fn any_true_mask64x8(self, a: mask64x8<Self>) -> bool
Returns true if any elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_true_mask64x8(self, a: mask64x8<Self>) -> bool
fn all_true_mask64x8(self, a: mask64x8<Self>) -> bool
Returns true if all elements in this mask are true (all ones).
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn any_false_mask64x8(self, a: mask64x8<Self>) -> bool
fn any_false_mask64x8(self, a: mask64x8<Self>) -> bool
Returns true if any elements in this mask are false (all zeroes).
This is logically equivalent to !all_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn all_false_mask64x8(self, a: mask64x8<Self>) -> bool
fn all_false_mask64x8(self, a: mask64x8<Self>) -> bool
Returns true if all elements in this mask are false (all zeroes).
This is logically equivalent to !any_true, but may be faster.
Behavior on mask elements that are not all zeroes or all ones is unspecified. It may vary depending on architecture, feature level, the mask elements’ width, the mask vector’s width, or library version.
The behavior is also not guaranteed to be logically consistent if mask elements are not all zeroes or all ones. any_true may not return the same result as !all_false, and all_true may not return the same result as !any_false.
The select operation also has unspecified behavior for mask elements that are not all zeroes or all ones. That behavior may not match the behavior of this operation.
Sourcefn split_mask64x8(self, a: mask64x8<Self>) -> (mask64x4<Self>, mask64x4<Self>)
fn split_mask64x8(self, a: mask64x8<Self>) -> (mask64x4<Self>, mask64x4<Self>)
Split a vector into two vectors of half the width.
Returns a tuple of (lower half, upper half).
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.