Struct Scalar256b 

pub struct Scalar256b;

Trait Implementations

impl Clone for Scalar256b

fn clone(&self) -> Scalar256b

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Scalar256b

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

Formats the value using the given formatter.

impl Simd for Scalar256b

const REGISTER_COUNT: usize = 16usize

type m8s = m8x32

type m16s = m16x16

type c32s = f32x8

type c64s = f64x4

type f32s = f32x8

type f64s = f64x4

type i16s = i16x16

type i32s = i32x8

type i64s = i64x4

type i8s = i8x32

type m32s = m32x8

type m64s = m64x4

type u16s = u16x16

type u32s = u32x8

type u64s = u64x4

type u8s = u8x32

fn min_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::u8s

fn min_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::i8s

fn min_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::u16s

fn min_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::i16s

fn min_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn min_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn min_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn min_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

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 max_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::u8s

fn max_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::i8s

fn max_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::u16s

fn max_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::i16s

fn max_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn max_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn max_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn max_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

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 add_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

fn add_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn add_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

fn add_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn add_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::u8s

fn add_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::i8s

fn add_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::u16s

fn add_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::i16s

fn add_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn add_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn add_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn add_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

fn sub_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

fn sub_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn sub_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

fn sub_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn sub_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::u8s

fn sub_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::i8s

fn sub_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::u16s

fn sub_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::i16s

fn sub_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn sub_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn sub_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn sub_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

fn mul_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

fn mul_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn mul_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

fn mul_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn mul_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::u16s

fn mul_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::i16s

fn mul_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn mul_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn mul_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn mul_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

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 and_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::u8s

fn and_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::u16s

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 or_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::u8s

fn or_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::u16s

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 xor_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::u8s

fn xor_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::u16s

fn xor_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn xor_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn equal_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::m8s

fn equal_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::m16s

fn equal_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn equal_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn equal_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::m32s

fn equal_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::m32s

fn equal_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::m64s

fn equal_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::m64s

fn greater_than_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::m8s

fn greater_than_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::m8s

fn greater_than_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::m16s

fn greater_than_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::m16s

fn greater_than_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn greater_than_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::m32s

fn greater_than_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn greater_than_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::m64s

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_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::m8s

fn greater_than_or_equal_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::m8s

fn greater_than_or_equal_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::m16s

fn greater_than_or_equal_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::m16s

fn greater_than_or_equal_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn greater_than_or_equal_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::m32s

fn greater_than_or_equal_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn greater_than_or_equal_i64s(self, a: Self::i64s, b: Self::i64s) -> 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 less_than_or_equal_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::m8s

fn less_than_or_equal_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::m8s

fn less_than_or_equal_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::m16s

fn less_than_or_equal_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::m16s

fn less_than_or_equal_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn less_than_or_equal_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::m32s

fn less_than_or_equal_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn less_than_or_equal_i64s(self, a: Self::i64s, b: Self::i64s) -> 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_u8s(self, a: Self::u8s, b: Self::u8s) -> Self::m8s

fn less_than_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::m8s

fn less_than_u16s(self, a: Self::u16s, b: Self::u16s) -> Self::m16s

fn less_than_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::m16s

