Struct V2 

pub struct V2 {
    pub sse: Sse,
    pub sse2: Sse2,
    pub fxsr: Fxsr,
    pub sse3: Sse3,
    pub ssse3: Ssse3,
    pub sse4_1: Sse4_1,
    pub sse4_2: Sse4_2,
    pub popcnt: Popcnt,
}

Available on x86 or x86-64 only.

SSE instruction set.

Fields

sse: Sse

sse2: Sse2

fxsr: Fxsr

sse3: Sse3

ssse3: Ssse3

sse4_1: Sse4_1

sse4_2: Sse4_2

popcnt: Popcnt

Implementations

impl V2

SSE instruction set.

pub const unsafe fn new_unchecked() -> Self

Returns a SIMD token type without checking if the required CPU features for this type are available.

Safety

• the required CPU features must be available.

pub fn try_new() -> Option<Self>

Returns a SIMD token type if the required CPU features for this type are available, otherwise returns None.

pub fn is_available() -> bool

Returns true if the required CPU features for this type are available, otherwise returns false.

pub fn vectorize<F: NullaryFnOnce>(self, f: F) -> F::Output

Vectorizes the given function as if the CPU features for this type were applied to it.

Note

For the vectorization to work properly, the given function must be inlined. Consider marking it as #[inline(always)]

pub fn to_ref(self) -> &'static Self

Takes a proof of the existence of this SIMD token (self), and returns a persistent reference to it.

impl V2

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

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

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

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

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

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

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

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

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

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

Returns ceil(a) for each lane of a, rounding towards positive infinity.

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

Returns ceil(a) for each lane of a, rounding towards positive infinity.

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

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

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

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

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

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

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

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

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

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

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

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

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

_mm_hadd_ps

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

_mm_hadd_ps

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

_mm_hadd_ps

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

_mm_hadd_ps

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

_mm_hadd_ps

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

_mm_hadd_ps

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

_mm_hsub_ps

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

_mm_hsub_ps

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

_mm_hsub_ps

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

_mm_hsub_ps

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

_mm_hsub_ps

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

_mm_hsub_ps

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

Computes max(a, b). for each lane in a and b.

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

Computes max(a, b). for each lane in a and b.

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

Computes max(a, b). for each lane in a and b.

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

Computes max(a, b). for each lane in a and b.

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

Computes max(a, b). for each lane in a and b.

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

Computes max(a, b). for each lane in a and b.

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

Computes max(a, b). for each lane in a and b.

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

Computes max(a, b). for each lane in a and b.

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

Computes a * b for each lane in a and b, with wrapping overflow.

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

Computes a * b for each lane in a and b, with wrapping overflow.

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

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

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

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

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

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

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

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

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

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

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

Computes abs(a) for each lane of a.

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

Computes abs(a) for each lane of a.

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

Computes the approximate reciprocal of the elements of each lane of a.

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

Computes the approximate reciprocal of the square roots of the elements of each lane of a.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Converts a u8x16 to i8x16, elementwise.

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

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

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

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

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

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

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

See _mm_hadds_epi16.

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

See _mm_hsubs_epi16.

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

See _mm_maddubs_epi16.

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

See _mm_mpsadbw_epu8.

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

See _mm_packus_epi32.

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

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

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

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

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

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

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

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

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

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

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

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

pub fn select_const_u32x4<const MASK4: i32>( self, if_true: u32x4, if_false: u32x4, ) -> u32x4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Trait Implementations

impl Clone for V2

fn clone(&self) -> V2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for V2

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

Formats the value using the given formatter.

impl Deref for V2

type Target = V1

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Simd for V2

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

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

Safety

See the trait-level safety documentation.

const REGISTER_COUNT: usize = 16usize

type c32s = f32x4

type c64s = f64x2

type f32s = f32x4

type f64s = f64x2

type i16s = i16x8

type i32s = i32x4

type i64s = i64x2

type i8s = i8x16

type m16s = m16x8

type m32s = m32x4

type m64s = m64x2

type m8s = m8x16

type u16s = u16x8

type u32s = u32x4

type u64s = u64x2

type u8s = u8x16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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( 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 splat_c32s(self, value: c32) -> Self::c32s

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

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

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

Safety

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

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_store_ptr_f32s( self, mask: MemMask<Self::m32s>, ptr: *mut f32, values: Self::f32s, )

Safety

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

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

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_load_f32s(self, slice: &[f32]) -> Self::f32s

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

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

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

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

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

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

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

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_i8s(self, slice: &mut [i8], values: Self::i8s)

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

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_u8s(self, slice: &mut [u8], values: Self::u8s)

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

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