Trait pulp::Simd

source ·

pub trait Simd: Seal + Debug + Copy + Send + Sync + 'static {
    type m32s: Debug + Copy + Send + Sync + Zeroable + '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 + '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 286 methods    // Required methods
    fn vectorize<Op: WithSimd>(self, op: Op) -> Op::Output;
    unsafe fn u32s_mask_load_ptr(
        self,
        mask: Self::m32s,
        ptr: *const u32,
        or: Self::u32s
    ) -> Self::u32s;
    unsafe fn c32s_mask_load_ptr(
        self,
        mask: Self::m32s,
        ptr: *const c32,
        or: Self::c32s
    ) -> Self::c32s;
    unsafe fn u32s_mask_store_ptr(
        self,
        mask: Self::m32s,
        ptr: *mut u32,
        values: Self::u32s
    );
    unsafe fn c32s_mask_store_ptr(
        self,
        mask: Self::m32s,
        ptr: *mut c32,
        values: Self::c32s
    );
    unsafe fn u64s_mask_load_ptr(
        self,
        mask: Self::m64s,
        ptr: *const u64,
        or: Self::u64s
    ) -> Self::u64s;
    unsafe fn c64s_mask_load_ptr(
        self,
        mask: Self::m64s,
        ptr: *const c64,
        or: Self::c64s
    ) -> Self::c64s;
    unsafe fn u64s_mask_store_ptr(
        self,
        mask: Self::m64s,
        ptr: *mut u64,
        values: Self::u64s
    );
    unsafe fn c64s_mask_store_ptr(
        self,
        mask: Self::m64s,
        ptr: *mut c64,
        values: Self::c64s
    );
    fn u32s_partial_load(self, slice: &[u32]) -> Self::u32s;
    fn u32s_partial_store(self, slice: &mut [u32], values: Self::u32s);
    fn u64s_partial_load(self, slice: &[u64]) -> Self::u64s;
    fn u64s_partial_store(self, slice: &mut [u64], values: Self::u64s);
    fn u32s_partial_load_last(self, slice: &[u32]) -> Self::u32s;
    fn u32s_partial_store_last(self, slice: &mut [u32], values: Self::u32s);
    fn u64s_partial_load_last(self, slice: &[u64]) -> Self::u64s;
    fn u64s_partial_store_last(self, slice: &mut [u64], values: Self::u64s);
    fn m32s_not(self, a: Self::m32s) -> Self::m32s;
    fn m32s_and(self, a: Self::m32s, b: Self::m32s) -> Self::m32s;
    fn m32s_or(self, a: Self::m32s, b: Self::m32s) -> Self::m32s;
    fn m32s_xor(self, a: Self::m32s, b: Self::m32s) -> Self::m32s;
    fn m64s_not(self, a: Self::m64s) -> Self::m64s;
    fn m64s_and(self, a: Self::m64s, b: Self::m64s) -> Self::m64s;
    fn m64s_or(self, a: Self::m64s, b: Self::m64s) -> Self::m64s;
    fn m64s_xor(self, a: Self::m64s, b: Self::m64s) -> Self::m64s;
    fn u32s_not(self, a: Self::u32s) -> Self::u32s;
    fn u32s_and(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn u32s_or(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn u32s_xor(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn u64s_not(self, a: Self::u64s) -> Self::u64s;
    fn u64s_and(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn u64s_or(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn u64s_xor(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn m32s_select_u32s(
        self,
        mask: Self::m32s,
        if_true: Self::u32s,
        if_false: Self::u32s
    ) -> Self::u32s;
    fn m64s_select_u64s(
        self,
        mask: Self::m64s,
        if_true: Self::u64s,
        if_false: Self::u64s
    ) -> Self::u64s;
    fn u32s_splat(self, value: u32) -> Self::u32s;
    fn u32s_add(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn u32s_sub(self, a: Self::u32s, b: Self::u32s) -> Self::u32s;
    fn u32s_less_than(self, a: Self::u32s, b: Self::u32s) -> Self::m32s;
    fn u32s_greater_than(self, a: Self::u32s, b: Self::u32s) -> Self::m32s;
    fn u32s_less_than_or_equal(self, a: Self::u32s, b: Self::u32s) -> Self::m32s;
    fn u32s_greater_than_or_equal(
        self,
        a: Self::u32s,
        b: Self::u32s
    ) -> Self::m32s;
    fn u32s_wrapping_dyn_shl(
        self,
        a: Self::u32s,
        amount: Self::u32s
    ) -> Self::u32s;
    fn u32s_wrapping_dyn_shr(
        self,
        a: Self::u32s,
        amount: Self::u32s
    ) -> Self::u32s;
    fn u32s_widening_mul(
        self,
        a: Self::u32s,
        b: Self::u32s
    ) -> (Self::u32s, Self::u32s);
    fn u64s_splat(self, value: u64) -> Self::u64s;
    fn u64s_add(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn u64s_sub(self, a: Self::u64s, b: Self::u64s) -> Self::u64s;
    fn u64s_less_than(self, a: Self::u64s, b: Self::u64s) -> Self::m64s;
    fn u64s_greater_than(self, a: Self::u64s, b: Self::u64s) -> Self::m64s;
    fn u64s_less_than_or_equal(self, a: Self::u64s, b: Self::u64s) -> Self::m64s;
    fn u64s_greater_than_or_equal(
        self,
        a: Self::u64s,
        b: Self::u64s
    ) -> Self::m64s;
    fn f32s_splat(self, value: f32) -> Self::f32s;
    fn f32s_add(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn f32s_sub(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn f32s_mul(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn f32s_div(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn f32s_mul_add(
        self,
        a: Self::f32s,
        b: Self::f32s,
        c: Self::f32s
    ) -> Self::f32s;
    fn f32s_equal(self, a: Self::f32s, b: Self::f32s) -> Self::m32s;
    fn f32s_less_than(self, a: Self::f32s, b: Self::f32s) -> Self::m32s;
    fn f32s_less_than_or_equal(self, a: Self::f32s, b: Self::f32s) -> Self::m32s;
    fn f32s_min(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn f32s_max(self, a: Self::f32s, b: Self::f32s) -> Self::f32s;
    fn f32s_reduce_sum(self, a: Self::f32s) -> f32;
    fn f32s_reduce_product(self, a: Self::f32s) -> f32;
    fn f32s_reduce_min(self, a: Self::f32s) -> f32;
    fn f32s_reduce_max(self, a: Self::f32s) -> f32;
    fn c32s_splat(self, value: c32) -> Self::c32s;
    fn c32s_conj(self, a: Self::c32s) -> Self::c32s;
    fn c32s_neg(self, a: Self::c32s) -> Self::c32s;
    fn c32s_swap_re_im(self, a: Self::c32s) -> Self::c32s;
    fn c32s_add(self, a: Self::c32s, b: Self::c32s) -> Self::c32s;
    fn c32s_sub(self, a: Self::c32s, b: Self::c32s) -> Self::c32s;
    fn c32s_mul(self, a: Self::c32s, b: Self::c32s) -> Self::c32s;
    fn c32s_conj_mul(self, a: Self::c32s, b: Self::c32s) -> Self::c32s;
    fn c32s_mul_add(
        self,
        a: Self::c32s,
        b: Self::c32s,
        c: Self::c32s
    ) -> Self::c32s;
    fn c32s_conj_mul_add(
        self,
        a: Self::c32s,
        b: Self::c32s,
        c: Self::c32s
    ) -> Self::c32s;
    fn c32s_abs2(self, a: Self::c32s) -> Self::c32s;
    fn c32s_reduce_sum(self, a: Self::c32s) -> c32;
    fn f64s_splat(self, value: f64) -> Self::f64s;
    fn f64s_add(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn f64s_sub(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn f64s_mul(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn f64s_div(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn f64s_mul_add(
        self,
        a: Self::f64s,
        b: Self::f64s,
        c: Self::f64s
    ) -> Self::f64s;
    fn f64s_equal(self, a: Self::f64s, b: Self::f64s) -> Self::m64s;
    fn f64s_less_than(self, a: Self::f64s, b: Self::f64s) -> Self::m64s;
    fn f64s_less_than_or_equal(self, a: Self::f64s, b: Self::f64s) -> Self::m64s;
    fn f64s_min(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn f64s_max(self, a: Self::f64s, b: Self::f64s) -> Self::f64s;
    fn f64s_reduce_sum(self, a: Self::f64s) -> f64;
    fn f64s_reduce_product(self, a: Self::f64s) -> f64;
    fn f64s_reduce_min(self, a: Self::f64s) -> f64;
    fn f64s_reduce_max(self, a: Self::f64s) -> f64;
    fn c64s_splat(self, value: c64) -> Self::c64s;
    fn c64s_conj(self, a: Self::c64s) -> Self::c64s;
    fn c64s_neg(self, a: Self::c64s) -> Self::c64s;
    fn c64s_swap_re_im(self, a: Self::c64s) -> Self::c64s;
    fn c64s_add(self, a: Self::c64s, b: Self::c64s) -> Self::c64s;
    fn c64s_sub(self, a: Self::c64s, b: Self::c64s) -> Self::c64s;
    fn c64s_mul(self, a: Self::c64s, b: Self::c64s) -> Self::c64s;
    fn c64s_conj_mul(self, a: Self::c64s, b: Self::c64s) -> Self::c64s;
    fn c64s_mul_add(
        self,
        a: Self::c64s,
        b: Self::c64s,
        c: Self::c64s
    ) -> Self::c64s;
    fn c64s_conj_mul_add(
        self,
        a: Self::c64s,
        b: Self::c64s,
        c: Self::c64s
    ) -> Self::c64s;
    fn c64s_abs2(self, a: Self::c64s) -> Self::c64s;
    fn c64s_reduce_sum(self, a: Self::c64s) -> c64;
    fn u32s_rotate_right(self, a: Self::u32s, amount: usize) -> Self::u32s;
    fn c32s_rotate_right(self, a: Self::c32s, amount: usize) -> Self::c32s;
    fn u64s_rotate_right(self, a: Self::u64s, amount: usize) -> Self::u64s;
    fn c64s_rotate_right(self, a: Self::c64s, amount: usize) -> Self::c64s;

    // Provided methods
    fn f32s_as_simd(slice: &[f32]) -> (&[Self::f32s], &[f32]) { ... }
    fn f32s_as_mut_simd(slice: &mut [f32]) -> (&mut [Self::f32s], &mut [f32]) { ... }
    fn f32s_as_uninit_mut_simd(
        slice: &mut [MaybeUninit<f32>]
    ) -> (&mut [MaybeUninit<Self::f32s>], &mut [MaybeUninit<f32>]) { ... }
    fn c32s_as_simd(slice: &[c32]) -> (&[Self::c32s], &[c32]) { ... }
    fn c32s_as_mut_simd(slice: &mut [c32]) -> (&mut [Self::c32s], &mut [c32]) { ... }
    fn c32s_as_uninit_mut_simd(
        slice: &mut [MaybeUninit<c32>]
    ) -> (&mut [MaybeUninit<Self::c32s>], &mut [MaybeUninit<c32>]) { ... }
    fn i32s_as_simd(slice: &[i32]) -> (&[Self::i32s], &[i32]) { ... }
    fn i32s_as_mut_simd(slice: &mut [i32]) -> (&mut [Self::i32s], &mut [i32]) { ... }
    fn i32s_as_uninit_mut_simd(
        slice: &mut [MaybeUninit<i32>]
    ) -> (&mut [MaybeUninit<Self::i32s>], &mut [MaybeUninit<i32>]) { ... }
    fn u32s_as_simd(slice: &[u32]) -> (&[Self::u32s], &[u32]) { ... }
    fn u32s_as_mut_simd(slice: &mut [u32]) -> (&mut [Self::u32s], &mut [u32]) { ... }
    fn u32s_as_uninit_mut_simd(
        slice: &mut [MaybeUninit<u32>]
    ) -> (&mut [MaybeUninit<Self::u32s>], &mut [MaybeUninit<u32>]) { ... }
    fn f64s_as_simd(slice: &[f64]) -> (&[Self::f64s], &[f64]) { ... }
    fn f64s_as_mut_simd(slice: &mut [f64]) -> (&mut [Self::f64s], &mut [f64]) { ... }
    fn f64s_as_uninit_mut_simd(
        slice: &mut [MaybeUninit<f64>]
    ) -> (&mut [MaybeUninit<Self::f64s>], &mut [MaybeUninit<f64>]) { ... }
    fn c64s_as_simd(slice: &[c64]) -> (&[Self::c64s], &[c64]) { ... }
    fn c64s_as_mut_simd(slice: &mut [c64]) -> (&mut [Self::c64s], &mut [c64]) { ... }
    fn c64s_as_uninit_mut_simd(
        slice: &mut [MaybeUninit<c64>]
    ) -> (&mut [MaybeUninit<Self::c64s>], &mut [MaybeUninit<c64>]) { ... }
    fn i64s_as_simd(slice: &[i64]) -> (&[Self::i64s], &[i64]) { ... }
    fn i64s_as_mut_simd(slice: &mut [i64]) -> (&mut [Self::i64s], &mut [i64]) { ... }
    fn i64s_as_uninit_mut_simd(
        slice: &mut [MaybeUninit<i64>]
    ) -> (&mut [MaybeUninit<Self::i64s>], &mut [MaybeUninit<i64>]) { ... }
    fn u64s_as_simd(slice: &[u64]) -> (&[Self::u64s], &[u64]) { ... }
    fn u64s_as_mut_simd(slice: &mut [u64]) -> (&mut [Self::u64s], &mut [u64]) { ... }
    fn u64s_as_uninit_mut_simd(
        slice: &mut [MaybeUninit<u64>]
    ) -> (&mut [MaybeUninit<Self::u64s>], &mut [MaybeUninit<u64>]) { ... }
    fn i32s_align_offset(
        self,
        ptr: *const i32,
        len: usize
    ) -> Offset<Self::m32s> { ... }
    fn f32s_align_offset(
        self,
        ptr: *const f32,
        len: usize
    ) -> Offset<Self::m32s> { ... }
    fn u32s_align_offset(
        self,
        ptr: *const u32,
        len: usize
    ) -> Offset<Self::m32s> { ... }
    fn c32s_align_offset(
        self,
        ptr: *const c32,
        len: usize
    ) -> Offset<Self::m32s> { ... }
    fn i64s_align_offset(
        self,
        ptr: *const i64,
        len: usize
    ) -> Offset<Self::m64s> { ... }
    fn f64s_align_offset(
        self,
        ptr: *const f64,
        len: usize
    ) -> Offset<Self::m64s> { ... }
    fn u64s_align_offset(
        self,
        ptr: *const u64,
        len: usize
    ) -> Offset<Self::m64s> { ... }
    fn c64s_align_offset(
        self,
        ptr: *const c64,
        len: usize
    ) -> Offset<Self::m64s> { ... }
    fn i32s_as_aligned_simd(
        self,
        slice: &[i32],
        offset: Offset<Self::m32s>
    ) -> (Prefix<'_, i32, Self, Self::m32s>, &[Self::i32s], Suffix<'_, i32, Self, Self::m32s>) { ... }
    fn f32s_as_aligned_simd(
        self,
        slice: &[f32],
        offset: Offset<Self::m32s>
    ) -> (Prefix<'_, f32, Self, Self::m32s>, &[Self::f32s], Suffix<'_, f32, Self, Self::m32s>) { ... }
    fn u32s_as_aligned_simd(
        self,
        slice: &[u32],
        offset: Offset<Self::m32s>
    ) -> (Prefix<'_, u32, Self, Self::m32s>, &[Self::u32s], Suffix<'_, u32, Self, Self::m32s>) { ... }
    fn c32s_as_aligned_simd(
        self,
        slice: &[c32],
        offset: Offset<Self::m32s>
    ) -> (Prefix<'_, c32, Self, Self::m32s>, &[Self::c32s], Suffix<'_, c32, Self, Self::m32s>) { ... }
    fn i64s_as_aligned_simd(
        self,
        slice: &[i64],
        offset: Offset<Self::m64s>
    ) -> (Prefix<'_, i64, Self, Self::m64s>, &[Self::i64s], Suffix<'_, i64, Self, Self::m64s>) { ... }
    fn f64s_as_aligned_simd(
        self,
        slice: &[f64],
        offset: Offset<Self::m64s>
    ) -> (Prefix<'_, f64, Self, Self::m64s>, &[Self::f64s], Suffix<'_, f64, Self, Self::m64s>) { ... }
    fn u64s_as_aligned_simd(
        self,
        slice: &[u64],
        offset: Offset<Self::m64s>
    ) -> (Prefix<'_, u64, Self, Self::m64s>, &[Self::u64s], Suffix<'_, u64, Self, Self::m64s>) { ... }
    fn c64s_as_aligned_simd(
        self,
        slice: &[c64],
        offset: Offset<Self::m64s>
    ) -> (Prefix<'_, c64, Self, Self::m64s>, &[Self::c64s], Suffix<'_, c64, Self, Self::m64s>) { ... }
    fn i32s_as_aligned_mut_simd(
        self,
        slice: &mut [i32],
        offset: Offset<Self::m32s>
    ) -> (PrefixMut<'_, i32, Self, Self::m32s>, &mut [Self::i32s], SuffixMut<'_, i32, Self, Self::m32s>) { ... }
    fn f32s_as_aligned_mut_simd(
        self,
        slice: &mut [f32],
        offset: Offset<Self::m32s>
    ) -> (PrefixMut<'_, f32, Self, Self::m32s>, &mut [Self::f32s], SuffixMut<'_, f32, Self, Self::m32s>) { ... }
    fn u32s_as_aligned_mut_simd(
        self,
        slice: &mut [u32],
        offset: Offset<Self::m32s>
    ) -> (PrefixMut<'_, u32, Self, Self::m32s>, &mut [Self::u32s], SuffixMut<'_, u32, Self, Self::m32s>) { ... }
    fn c32s_as_aligned_mut_simd(
        self,
        slice: &mut [c32],
        offset: Offset<Self::m32s>
    ) -> (PrefixMut<'_, c32, Self, Self::m32s>, &mut [Self::c32s], SuffixMut<'_, c32, Self, Self::m32s>) { ... }
    fn i64s_as_aligned_mut_simd(
        self,
        slice: &mut [i64],
        offset: Offset<Self::m64s>
    ) -> (PrefixMut<'_, i64, Self, Self::m64s>, &mut [Self::i64s], SuffixMut<'_, i64, Self, Self::m64s>) { ... }
    fn f64s_as_aligned_mut_simd(
        self,
        slice: &mut [f64],
        offset: Offset<Self::m64s>
    ) -> (PrefixMut<'_, f64, Self, Self::m64s>, &mut [Self::f64s], SuffixMut<'_, f64, Self, Self::m64s>) { ... }
    fn u64s_as_aligned_mut_simd(
        self,
        slice: &mut [u64],
        offset: Offset<Self::m64s>
    ) -> (PrefixMut<'_, u64, Self, Self::m64s>, &mut [Self::u64s], SuffixMut<'_, u64, Self, Self::m64s>) { ... }
    fn c64s_as_aligned_mut_simd(
        self,
        slice: &mut [c64],
        offset: Offset<Self::m64s>
    ) -> (PrefixMut<'_, c64, Self, Self::m64s>, &mut [Self::c64s], SuffixMut<'_, c64, Self, Self::m64s>) { ... }
    fn i32s_as_aligned_uninit_mut_simd(
        self,
        slice: &mut [MaybeUninit<i32>],
        offset: Offset<Self::m32s>
    ) -> (PrefixMut<'_, MaybeUninit<i32>, Self, Self::m32s>, &mut [MaybeUninit<Self::i32s>], SuffixMut<'_, MaybeUninit<i32>, Self, Self::m32s>) { ... }
    fn f32s_as_aligned_uninit_mut_simd(
        self,
        slice: &mut [MaybeUninit<f32>],
        offset: Offset<Self::m32s>
    ) -> (PrefixMut<'_, MaybeUninit<f32>, Self, Self::m32s>, &mut [MaybeUninit<Self::f32s>], SuffixMut<'_, MaybeUninit<f32>, Self, Self::m32s>) { ... }
    fn u32s_as_aligned_uninit_mut_simd(
        self,
        slice: &mut [MaybeUninit<u32>],
        offset: Offset<Self::m32s>
    ) -> (PrefixMut<'_, MaybeUninit<u32>, Self, Self::m32s>, &mut [MaybeUninit<Self::u32s>], SuffixMut<'_, MaybeUninit<u32>, Self, Self::m32s>) { ... }
    fn c32s_as_aligned_uninit_mut_simd(
        self,
        slice: &mut [MaybeUninit<c32>],
        offset: Offset<Self::m32s>
    ) -> (PrefixMut<'_, MaybeUninit<c32>, Self, Self::m32s>, &mut [MaybeUninit<Self::c32s>], SuffixMut<'_, MaybeUninit<c32>, Self, Self::m32s>) { ... }
    fn i64s_as_aligned_uninit_mut_simd(
        self,
        slice: &mut [MaybeUninit<i64>],
        offset: Offset<Self::m64s>
    ) -> (PrefixMut<'_, MaybeUninit<i64>, Self, Self::m64s>, &mut [MaybeUninit<Self::i64s>], SuffixMut<'_, MaybeUninit<i64>, Self, Self::m64s>) { ... }
    fn f64s_as_aligned_uninit_mut_simd(
        self,
        slice: &mut [MaybeUninit<f64>],
        offset: Offset<Self::m64s>
    ) -> (PrefixMut<'_, MaybeUninit<f64>, Self, Self::m64s>, &mut [MaybeUninit<Self::f64s>], SuffixMut<'_, MaybeUninit<f64>, Self, Self::m64s>) { ... }
    fn u64s_as_aligned_uninit_mut_simd(
        self,
        slice: &mut [MaybeUninit<u64>],
        offset: Offset<Self::m64s>
    ) -> (PrefixMut<'_, MaybeUninit<u64>, Self, Self::m64s>, &mut [MaybeUninit<Self::u64s>], SuffixMut<'_, MaybeUninit<u64>, Self, Self::m64s>) { ... }
    fn c64s_as_aligned_uninit_mut_simd(
        self,
        slice: &mut [MaybeUninit<c64>],
        offset: Offset<Self::m64s>
    ) -> (PrefixMut<'_, MaybeUninit<c64>, Self, Self::m64s>, &mut [MaybeUninit<Self::c64s>], SuffixMut<'_, MaybeUninit<c64>, Self, Self::m64s>) { ... }
    unsafe fn i32s_mask_load_ptr(
        self,
        mask: Self::m32s,
        ptr: *const i32,
        or: Self::i32s
    ) -> Self::i32s { ... }
    unsafe fn f32s_mask_load_ptr(
        self,
        mask: Self::m32s,
        ptr: *const f32,
        or: Self::f32s
    ) -> Self::f32s { ... }
    unsafe fn i32s_mask_store_ptr(
        self,
        mask: Self::m32s,
        ptr: *mut i32,
        values: Self::i32s
    ) { ... }
    unsafe fn f32s_mask_store_ptr(
        self,
        mask: Self::m32s,
        ptr: *mut f32,
        values: Self::f32s
    ) { ... }
    unsafe fn i64s_mask_load_ptr(
        self,
        mask: Self::m64s,
        ptr: *const i64,
        or: Self::i64s
    ) -> Self::i64s { ... }
    unsafe fn f64s_mask_load_ptr(
        self,
        mask: Self::m64s,
        ptr: *const f64,
        or: Self::f64s
    ) -> Self::f64s { ... }
    unsafe fn i64s_mask_store_ptr(
        self,
        mask: Self::m64s,
        ptr: *mut i64,
        values: Self::i64s
    ) { ... }
    unsafe fn f64s_mask_store_ptr(
        self,
        mask: Self::m64s,
        ptr: *mut f64,
        values: Self::f64s
    ) { ... }
    fn i32s_partial_load(self, slice: &[i32]) -> Self::i32s { ... }
    fn i32s_partial_store(self, slice: &mut [i32], values: Self::i32s) { ... }
    fn i64s_partial_load(self, slice: &[i64]) -> Self::i64s { ... }
    fn i64s_partial_store(self, slice: &mut [i64], values: Self::i64s) { ... }
    fn f32s_partial_load(self, slice: &[f32]) -> Self::f32s { ... }
    fn f32s_partial_store(self, slice: &mut [f32], values: Self::f32s) { ... }
    fn f64s_partial_load(self, slice: &[f64]) -> Self::f64s { ... }
    fn f64s_partial_store(self, slice: &mut [f64], values: Self::f64s) { ... }
    fn c32s_partial_load(self, slice: &[c32]) -> Self::c32s { ... }
    fn c32s_partial_store(self, slice: &mut [c32], values: Self::c32s) { ... }
    fn c64s_partial_load(self, slice: &[c64]) -> Self::c64s { ... }
    fn c64s_partial_store(self, slice: &mut [c64], values: Self::c64s) { ... }
    fn i32s_partial_load_last(self, slice: &[i32]) -> Self::i32s { ... }
    fn i32s_partial_store_last(self, slice: &mut [i32], values: Self::i32s) { ... }
    fn i64s_partial_load_last(self, slice: &[i64]) -> Self::i64s { ... }
    fn i64s_partial_store_last(self, slice: &mut [i64], values: Self::i64s) { ... }
    fn f32s_partial_load_last(self, slice: &[f32]) -> Self::f32s { ... }
    fn f32s_partial_store_last(self, slice: &mut [f32], values: Self::f32s) { ... }
    fn f64s_partial_load_last(self, slice: &[f64]) -> Self::f64s { ... }
    fn f64s_partial_store_last(self, slice: &mut [f64], values: Self::f64s) { ... }
    fn c32s_partial_load_last(self, slice: &[c32]) -> Self::c32s { ... }
    fn c32s_partial_store_last(self, slice: &mut [c32], values: Self::c32s) { ... }
    fn c64s_partial_load_last(self, slice: &[c64]) -> Self::c64s { ... }
    fn c64s_partial_store_last(self, slice: &mut [c64], values: Self::c64s) { ... }
    fn i32s_not(self, a: Self::i32s) -> Self::i32s { ... }
    fn i32s_and(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn i32s_or(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn i32s_xor(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn i64s_not(self, a: Self::i64s) -> Self::i64s { ... }
    fn i64s_and(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn i64s_or(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn i64s_xor(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn f32s_not(self, a: Self::f32s) -> Self::f32s { ... }
    fn f32s_and(self, a: Self::f32s, b: Self::f32s) -> Self::f32s { ... }
    fn f32s_or(self, a: Self::f32s, b: Self::f32s) -> Self::f32s { ... }
    fn f32s_xor(self, a: Self::f32s, b: Self::f32s) -> Self::f32s { ... }
    fn f64s_not(self, a: Self::f64s) -> Self::f64s { ... }
    fn f64s_and(self, a: Self::f64s, b: Self::f64s) -> Self::f64s { ... }
    fn f64s_or(self, a: Self::f64s, b: Self::f64s) -> Self::f64s { ... }
    fn f64s_xor(self, a: Self::f64s, b: Self::f64s) -> Self::f64s { ... }
    fn m32s_select_i32s(
        self,
        mask: Self::m32s,
        if_true: Self::i32s,
        if_false: Self::i32s
    ) -> Self::i32s { ... }
    fn m32s_select_f32s(
        self,
        mask: Self::m32s,
        if_true: Self::f32s,
        if_false: Self::f32s
    ) -> Self::f32s { ... }
    fn m64s_select_i64s(
        self,
        mask: Self::m64s,
        if_true: Self::i64s,
        if_false: Self::i64s
    ) -> Self::i64s { ... }
    fn m64s_select_f64s(
        self,
        mask: Self::m64s,
        if_true: Self::f64s,
        if_false: Self::f64s
    ) -> Self::f64s { ... }
    fn i32s_splat(self, value: i32) -> Self::i32s { ... }
    fn i32s_add(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn i32s_sub(self, a: Self::i32s, b: Self::i32s) -> Self::i32s { ... }
    fn i64s_splat(self, value: i64) -> Self::i64s { ... }
    fn i64s_add(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn i64s_sub(self, a: Self::i64s, b: Self::i64s) -> Self::i64s { ... }
    fn f32s_abs(self, a: Self::f32s) -> Self::f32s { ... }
    fn f32s_neg(self, a: Self::f32s) -> Self::f32s { ... }
    fn f32s_mul_add_e(
        self,
        a: Self::f32s,
        b: Self::f32s,
        c: Self::f32s
    ) -> Self::f32s { ... }
    fn f32_scalar_mul_add_e(self, a: f32, b: f32, c: f32) -> f32 { ... }
    fn f32_scalar_mul_add(self, a: f32, b: f32, c: f32) -> f32 { ... }
    fn f32s_greater_than(self, a: Self::f32s, b: Self::f32s) -> Self::m32s { ... }
    fn f32s_greater_than_or_equal(
        self,
        a: Self::f32s,
        b: Self::f32s
    ) -> Self::m32s { ... }
    fn c32s_mul_e(self, a: Self::c32s, b: Self::c32s) -> Self::c32s { ... }
    fn c32_scalar_mul_e(self, a: c32, b: c32) -> c32 { ... }
    fn c32_scalar_mul(self, a: c32, b: c32) -> c32 { ... }
    fn c32s_conj_mul_e(self, a: Self::c32s, b: Self::c32s) -> Self::c32s { ... }
    fn c32_scalar_conj_mul_e(self, a: c32, b: c32) -> c32 { ... }
    fn c32_scalar_conj_mul(self, a: c32, b: c32) -> c32 { ... }
    fn c32s_mul_add_e(
        self,
        a: Self::c32s,
        b: Self::c32s,
        c: Self::c32s
    ) -> Self::c32s { ... }
    fn c32_scalar_mul_add_e(self, a: c32, b: c32, c: c32) -> c32 { ... }
    fn c32_scalar_mul_add(self, a: c32, b: c32, c: c32) -> c32 { ... }
    fn c32s_conj_mul_add_e(
        self,
        a: Self::c32s,
        b: Self::c32s,
        c: Self::c32s
    ) -> Self::c32s { ... }
    fn c32_scalar_conj_mul_add_e(self, a: c32, b: c32, c: c32) -> c32 { ... }
    fn c32_scalar_conj_mul_add(self, a: c32, b: c32, c: c32) -> c32 { ... }
    fn f64s_abs(self, a: Self::f64s) -> Self::f64s { ... }
    fn f64s_neg(self, a: Self::f64s) -> Self::f64s { ... }
    fn f64s_mul_add_e(
        self,
        a: Self::f64s,
        b: Self::f64s,
        c: Self::f64s
    ) -> Self::f64s { ... }
    fn f64_scalar_mul_add_e(self, a: f64, b: f64, c: f64) -> f64 { ... }
    fn f64_scalar_mul_add(self, a: f64, b: f64, c: f64) -> f64 { ... }
    fn f64s_greater_than(self, a: Self::f64s, b: Self::f64s) -> Self::m64s { ... }
    fn f64s_greater_than_or_equal(
        self,
        a: Self::f64s,
        b: Self::f64s
    ) -> Self::m64s { ... }
    fn c64s_mul_e(self, a: Self::c64s, b: Self::c64s) -> Self::c64s { ... }
    fn c64_scalar_mul_e(self, a: c64, b: c64) -> c64 { ... }
    fn c64_scalar_mul(self, a: c64, b: c64) -> c64 { ... }
    fn c64s_conj_mul_e(self, a: Self::c64s, b: Self::c64s) -> Self::c64s { ... }
    fn c64_scalar_conj_mul_e(self, a: c64, b: c64) -> c64 { ... }
    fn c64_scalar_conj_mul(self, a: c64, b: c64) -> c64 { ... }
    fn c64s_mul_add_e(
        self,
        a: Self::c64s,
        b: Self::c64s,
        c: Self::c64s
    ) -> Self::c64s { ... }
    fn c64_scalar_mul_add_e(self, a: c64, b: c64, c: c64) -> c64 { ... }
    fn c64_scalar_mul_add(self, a: c64, b: c64, c: c64) -> c64 { ... }
    fn c64s_conj_mul_add_e(
        self,
        a: Self::c64s,
        b: Self::c64s,
        c: Self::c64s
    ) -> Self::c64s { ... }
    fn c64_scalar_conj_mul_add_e(self, a: c64, b: c64, c: c64) -> c64 { ... }
    fn c64_scalar_conj_mul_add(self, a: c64, b: c64, c: c64) -> c64 { ... }
    fn f32s_transmute_i32s(self, a: Self::f32s) -> Self::i32s { ... }
    fn f32s_transmute_u32s(self, a: Self::f32s) -> Self::u32s { ... }
    fn i32s_transmute_f32s(self, a: Self::i32s) -> Self::f32s { ... }
    fn i32s_transmute_u32s(self, a: Self::i32s) -> Self::u32s { ... }
    fn u32s_transmute_f32s(self, a: Self::u32s) -> Self::f32s { ... }
    fn u32s_transmute_i32s(self, a: Self::u32s) -> Self::i32s { ... }
    fn f64s_transmute_i64s(self, a: Self::f64s) -> Self::i64s { ... }
    fn f64s_transmute_u64s(self, a: Self::f64s) -> Self::u64s { ... }
    fn i64s_transmute_f64s(self, a: Self::i64s) -> Self::f64s { ... }
    fn i64s_transmute_u64s(self, a: Self::i64s) -> Self::u64s { ... }
    fn u64s_transmute_f64s(self, a: Self::u64s) -> Self::f64s { ... }
    fn u64s_transmute_i64s(self, a: Self::u64s) -> Self::i64s { ... }
    fn i32s_rotate_right(self, a: Self::i32s, amount: usize) -> Self::i32s { ... }
    fn f32s_rotate_right(self, a: Self::f32s, amount: usize) -> Self::f32s { ... }
    fn i64s_rotate_right(self, a: Self::i64s, amount: usize) -> Self::i64s { ... }
    fn f64s_rotate_right(self, a: Self::f64s, amount: usize) -> Self::f64s { ... }
    fn i32s_rotate_left(self, a: Self::i32s, amount: usize) -> Self::i32s { ... }
    fn f32s_rotate_left(self, a: Self::f32s, amount: usize) -> Self::f32s { ... }
    fn u32s_rotate_left(self, a: Self::u32s, amount: usize) -> Self::u32s { ... }
    fn c32s_rotate_left(self, a: Self::c32s, amount: usize) -> Self::c32s { ... }
    fn i64s_rotate_left(self, a: Self::i64s, amount: usize) -> Self::i64s { ... }
    fn f64s_rotate_left(self, a: Self::f64s, amount: usize) -> Self::f64s { ... }
    fn u64s_rotate_left(self, a: Self::u64s, amount: usize) -> Self::u64s { ... }
    fn c64s_rotate_left(self, a: Self::c64s, amount: usize) -> Self::c64s { ... }
}