fn less_than_u32s(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn less_than_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::m32s

fn less_than_u64s(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn less_than_i64s(self, a: Self::i64s, b: Self::i64s) -> 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 not_m8s(self, a: Self::m8s) -> Self::m8s

fn not_u8s(self, a: Self::u8s) -> Self::u8s

fn not_m16s(self, a: Self::m16s) -> Self::m16s

fn not_u16s(self, a: Self::u16s) -> Self::u16s

fn not_m32s(self, a: Self::m32s) -> Self::m32s

fn not_u32s(self, a: Self::u32s) -> Self::u32s

fn not_m64s(self, a: Self::m64s) -> Self::m64s

fn not_u64s(self, a: Self::u64s) -> Self::u64s

fn splat_u8s(self, value: u8) -> Self::u8s

fn splat_i8s(self, value: i8) -> Self::i8s

fn splat_u16s(self, value: u16) -> Self::u16s

fn splat_i16s(self, value: i16) -> Self::i16s

fn splat_u32s(self, value: u32) -> Self::u32s

fn splat_i32s(self, value: i32) -> Self::i32s

fn splat_u64s(self, value: u64) -> Self::u64s

fn splat_i64s(self, value: i64) -> Self::i64s

fn splat_f32s(self, value: f32) -> Self::f32s

fn splat_f64s(self, value: f64) -> Self::f64s

fn partial_load_u8s(self, slice: &[u8]) -> Self::u8s

fn partial_load_i8s(self, slice: &[i8]) -> Self::i8s

fn partial_load_u16s(self, slice: &[u16]) -> Self::u16s

fn partial_load_i16s(self, slice: &[i16]) -> Self::i16s

fn partial_load_u32s(self, slice: &[u32]) -> Self::u32s

fn partial_load_i32s(self, slice: &[i32]) -> Self::i32s

fn partial_load_u64s(self, slice: &[u64]) -> Self::u64s

fn partial_load_i64s(self, slice: &[i64]) -> Self::i64s

fn partial_load_f32s(self, slice: &[f32]) -> Self::f32s

fn partial_load_f64s(self, slice: &[f64]) -> Self::f64s

fn partial_store_u8s(self, slice: &mut [u8], values: Self::u8s)

fn partial_store_i8s(self, slice: &mut [i8], values: Self::i8s)

fn partial_store_u16s(self, slice: &mut [u16], values: Self::u16s)

fn partial_store_i16s(self, slice: &mut [i16], values: Self::i16s)

fn partial_store_u32s(self, slice: &mut [u32], values: Self::u32s)

fn partial_store_i32s(self, slice: &mut [i32], values: Self::i32s)

fn partial_store_u64s(self, slice: &mut [u64], values: Self::u64s)

fn partial_store_i64s(self, slice: &mut [i64], values: Self::i64s)

fn partial_store_f32s(self, slice: &mut [f32], values: Self::f32s)

fn partial_store_f64s(self, slice: &mut [f64], values: Self::f64s)

unsafe fn mask_load_ptr_u8s( self, mask: MemMask<Self::m8s>, ptr: *const u8, ) -> Self::u8s

Safety

unsafe fn mask_load_ptr_u16s( self, mask: MemMask<Self::m16s>, ptr: *const u16, ) -> Self::u16s

Safety

unsafe fn mask_load_ptr_u32s( self, mask: MemMask<Self::m32s>, ptr: *const u32, ) -> Self::u32s

Safety

unsafe fn mask_load_ptr_u64s( self, mask: MemMask<Self::m64s>, ptr: *const u64, ) -> Self::u64s

Safety

unsafe fn mask_load_ptr_i8s( self, mask: MemMask<Self::m8s>, ptr: *const i8, ) -> Self::i8s

Safety

unsafe fn mask_load_ptr_i16s( self, mask: MemMask<Self::m16s>, ptr: *const i16, ) -> Self::i16s

Safety

unsafe fn mask_load_ptr_i32s( self, mask: MemMask<Self::m32s>, ptr: *const i32, ) -> Self::i32s

Safety

unsafe fn mask_load_ptr_i64s( self, mask: MemMask<Self::m64s>, ptr: *const i64, ) -> Self::i64s

Safety

unsafe fn mask_load_ptr_c32s( self, mask: MemMask<Self::m32s>, ptr: *const c32, ) -> Self::c32s

Safety

unsafe fn mask_load_ptr_f32s( self, mask: MemMask<Self::m32s>, ptr: *const f32, ) -> Self::f32s

Safety

unsafe fn mask_load_ptr_c64s( self, mask: MemMask<Self::m64s>, ptr: *const c64, ) -> Self::c64s

Safety

unsafe fn mask_load_ptr_f64s( self, mask: MemMask<Self::m64s>, ptr: *const f64, ) -> Self::f64s

Safety

unsafe fn mask_store_ptr_u8s( self, mask: MemMask<Self::m8s>, ptr: *mut u8, values: Self::u8s, )

Safety

unsafe fn mask_store_ptr_u16s( self, mask: MemMask<Self::m16s>, ptr: *mut u16, values: Self::u16s, )

Safety

unsafe fn mask_store_ptr_u32s( self, mask: MemMask<Self::m32s>, ptr: *mut u32, values: Self::u32s, )

Safety

unsafe fn mask_store_ptr_u64s( self, mask: MemMask<Self::m64s>, ptr: *mut u64, values: Self::u64s, )

Safety

unsafe fn mask_store_ptr_i8s( self, mask: MemMask<Self::m8s>, ptr: *mut i8, values: Self::i8s, )

Safety

unsafe fn mask_store_ptr_i16s( self, mask: MemMask<Self::m16s>, ptr: *mut i16, values: Self::i16s, )

Safety

unsafe fn mask_store_ptr_i32s( self, mask: MemMask<Self::m32s>, ptr: *mut i32, values: Self::i32s, )

Safety

unsafe fn mask_store_ptr_i64s( self, mask: MemMask<Self::m64s>, ptr: *mut i64, values: Self::i64s, )

Safety

unsafe fn mask_store_ptr_c32s( self, mask: MemMask<Self::m32s>, ptr: *mut c32, values: Self::c32s, )

Safety

unsafe fn mask_store_ptr_f32s( self, mask: MemMask<Self::m32s>, ptr: *mut f32, values: Self::f32s, )

Safety

unsafe fn mask_store_ptr_c64s( self, mask: MemMask<Self::m64s>, ptr: *mut c64, values: Self::c64s, )

Safety

unsafe fn mask_store_ptr_f64s( self, mask: MemMask<Self::m64s>, ptr: *mut f64, values: Self::f64s, )

Safety

fn vectorize<Op: WithSimd>(self, op: Op) -> Op::Output

fn and_m32s(self, a: Self::m32s, b: Self::m32s) -> Self::m32s

fn or_m32s(self, a: Self::m32s, b: Self::m32s) -> Self::m32s

fn xor_m32s(self, a: Self::m32s, b: Self::m32s) -> Self::m32s

fn and_m64s(self, a: Self::m64s, b: Self::m64s) -> Self::m64s

fn or_m64s(self, a: Self::m64s, b: Self::m64s) -> Self::m64s

fn xor_m64s(self, a: Self::m64s, b: Self::m64s) -> Self::m64s

fn select_u32s( self, mask: Self::m32s, if_true: Self::u32s, if_false: Self::u32s, ) -> Self::u32s

fn select_u64s( self, mask: Self::m64s, if_true: Self::u64s, if_false: Self::u64s, ) -> Self::u64s

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 widening_mul_u32s( self, a: Self::u32s, b: Self::u32s, ) -> (Self::u32s, Self::u32s)

fn mul_add_f32s(self, a: Self::f32s, b: Self::f32s, c: Self::f32s) -> Self::f32s

fn reduce_sum_f32s(self, a: Self::f32s) -> f32

fn reduce_product_f32s(self, a: Self::f32s) -> f32

fn reduce_min_f32s(self, a: Self::f32s) -> f32

fn reduce_max_f32s(self, a: Self::f32s) -> f32

fn splat_c32s(self, value: c32) -> Self::c32s

fn conj_c32s(self, a: Self::c32s) -> Self::c32s

fn neg_c32s(self, a: Self::c32s) -> Self::c32s

fn swap_re_im_c32s(self, a: Self::c32s) -> Self::c32s

fn conj_mul_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

fn mul_add_c32s(self, a: Self::c32s, b: Self::c32s, c: Self::c32s) -> Self::c32s

fn conj_mul_add_c32s( self, a: Self::c32s, b: Self::c32s, c: Self::c32s, ) -> Self::c32s

fn abs2_c32s(self, a: Self::c32s) -> Self::c32s

Contains the square of the norm in both the real and imaginary components.

fn abs_max_c32s(self, a: Self::c32s) -> Self::c32s

Contains the max norm in both the real and imaginary components.

fn reduce_sum_c32s(self, a: Self::c32s) -> c32

fn reduce_min_c32s(self, a: Self::c32s) -> c32

fn reduce_max_c32s(self, a: Self::c32s) -> c32

fn rotate_right_u32s(self, a: Self::u32s, amount: usize) -> Self::u32s

fn rotate_right_c32s(self, a: Self::c32s, amount: usize) -> Self::c32s

fn mul_add_f64s(self, a: Self::f64s, b: Self::f64s, c: Self::f64s) -> Self::f64s

fn reduce_sum_f64s(self, a: Self::f64s) -> f64

fn reduce_product_f64s(self, a: Self::f64s) -> f64

fn reduce_min_f64s(self, a: Self::f64s) -> f64

fn reduce_max_f64s(self, a: Self::f64s) -> f64

fn splat_c64s(self, value: c64) -> Self::c64s

fn conj_c64s(self, a: Self::c64s) -> Self::c64s

fn neg_c64s(self, a: Self::c64s) -> Self::c64s

fn swap_re_im_c64s(self, a: Self::c64s) -> Self::c64s

fn conj_mul_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

fn mul_add_c64s(self, a: Self::c64s, b: Self::c64s, c: Self::c64s) -> Self::c64s

fn conj_mul_add_c64s( self, a: Self::c64s, b: Self::c64s, c: Self::c64s, ) -> Self::c64s

fn abs2_c64s(self, a: Self::c64s) -> Self::c64s

Contains the square of the norm in both the real and imaginary components.

fn abs_max_c64s(self, a: Self::c64s) -> Self::c64s

Contains the max norm in both the real and imaginary components.

fn reduce_sum_c64s(self, a: Self::c64s) -> c64

fn reduce_min_c64s(self, a: Self::c64s) -> c64

fn reduce_max_c64s(self, a: Self::c64s) -> c64

fn rotate_right_u64s(self, a: Self::u64s, amount: usize) -> Self::u64s

fn rotate_right_c64s(self, a: Self::c64s, amount: usize) -> 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 sqrt_f32s(self, a: Self::f32s) -> Self::f32s

fn sqrt_f64s(self, a: Self::f64s) -> Self::f64s

const IS_SCALAR: bool = false

const M64_LANES: usize = _

const U64_LANES: usize = _

const I64_LANES: usize = _

const F64_LANES: usize = _

const C64_LANES: usize = _

const M32_LANES: usize = _

const U32_LANES: usize = _

const I32_LANES: usize = _

const F32_LANES: usize = _

const C32_LANES: usize = _

const M16_LANES: usize = _

const U16_LANES: usize = _

const I16_LANES: usize = _

const M8_LANES: usize = _

const U8_LANES: usize = _

const I8_LANES: usize = _

fn abs_f32s(self, a: Self::f32s) -> Self::f32s

fn abs_f64s(self, a: Self::f64s) -> Self::f64s

fn and_m8s(self, a: Self::m8s, b: Self::m8s) -> Self::m8s

fn and_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::i8s

fn and_m16s(self, a: Self::m16s, b: Self::m16s) -> Self::m16s

fn and_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::i16s

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 and_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn and_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn or_m8s(self, a: Self::m8s, b: Self::m8s) -> Self::m8s

fn or_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::i8s

fn or_m16s(self, a: Self::m16s, b: Self::m16s) -> Self::m16s

fn or_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::i16s

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 or_f32s(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn or_f64s(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn xor_m8s(self, a: Self::m8s, b: Self::m8s) -> Self::m8s

fn xor_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::i8s

fn xor_m16s(self, a: Self::m16s, b: Self::m16s) -> Self::m16s

fn xor_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::i16s

fn xor_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn xor_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

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 equal_m8s(self, a: Self::m8s, b: Self::m8s) -> Self::m8s

fn equal_i8s(self, a: Self::i8s, b: Self::i8s) -> Self::m8s

fn equal_m16s(self, a: Self::m16s, b: Self::m16s) -> Self::m16s

fn equal_i16s(self, a: Self::i16s, b: Self::i16s) -> Self::m16s

fn equal_m32s(self, a: Self::m32s, b: Self::m32s) -> Self::m32s

fn equal_i32s(self, a: Self::i32s, b: Self::i32s) -> Self::m32s

fn equal_m64s(self, a: Self::m64s, b: Self::m64s) -> Self::m64s

fn equal_i64s(self, a: Self::i64s, b: Self::i64s) -> Self::m64s

fn not_i8s(self, a: Self::i8s) -> Self::i8s

fn not_i16s(self, a: Self::i16s) -> Self::i16s

fn not_i32s(self, a: Self::i32s) -> Self::i32s

fn not_i64s(self, a: Self::i64s) -> Self::i64s

fn not_f32s(self, a: Self::f32s) -> Self::f32s

fn not_f64s(self, a: Self::f64s) -> Self::f64s

fn as_mut_rsimd_u8s(slice: &mut [u8]) -> (&mut [u8], &mut [Self::u8s])

fn as_rsimd_u8s(slice: &[u8]) -> (&[u8], &[Self::u8s])

fn as_mut_simd_u8s(slice: &mut [u8]) -> (&mut [Self::u8s], &mut [u8])

fn as_simd_u8s(slice: &[u8]) -> (&[Self::u8s], &[u8])

fn as_uninit_mut_rsimd_u8s( slice: &mut [MaybeUninit<u8>], ) -> (&mut [MaybeUninit<u8>], &mut [MaybeUninit<Self::u8s>])

fn as_uninit_mut_simd_u8s( slice: &mut [MaybeUninit<u8>], ) -> (&mut [MaybeUninit<Self::u8s>], &mut [MaybeUninit<u8>])

fn as_mut_rsimd_i8s(slice: &mut [i8]) -> (&mut [i8], &mut [Self::i8s])

fn as_rsimd_i8s(slice: &[i8]) -> (&[i8], &[Self::i8s])

fn as_mut_simd_i8s(slice: &mut [i8]) -> (&mut [Self::i8s], &mut [i8])

fn as_simd_i8s(slice: &[i8]) -> (&[Self::i8s], &[i8])

fn as_uninit_mut_rsimd_i8s( slice: &mut [MaybeUninit<i8>], ) -> (&mut [MaybeUninit<i8>], &mut [MaybeUninit<Self::i8s>])

fn as_uninit_mut_simd_i8s( slice: &mut [MaybeUninit<i8>], ) -> (&mut [MaybeUninit<Self::i8s>], &mut [MaybeUninit<i8>])

fn as_mut_rsimd_u16s(slice: &mut [u16]) -> (&mut [u16], &mut [Self::u16s])

fn as_rsimd_u16s(slice: &[u16]) -> (&[u16], &[Self::u16s])

fn as_mut_simd_u16s(slice: &mut [u16]) -> (&mut [Self::u16s], &mut [u16])

fn as_simd_u16s(slice: &[u16]) -> (&[Self::u16s], &[u16])

fn as_uninit_mut_rsimd_u16s( slice: &mut [MaybeUninit<u16>], ) -> (&mut [MaybeUninit<u16>], &mut [MaybeUninit<Self::u16s>])

fn as_uninit_mut_simd_u16s( slice: &mut [MaybeUninit<u16>], ) -> (&mut [MaybeUninit<Self::u16s>], &mut [MaybeUninit<u16>])

fn as_mut_rsimd_i16s(slice: &mut [i16]) -> (&mut [i16], &mut [Self::i16s])

fn as_rsimd_i16s(slice: &[i16]) -> (&[i16], &[Self::i16s])

fn as_mut_simd_i16s(slice: &mut [i16]) -> (&mut [Self::i16s], &mut [i16])

fn as_simd_i16s(slice: &[i16]) -> (&[Self::i16s], &[i16])

fn as_uninit_mut_rsimd_i16s( slice: &mut [MaybeUninit<i16>], ) -> (&mut [MaybeUninit<i16>], &mut [MaybeUninit<Self::i16s>])

fn as_uninit_mut_simd_i16s( slice: &mut [MaybeUninit<i16>], ) -> (&mut [MaybeUninit<Self::i16s>], &mut [MaybeUninit<i16>])

fn as_mut_rsimd_u32s(slice: &mut [u32]) -> (&mut [u32], &mut [Self::u32s])

fn as_rsimd_u32s(slice: &[u32]) -> (&[u32], &[Self::u32s])

fn as_mut_simd_u32s(slice: &mut [u32]) -> (&mut [Self::u32s], &mut [u32])

fn as_simd_u32s(slice: &[u32]) -> (&[Self::u32s], &[u32])

fn as_uninit_mut_rsimd_u32s( slice: &mut [MaybeUninit<u32>], ) -> (&mut [MaybeUninit<u32>], &mut [MaybeUninit<Self::u32s>])

fn as_uninit_mut_simd_u32s( slice: &mut [MaybeUninit<u32>], ) -> (&mut [MaybeUninit<Self::u32s>], &mut [MaybeUninit<u32>])

fn as_mut_rsimd_i32s(slice: &mut [i32]) -> (&mut [i32], &mut [Self::i32s])

fn as_rsimd_i32s(slice: &[i32]) -> (&[i32], &[Self::i32s])

fn as_mut_simd_i32s(slice: &mut [i32]) -> (&mut [Self::i32s], &mut [i32])

fn as_simd_i32s(slice: &[i32]) -> (&[Self::i32s], &[i32])

fn as_uninit_mut_rsimd_i32s( slice: &mut [MaybeUninit<i32>], ) -> (&mut [MaybeUninit<i32>], &mut [MaybeUninit<Self::i32s>])

fn as_uninit_mut_simd_i32s( slice: &mut [MaybeUninit<i32>], ) -> (&mut [MaybeUninit<Self::i32s>], &mut [MaybeUninit<i32>])

fn as_mut_rsimd_u64s(slice: &mut [u64]) -> (&mut [u64], &mut [Self::u64s])

fn as_rsimd_u64s(slice: &[u64]) -> (&[u64], &[Self::u64s])

fn as_mut_simd_u64s(slice: &mut [u64]) -> (&mut [Self::u64s], &mut [u64])

fn as_simd_u64s(slice: &[u64]) -> (&[Self::u64s], &[u64])

fn as_uninit_mut_rsimd_u64s( slice: &mut [MaybeUninit<u64>], ) -> (&mut [MaybeUninit<u64>], &mut [MaybeUninit<Self::u64s>])

fn as_uninit_mut_simd_u64s( slice: &mut [MaybeUninit<u64>], ) -> (&mut [MaybeUninit<Self::u64s>], &mut [MaybeUninit<u64>])

fn as_mut_rsimd_i64s(slice: &mut [i64]) -> (&mut [i64], &mut [Self::i64s])

fn as_rsimd_i64s(slice: &[i64]) -> (&[i64], &[Self::i64s])

fn as_mut_simd_i64s(slice: &mut [i64]) -> (&mut [Self::i64s], &mut [i64])

fn as_simd_i64s(slice: &[i64]) -> (&[Self::i64s], &[i64])

fn as_uninit_mut_rsimd_i64s( slice: &mut [MaybeUninit<i64>], ) -> (&mut [MaybeUninit<i64>], &mut [MaybeUninit<Self::i64s>])

fn as_uninit_mut_simd_i64s( slice: &mut [MaybeUninit<i64>], ) -> (&mut [MaybeUninit<Self::i64s>], &mut [MaybeUninit<i64>])

fn as_mut_rsimd_c32s(slice: &mut [c32]) -> (&mut [c32], &mut [Self::c32s])

fn as_rsimd_c32s(slice: &[c32]) -> (&[c32], &[Self::c32s])

fn as_mut_simd_c32s(slice: &mut [c32]) -> (&mut [Self::c32s], &mut [c32])

fn as_simd_c32s(slice: &[c32]) -> (&[Self::c32s], &[c32])

fn as_uninit_mut_rsimd_c32s( slice: &mut [MaybeUninit<c32>], ) -> (&mut [MaybeUninit<c32>], &mut [MaybeUninit<Self::c32s>])

fn as_uninit_mut_simd_c32s( slice: &mut [MaybeUninit<c32>], ) -> (&mut [MaybeUninit<Self::c32s>], &mut [MaybeUninit<c32>])

fn as_mut_rsimd_f32s(slice: &mut [f32]) -> (&mut [f32], &mut [Self::f32s])

fn as_rsimd_f32s(slice: &[f32]) -> (&[f32], &[Self::f32s])

fn as_mut_simd_f32s(slice: &mut [f32]) -> (&mut [Self::f32s], &mut [f32])

fn as_simd_f32s(slice: &[f32]) -> (&[Self::f32s], &[f32])

fn as_uninit_mut_rsimd_f32s( slice: &mut [MaybeUninit<f32>], ) -> (&mut [MaybeUninit<f32>], &mut [MaybeUninit<Self::f32s>])

fn as_uninit_mut_simd_f32s( slice: &mut [MaybeUninit<f32>], ) -> (&mut [MaybeUninit<Self::f32s>], &mut [MaybeUninit<f32>])

fn as_mut_rsimd_c64s(slice: &mut [c64]) -> (&mut [c64], &mut [Self::c64s])

fn as_rsimd_c64s(slice: &[c64]) -> (&[c64], &[Self::c64s])

fn as_mut_simd_c64s(slice: &mut [c64]) -> (&mut [Self::c64s], &mut [c64])

fn as_simd_c64s(slice: &[c64]) -> (&[Self::c64s], &[c64])

fn as_uninit_mut_rsimd_c64s( slice: &mut [MaybeUninit<c64>], ) -> (&mut [MaybeUninit<c64>], &mut [MaybeUninit<Self::c64s>])

fn as_uninit_mut_simd_c64s( slice: &mut [MaybeUninit<c64>], ) -> (&mut [MaybeUninit<Self::c64s>], &mut [MaybeUninit<c64>])

fn as_mut_rsimd_f64s(slice: &mut [f64]) -> (&mut [f64], &mut [Self::f64s])

fn as_rsimd_f64s(slice: &[f64]) -> (&[f64], &[Self::f64s])

fn as_mut_simd_f64s(slice: &mut [f64]) -> (&mut [Self::f64s], &mut [f64])

fn as_simd_f64s(slice: &[f64]) -> (&[Self::f64s], &[f64])

fn as_uninit_mut_rsimd_f64s( slice: &mut [MaybeUninit<f64>], ) -> (&mut [MaybeUninit<f64>], &mut [MaybeUninit<Self::f64s>])

fn as_uninit_mut_simd_f64s( slice: &mut [MaybeUninit<f64>], ) -> (&mut [MaybeUninit<Self::f64s>], &mut [MaybeUninit<f64>])

fn conj_mul_add_e_c32s( self, a: Self::c32s, b: Self::c32s, c: Self::c32s, ) -> Self::c32s

Computes conj(a) * b + c

fn conj_mul_add_e_c64s( self, a: Self::c64s, b: Self::c64s, c: Self::c64s, ) -> Self::c64s

Computes conj(a) * b + c

fn conj_mul_e_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

Computes conj(a) * b

fn conj_mul_e_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

Computes conj(a) * b

fn deinterleave_shfl_f32s<T: Interleave>(self, values: T) -> T

fn deinterleave_shfl_f64s<T: Interleave>(self, values: T) -> T

fn first_true_m8s(self, mask: Self::m8s) -> usize

fn first_true_m16s(self, mask: Self::m16s) -> usize

fn first_true_m32s(self, mask: Self::m32s) -> usize

fn first_true_m64s(self, mask: Self::m64s) -> usize

fn interleave_shfl_f32s<T: Interleave>(self, values: T) -> T

fn interleave_shfl_f64s<T: Interleave>(self, values: T) -> T

fn mask_between_m8s(self, start: u8, end: u8) -> MemMask<Self::m8s>

fn mask_between_m16s(self, start: u16, end: u16) -> MemMask<Self::m16s>

fn mask_between_m32s(self, start: u32, end: u32) -> MemMask<Self::m32s>

fn mask_between_m64s(self, start: u64, end: u64) -> MemMask<Self::m64s>

fn mul_add_e_c32s( self, a: Self::c32s, b: Self::c32s, c: Self::c32s, ) -> Self::c32s

Computes a * b + c

fn mul_add_e_c64s( self, a: Self::c64s, b: Self::c64s, c: Self::c64s, ) -> Self::c64s

Computes a * b + c

fn mul_e_c32s(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

Computes a * b

fn mul_e_c64s(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

Computes a * b

fn neg_f32s(self, a: Self::f32s) -> Self::f32s

fn neg_f64s(self, a: Self::f64s) -> Self::f64s

fn partial_load_c32s(self, slice: &[c32]) -> Self::c32s

fn partial_load_c64s(self, slice: &[c64]) -> Self::c64s

fn partial_store_c32s(self, slice: &mut [c32], values: Self::c32s)

fn partial_store_c64s(self, slice: &mut [c64], values: Self::c64s)

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( self, mask: Self::m32s, if_true: Self::f32s, if_false: Self::f32s, ) -> Self::f32s

fn select_f64s( self, mask: Self::m64s, if_true: Self::f64s, if_false: Self::f64s, ) -> Self::f64s

fn select_i32s( self, mask: Self::m32s, if_true: Self::i32s, if_false: Self::i32s, ) -> Self::i32s

fn select_i64s( self, mask: Self::m64s, if_true: Self::i64s, if_false: 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_m8s_u8s(self, a: Self::u8s) -> Self::m8s

fn transmute_u8s_m8s(self, a: Self::m8s) -> Self::u8s

fn transmute_m16s_u16s(self, a: Self::u16s) -> Self::m16s

fn transmute_u16s_m16s(self, a: Self::m16s) -> Self::u16s

fn transmute_m32s_u32s(self, a: Self::u32s) -> Self::m32s

fn transmute_u32s_m32s(self, a: Self::m32s) -> Self::u32s

fn transmute_m64s_u64s(self, a: Self::u64s) -> Self::m64s

fn transmute_u64s_m64s(self, a: Self::m64s) -> Self::u64s

fn transmute_i8s_u8s(self, a: Self::u8s) -> Self::i8s

fn transmute_u8s_i8s(self, a: Self::i8s) -> Self::u8s

fn transmute_u16s_i16s(self, a: Self::i16s) -> Self::u16s

fn transmute_i16s_u16s(self, a: Self::u16s) -> Self::i16s

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

impl Copy for Scalar256b

impl PortableSimd for Scalar256b