Trait Simd

Source

pub trait Simd:
    Seal
    + Debug
    + Copy
    + Send
    + Sync
    + 'static {
    type m32s: Debug + Copy + Send + Sync + Zeroable + NoUninit + 'static;
    type f32s: Debug + Copy + Send + Sync + Pod + 'static;
    type c32s: Debug + Copy + Send + Sync + Pod + 'static;
    type i32s: Debug + Copy + Send + Sync + Pod + 'static;
    type u32s: Debug + Copy + Send + Sync + Pod + 'static;
    type m64s: Debug + Copy + Send + Sync + Zeroable + NoUninit + 'static;
    type f64s: Debug + Copy + Send + Sync + Pod + 'static;
    type c64s: Debug + Copy + Send + Sync + Pod + 'static;
    type i64s: Debug + Copy + Send + Sync + Pod + 'static;
    type u64s: Debug + Copy + Send + Sync + Pod + 'static;
Show 10 associated constants and 264 methods
    const REGISTER_COUNT: usize;
    const IS_SCALAR: bool = false;
    const U64_LANES: usize = _;
    const I64_LANES: usize = _;
    const F64_LANES: usize = _;
    const C64_LANES: usize = _;
    const U32_LANES: usize = _;
    const I32_LANES: usize = _;
    const F32_LANES: usize = _;
    const C32_LANES: usize = _;

    // Required methods
    fn abs2_c32s(self, a: Self::c32s) -> Self::c32s;
    fn abs2_c64s(self, a: Self::c64s) -> Self::c64s;
    fn abs_max_c32s(self, a: Self::c32s) -> Self::c32s;
    fn abs_max_c64s(self, a: Self::c64s) -> Self::c64s;
    fn add_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s;
    fn add_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s;
    fn add_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn add_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn add_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn add_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn and_m32s(self, a: Self::m32s, b: Self::m32s) -> Self::m32s;
    fn and_m64s(self, a: Self::m64s, b: Self::m64s) -> Self::m64s;
    fn and_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn and_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn conj_c32s(self, a: Self::c32s) -> Self::c32s;
    fn conj_c64s(self, a: Self::c64s) -> Self::c64s;
    fn conj_mul_add_c32s(
        self,
        a: Self::c32s,
        b: Self::c32s,
        c: Self::c32s,
    ) -> Self::c32s;
    fn conj_mul_add_c64s(
        self,
        a: Self::c64s,
        b: Self::c64s,
        c: Self::c64s,
    ) -> Self::c64s;
    fn conj_mul_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s;
    fn conj_mul_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s;
    fn div_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn div_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn equal_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::m32s;
    fn equal_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::m64s;
    fn greater_than_or_equal_i32s(
        self,
        a: Self::i32s,
        b: Self::i32s,
    ) -> Self::m32s;
    fn greater_than_or_equal_i64s(
        self,
        a: Self::i64s,
        b: Self::i64s,
    ) -> Self::m64s;
    fn greater_than_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::m32s;
    fn greater_than_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::m64s;
    fn greater_than_or_equal_u32s(
        self,
        a: Self::u32s,
        b: Self::u32s,
    ) -> Self::m32s;
    fn greater_than_or_equal_u64s(
        self,
        a: Self::u64s,
        b: Self::u64s,
    ) -> Self::m64s;
    fn greater_than_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::m32s;
    fn greater_than_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::m64s;
    fn less_than_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::m32s;
    fn less_than_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::m64s;
    fn less_than_or_equal_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::m32s;
    fn less_than_or_equal_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::m64s;
    fn less_than_or_equal_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::m32s;
    fn less_than_or_equal_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::m64s;
    fn less_than_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::m32s;
    fn less_than_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::m64s;
    fn less_than_or_equal_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::m32s;
    fn less_than_or_equal_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::m64s;
    fn less_than_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::m32s;
    fn less_than_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::m64s;
    unsafe fn mask_load_ptr_c32s(
        self,
        mask: MemMask<Self::m32s>,
        ptr: *const c32,
    ) -> Self::c32s;
    unsafe fn mask_load_ptr_c64s(
        self,
        mask: MemMask<Self::m64s>,
        ptr: *const c64,
    ) -> Self::c64s;
    unsafe fn mask_load_ptr_u32s(
        self,
        mask: MemMask<Self::m32s>,
        ptr: *const u32,
    ) -> Self::u32s;
    unsafe fn mask_load_ptr_u64s(
        self,
        mask: MemMask<Self::m64s>,
        ptr: *const u64,
    ) -> Self::u64s;
    unsafe fn mask_store_ptr_c32s(
        self,
        mask: MemMask<Self::m32s>,
        ptr: *mut c32,
        values: Self::c32s,
    );
    unsafe fn mask_store_ptr_c64s(
        self,
        mask: MemMask<Self::m64s>,
        ptr: *mut c64,
        values: Self::c64s,
    );
    unsafe fn mask_store_ptr_u32s(
        self,
        mask: MemMask<Self::m32s>,
        ptr: *mut u32,
        values: Self::u32s,
    );
    unsafe fn mask_store_ptr_u64s(
        self,
        mask: MemMask<Self::m64s>,
        ptr: *mut u64,
        values: Self::u64s,
    );
    fn max_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn max_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn min_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn min_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn mul_add_c32s(
        self,
        a: Self::c32s,
        b: Self::c32s,
        c: Self::c32s,
    ) -> Self::c32s;
    fn mul_add_c64s(
        self,
        a: Self::c64s,
        b: Self::c64s,
        c: Self::c64s,
    ) -> Self::c64s;
    fn mul_add_e_f32s(
        self,
        a: Self::f32s,
        b: Self::f32s,
        c: Self::f32s,
    ) -> Self::f32s;
    fn mul_add_e_f64s(
        self,
        a: Self::f64s,
        b: Self::f64s,
        c: Self::f64s,
    ) -> Self::f64s;
    fn mul_add_f32s(
        self,
        a: Self::f32s,
        b: Self::f32s,
        c: Self::f32s,
    ) -> Self::f32s;
    fn mul_add_f64s(
        self,
        a: Self::f64s,
        b: Self::f64s,
        c: Self::f64s,
    ) -> Self::f64s;
    fn mul_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s;
    fn mul_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s;
    fn mul_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn mul_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn neg_c32s(self, a: Self::c32s) -> Self::c32s;
    fn neg_c64s(self, a: Self::c64s) -> Self::c64s;
    fn not_m32s(self, a: Self::m32s) -> Self::m32s;
    fn not_m64s(self, a: Self::m64s) -> Self::m64s;
    fn not_u32s(self, a: Self::u32s) -> Self::u32s;
    fn not_u64s(self, a: Self::u64s) -> Self::u64s;
    fn or_m32s(self, a: Self::m32s, b: Self::m32s) -> Self::m32s;
    fn or_m64s(self, a: Self::m64s, b: Self::m64s) -> Self::m64s;
    fn or_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn or_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn reduce_max_c32s(self, a: Self::c32s) -> c32;
    fn reduce_max_c64s(self, a: Self::c64s) -> c64;
    fn reduce_max_f32s(self, a: Self::f32s) -> f32;
    fn reduce_max_f64s(self, a: Self::f64s) -> f64;
    fn reduce_min_c32s(self, a: Self::c32s) -> c32;
    fn reduce_min_c64s(self, a: Self::c64s) -> c64;
    fn reduce_min_f32s(self, a: Self::f32s) -> f32;
    fn reduce_min_f64s(self, a: Self::f64s) -> f64;
    fn reduce_product_f32s(self, a: Self::f32s) -> f32;
    fn reduce_product_f64s(self, a: Self::f64s) -> f64;
    fn reduce_sum_c32s(self, a: Self::c32s) -> c32;
    fn reduce_sum_c64s(self, a: Self::c64s) -> c64;
    fn reduce_sum_f32s(self, a: Self::f32s) -> f32;
    fn reduce_sum_f64s(self, a: Self::f64s) -> f64;
    fn rotate_right_c32s(self, a: Self::c32s, amount: usize) -> Self::c32s;
    fn rotate_right_c64s(self, a: Self::c64s, amount: usize) -> Self::c64s;
    fn rotate_right_u32s(self, a: Self::u32s, amount: usize) -> Self::u32s;
    fn rotate_right_u64s(self, a: Self::u64s, amount: usize) -> Self::u64s;
    fn select_u32s_m32s(
        self,
        mask: Self::m32s,
        if_true: Self::u32s,
        if_false: Self::u32s,
    ) -> Self::u32s;
    fn select_u64s_m64s(
        self,
        mask: Self::m64s,
        if_true: Self::u64s,
        if_false: Self::u64s,
    ) -> Self::u64s;
    fn splat_c32s(self, value: c32) -> Self::c32s;
    fn splat_c64s(self, value: c64) -> Self::c64s;
    fn splat_f32s(self, value: f32) -> Self::f32s;
    fn splat_f64s(self, value: f64) -> Self::f64s;
    fn splat_u32s(self, value: u32) -> Self::u32s;
    fn splat_u64s(self, value: u64) -> Self::u64s;
    fn sub_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s;
    fn sub_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s;
    fn sub_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn sub_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn sub_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn sub_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn swap_re_im_c32s(self, a: Self::c32s) -> Self::c32s;
    fn swap_re_im_c64s(self, a: Self::c64s) -> Self::c64s;
    fn vectorize<Op: WithSimd>(self, op: Op) -> Op::Output;
    fn widening_mul_u32s(
        self,
        a: Self::u32s,
        b: Self::u32s,
    ) -> (Self::u32s, Self::u32s);
    fn wrapping_dyn_shl_u32s(
        self,
        a: Self::u32s,
        amount: Self::u32s,
    ) -> Self::u32s;
    fn wrapping_dyn_shr_u32s(
        self,
        a: Self::u32s,
        amount: Self::u32s,
    ) -> Self::u32s;
    fn xor_m32s(self, a: Self::m32s, b: Self::m32s) -> Self::m32s;
    fn xor_m64s(self, a: Self::m64s, b: Self::m64s) -> Self::m64s;
    fn xor_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn xor_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;

    // Provided methods
    fn abs_f32s(self, a: Self::f32s) -> Self::f32s { ... }
    fn abs_f64s(self, a: Self::f64s) -> Self::f64s { ... }
    fn add_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn add_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn and_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s { ... }
    fn and_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s { ... }
    fn and_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn and_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn as_mut_rsimd_c32s(slice: &mut [c32]) -> (&mut [c32], &mut [Self::c32s]) { ... }
    fn as_mut_rsimd_c64s(slice: &mut [c64]) -> (&mut [c64], &mut [Self::c64s]) { ... }
    fn as_mut_rsimd_f32s(slice: &mut [f32]) -> (&mut [f32], &mut [Self::f32s]) { ... }
    fn as_mut_rsimd_f64s(slice: &mut [f64]) -> (&mut [f64], &mut [Self::f64s]) { ... }
    fn as_mut_rsimd_i32s(slice: &mut [i32]) -> (&mut [i32], &mut [Self::i32s]) { ... }
    fn as_mut_rsimd_i64s(slice: &mut [i64]) -> (&mut [i64], &mut [Self::i64s]) { ... }
    fn as_mut_rsimd_u32s(slice: &mut [u32]) -> (&mut [u32], &mut [Self::u32s]) { ... }
    fn as_mut_rsimd_u64s(slice: &mut [u64]) -> (&mut [u64], &mut [Self::u64s]) { ... }
    fn as_mut_simd_c32s(slice: &mut [c32]) -> (&mut [Self::c32s], &mut [c32]) { ... }
    fn as_mut_simd_c64s(slice: &mut [c64]) -> (&mut [Self::c64s], &mut [c64]) { ... }
    fn as_mut_simd_f32s(slice: &mut [f32]) -> (&mut [Self::f32s], &mut [f32]) { ... }
    fn as_mut_simd_f64s(slice: &mut [f64]) -> (&mut [Self::f64s], &mut [f64]) { ... }
    fn as_mut_simd_i32s(slice: &mut [i32]) -> (&mut [Self::i32s], &mut [i32]) { ... }
    fn as_mut_simd_i64s(slice: &mut [i64]) -> (&mut [Self::i64s], &mut [i64]) { ... }
    fn as_mut_simd_u32s(slice: &mut [u32]) -> (&mut [Self::u32s], &mut [u32]) { ... }
    fn as_mut_simd_u64s(slice: &mut [u64]) -> (&mut [Self::u64s], &mut [u64]) { ... }
    fn as_rsimd_c32s(slice: &[c32]) -> (&[c32], &[Self::c32s]) { ... }
    fn as_rsimd_c64s(slice: &[c64]) -> (&[c64], &[Self::c64s]) { ... }
    fn as_rsimd_f32s(slice: &[f32]) -> (&[f32], &[Self::f32s]) { ... }
    fn as_rsimd_f64s(slice: &[f64]) -> (&[f64], &[Self::f64s]) { ... }
    fn as_rsimd_i32s(slice: &[i32]) -> (&[i32], &[Self::i32s]) { ... }
    fn as_rsimd_i64s(slice: &[i64]) -> (&[i64], &[Self::i64s]) { ... }
    fn as_rsimd_u32s(slice: &[u32]) -> (&[u32], &[Self::u32s]) { ... }
    fn as_rsimd_u64s(slice: &[u64]) -> (&[u64], &[Self::u64s]) { ... }
    fn as_simd_c32s(slice: &[c32]) -> (&[Self::c32s], &[c32]) { ... }
    fn as_simd_c64s(slice: &[c64]) -> (&[Self::c64s], &[c64]) { ... }
    fn as_simd_f32s(slice: &[f32]) -> (&[Self::f32s], &[f32]) { ... }
    fn as_simd_f64s(slice: &[f64]) -> (&[Self::f64s], &[f64]) { ... }
    fn as_simd_i32s(slice: &[i32]) -> (&[Self::i32s], &[i32]) { ... }
    fn as_simd_i64s(slice: &[i64]) -> (&[Self::i64s], &[i64]) { ... }
    fn as_simd_u32s(slice: &[u32]) -> (&[Self::u32s], &[u32]) { ... }
    fn as_simd_u64s(slice: &[u64]) -> (&[Self::u64s], &[u64]) { ... }
    fn as_uninit_mut_rsimd_c32s(
        slice: &mut [MaybeUninit<c32>],
    ) -> (&mut [MaybeUninit<c32>], &mut [MaybeUninit<Self::c32s>]) { ... }
    fn as_uninit_mut_rsimd_c64s(
        slice: &mut [MaybeUninit<c64>],
    ) -> (&mut [MaybeUninit<c64>], &mut [MaybeUninit<Self::c64s>]) { ... }
    fn as_uninit_mut_rsimd_f32s(
        slice: &mut [MaybeUninit<f32>],
    ) -> (&mut [MaybeUninit<f32>], &mut [MaybeUninit<Self::f32s>]) { ... }
    fn as_uninit_mut_rsimd_f64s(
        slice: &mut [MaybeUninit<f64>],
    ) -> (&mut [MaybeUninit<f64>], &mut [MaybeUninit<Self::f64s>]) { ... }
    fn as_uninit_mut_rsimd_i32s(
        slice: &mut [MaybeUninit<i32>],
    ) -> (&mut [MaybeUninit<i32>], &mut [MaybeUninit<Self::i32s>]) { ... }
    fn as_uninit_mut_rsimd_i64s(
        slice: &mut [MaybeUninit<i64>],
    ) -> (&mut [MaybeUninit<i64>], &mut [MaybeUninit<Self::i64s>]) { ... }
    fn as_uninit_mut_rsimd_u32s(
        slice: &mut [MaybeUninit<u32>],
    ) -> (&mut [MaybeUninit<u32>], &mut [MaybeUninit<Self::u32s>]) { ... }
    fn as_uninit_mut_rsimd_u64s(
        slice: &mut [MaybeUninit<u64>],
    ) -> (&mut [MaybeUninit<u64>], &mut [MaybeUninit<Self::u64s>]) { ... }
    fn as_uninit_mut_simd_c32s(
        slice: &mut [MaybeUninit<c32>],
    ) -> (&mut [MaybeUninit<Self::c32s>], &mut [MaybeUninit<c32>]) { ... }
    fn as_uninit_mut_simd_c64s(
        slice: &mut [MaybeUninit<c64>],
    ) -> (&mut [MaybeUninit<Self::c64s>], &mut [MaybeUninit<c64>]) { ... }
    fn as_uninit_mut_simd_f32s(
        slice: &mut [MaybeUninit<f32>],
    ) -> (&mut [MaybeUninit<Self::f32s>], &mut [MaybeUninit<f32>]) { ... }
    fn as_uninit_mut_simd_f64s(
        slice: &mut [MaybeUninit<f64>],
    ) -> (&mut [MaybeUninit<Self::f64s>], &mut [MaybeUninit<f64>]) { ... }
    fn as_uninit_mut_simd_i32s(
        slice: &mut [MaybeUninit<i32>],
    ) -> (&mut [MaybeUninit<Self::i32s>], &mut [MaybeUninit<i32>]) { ... }
    fn as_uninit_mut_simd_i64s(
        slice: &mut [MaybeUninit<i64>],
    ) -> (&mut [MaybeUninit<Self::i64s>], &mut [MaybeUninit<i64>]) { ... }
    fn as_uninit_mut_simd_u32s(
        slice: &mut [MaybeUninit<u32>],
    ) -> (&mut [MaybeUninit<Self::u32s>], &mut [MaybeUninit<u32>]) { ... }
    fn as_uninit_mut_simd_u64s(
        slice: &mut [MaybeUninit<u64>],
    ) -> (&mut [MaybeUninit<Self::u64s>], &mut [MaybeUninit<u64>]) { ... }
    fn conj_mul_add_e_c32s(
        self,
        a: Self::c32s,
        b: Self::c32s,
        c: Self::c32s,
    ) -> Self::c32s { ... }
    fn conj_mul_add_e_c64s(
        self,
        a: Self::c64s,
        b: Self::c64s,
        c: Self::c64s,
    ) -> Self::c64s { ... }
    fn conj_mul_e_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s { ... }
    fn conj_mul_e_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s { ... }
    fn deinterleave_shfl_f32s<T: Interleave>(self, values: T) -> T { ... }
    fn deinterleave_shfl_f64s<T: Interleave>(self, values: T) -> T { ... }
    fn first_true_m32s(self, mask: Self::m32s) -> usize { ... }
    fn first_true_m64s(self, mask: Self::m64s) -> usize { ... }
    fn greater_than_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::m32s { ... }
    fn greater_than_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::m64s { ... }
    fn greater_than_or_equal_f32s(
        self,
        a: Self::f32s,
        b: Self::f32s,
    ) -> Self::m32s { ... }
    fn greater_than_or_equal_f64s(
        self,
        a: Self::f64s,
        b: Self::f64s,
    ) -> Self::m64s { ... }
    fn interleave_shfl_f32s<T: Interleave>(self, values: T) -> T { ... }
    fn interleave_shfl_f64s<T: Interleave>(self, values: T) -> T { ... }
    fn mask_between_m32s(self, start: u32, end: u32) -> MemMask<Self::m32s> { ... }
    fn mask_between_m64s(self, start: u64, end: u64) -> MemMask<Self::m64s> { ... }
    unsafe fn mask_load_ptr_f32s(
        self,
        mask: MemMask<Self::m32s>,
        ptr: *const f32,
    ) -> Self::f32s { ... }
    unsafe fn mask_load_ptr_f64s(
        self,
        mask: MemMask<Self::m64s>,
        ptr: *const f64,
    ) -> Self::f64s { ... }
    unsafe fn mask_load_ptr_i32s(
        self,
        mask: MemMask<Self::m32s>,
        ptr: *const i32,
    ) -> Self::i32s { ... }
    unsafe fn mask_load_ptr_i64s(
        self,
        mask: MemMask<Self::m64s>,
        ptr: *const i64,
    ) -> Self::i64s { ... }
    unsafe fn mask_store_ptr_f32s(
        self,
        mask: MemMask<Self::m32s>,
        ptr: *mut f32,
        values: Self::f32s,
    ) { ... }
    unsafe fn mask_store_ptr_f64s(
        self,
        mask: MemMask<Self::m64s>,
        ptr: *mut f64,
        values: Self::f64s,
    ) { ... }
    unsafe fn mask_store_ptr_i32s(
        self,
        mask: MemMask<Self::m32s>,
        ptr: *mut i32,
        values: Self::i32s,
    ) { ... }
    unsafe fn mask_store_ptr_i64s(
        self,
        mask: MemMask<Self::m64s>,
        ptr: *mut i64,
        values: Self::i64s,
    ) { ... }
    fn mul_add_e_c32s(
        self,
        a: Self::c32s,
        b: Self::c32s,
        c: Self::c32s,
    ) -> Self::c32s { ... }
    fn mul_add_e_c64s(
        self,
        a: Self::c64s,
        b: Self::c64s,
        c: Self::c64s,
    ) -> Self::c64s { ... }
    fn mul_e_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s { ... }
    fn mul_e_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s { ... }
    fn neg_f32s(self, a: Self::f32s) -> Self::f32s { ... }
    fn neg_f64s(self, a: Self::f64s) -> Self::f64s { ... }
    fn not_f32s(self, a: Self::f32s) -> Self::f32s { ... }
    fn not_f64s(self, a: Self::f64s) -> Self::f64s { ... }
    fn not_i32s(self, a: Self::i32s) -> Self::i32s { ... }
    fn not_i64s(self, a: Self::i64s) -> Self::i64s { ... }
    fn or_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s { ... }
    fn or_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s { ... }
    fn or_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn or_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn partial_load_c32s(self, slice: &[c32]) -> Self::c32s { ... }
    fn partial_load_c64s(self, slice: &[c64]) -> Self::c64s { ... }
    fn partial_load_f32s(self, slice: &[f32]) -> Self::f32s { ... }
    fn partial_load_f64s(self, slice: &[f64]) -> Self::f64s { ... }
    fn partial_load_i32s(self, slice: &[i32]) -> Self::i32s { ... }
    fn partial_load_i64s(self, slice: &[i64]) -> Self::i64s { ... }
    fn partial_load_u32s(self, slice: &[u32]) -> Self::u32s { ... }
    fn partial_load_u64s(self, slice: &[u64]) -> Self::u64s { ... }
    fn partial_store_c32s(self, slice: &mut [c32], values: Self::c32s) { ... }
    fn partial_store_c64s(self, slice: &mut [c64], values: Self::c64s) { ... }
    fn partial_store_f32s(self, slice: &mut [f32], values: Self::f32s) { ... }
    fn partial_store_f64s(self, slice: &mut [f64], values: Self::f64s) { ... }
    fn partial_store_i32s(self, slice: &mut [i32], values: Self::i32s) { ... }
    fn partial_store_i64s(self, slice: &mut [i64], values: Self::i64s) { ... }
    fn partial_store_u32s(self, slice: &mut [u32], values: Self::u32s) { ... }
    fn partial_store_u64s(self, slice: &mut [u64], values: Self::u64s) { ... }
    fn rotate_left_c32s(self, a: Self::c32s, amount: usize) -> Self::c32s { ... }
    fn rotate_left_c64s(self, a: Self::c64s, amount: usize) -> Self::c64s { ... }
    fn rotate_left_f32s(self, a: Self::f32s, amount: usize) -> Self::f32s { ... }
    fn rotate_left_f64s(self, a: Self::f64s, amount: usize) -> Self::f64s { ... }
    fn rotate_left_i32s(self, a: Self::i32s, amount: usize) -> Self::i32s { ... }
    fn rotate_left_i64s(self, a: Self::i64s, amount: usize) -> Self::i64s { ... }
    fn rotate_left_u32s(self, a: Self::u32s, amount: usize) -> Self::u32s { ... }
    fn rotate_left_u64s(self, a: Self::u64s, amount: usize) -> Self::u64s { ... }
    fn rotate_right_f32s(self, a: Self::f32s, amount: usize) -> Self::f32s { ... }
    fn rotate_right_f64s(self, a: Self::f64s, amount: usize) -> Self::f64s { ... }
    fn rotate_right_i32s(self, a: Self::i32s, amount: usize) -> Self::i32s { ... }
    fn rotate_right_i64s(self, a: Self::i64s, amount: usize) -> Self::i64s { ... }
    fn select_f32s_m32s(
        self,
        mask: Self::m32s,
        if_true: Self::f32s,
        if_false: Self::f32s,
    ) -> Self::f32s { ... }
    fn select_f64s_m64s(
        self,
        mask: Self::m64s,
        if_true: Self::f64s,
        if_false: Self::f64s,
    ) -> Self::f64s { ... }
    fn select_i32s_m32s(
        self,
        mask: Self::m32s,
        if_true: Self::i32s,
        if_false: Self::i32s,
    ) -> Self::i32s { ... }
    fn select_i64s_m64s(
        self,
        mask: Self::m64s,
        if_true: Self::i64s,
        if_false: Self::i64s,
    ) -> Self::i64s { ... }
    fn splat_i32s(self, value: i32) -> Self::i32s { ... }
    fn splat_i64s(self, value: i64) -> Self::i64s { ... }
    fn sub_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn sub_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn transmute_f32s_i32s(self, a: Self::i32s) -> Self::f32s { ... }
    fn transmute_f32s_u32s(self, a: Self::u32s) -> Self::f32s { ... }
    fn transmute_f64s_i64s(self, a: Self::i64s) -> Self::f64s { ... }
    fn transmute_f64s_u64s(self, a: Self::u64s) -> Self::f64s { ... }
    fn transmute_i32s_f32s(self, a: Self::f32s) -> Self::i32s { ... }
    fn transmute_i32s_u32s(self, a: Self::u32s) -> Self::i32s { ... }
    fn transmute_i64s_f64s(self, a: Self::f64s) -> Self::i64s { ... }
    fn transmute_i64s_u64s(self, a: Self::u64s) -> Self::i64s { ... }
    fn transmute_u32s_f32s(self, a: Self::f32s) -> Self::u32s { ... }
    fn transmute_u32s_i32s(self, a: Self::i32s) -> Self::u32s { ... }
    fn transmute_u64s_f64s(self, a: Self::f64s) -> Self::u64s { ... }
    fn transmute_u64s_i64s(self, a: Self::i64s) -> Self::u64s { ... }
    fn xor_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s { ... }
    fn xor_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s { ... }
    fn xor_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn xor_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
}