Struct Fallback 

pub struct Fallback { /* private fields */ }

Available on crate feature force_support_fallback or neither AArch64 and target feature neon, nor target feature fxsr and target feature sse2 and (x86 or x86-64), nor WebAssembly and target feature simd128 only.

A token for scalar fallback SIMD, representing the “fallback” level.

Browsing the documentation

The method list on this struct is very verbose. A better way to browse the docs is by looking at vector types such as u32x4, f32x4 or mask32x4. They include all the operations listed here, and also provide some additional convenience methods.

Implementations

impl Fallback

pub const fn new() -> Self

Create a scalar fallback token.

Trait Implementations

impl Clone for Fallback

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Fallback

impl Debug for Fallback

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

Formats the value using the given formatter.

impl ExtractToken for Fallback

type S = Fallback

The SIMD implementation associated with this value.

fn token(&self) -> Self

Get the SIMD token associated with this value.

impl Simd for Fallback

type f32s = f32x4<Fallback>

A native-width SIMD vector of f32s.

type f64s = f64x2<Fallback>

A native-width SIMD vector of f64s.

type u8s = u8x16<Fallback>

A native-width SIMD vector of u8s.

type i8s = i8x16<Fallback>

A native-width SIMD vector of i8s.

type u16s = u16x8<Fallback>

A native-width SIMD vector of u16s.

type i16s = i16x8<Fallback>

A native-width SIMD vector of i16s.

type u32s = u32x4<Fallback>

A native-width SIMD vector of u32s.

type i32s = i32x4<Fallback>

A native-width SIMD vector of i32s.

type u64s = u64x2<Fallback>

A native-width SIMD vector of u64s.

type i64s = i64x2<Fallback>

A native-width SIMD vector of i64s.

type mask8s = mask8x16<Fallback>

A native-width SIMD mask with 8-bit lanes.

type mask16s = mask16x8<Fallback>

A native-width SIMD mask with 16-bit lanes.

type mask32s = mask32x4<Fallback>

A native-width SIMD mask with 32-bit lanes.

type mask64s = mask64x2<Fallback>

A native-width SIMD mask with 64-bit lanes.

fn level(self) -> Level

This SIMD token’s feature level.

fn vectorize<F: FnOnce() -> R, R>(self, f: F) -> R

Call a closure with the instructions for this SIMD level enabled.

fn abs_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Compute the absolute value of each element.

fn splat_f32x4(self, val: f32) -> f32x4<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Reverse the order of the vector’s elements.

fn slide_f32x4<const SHIFT: usize>( self, a: f32x4<Self>, b: f32x4<Self>, ) -> f32x4<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn neg_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Negate each element of the vector.

fn sqrt_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Compute the square root of each element.

fn approximate_recip_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Compute an approximate reciprocal (1. / x) for each element.

fn add_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Add two vectors element-wise.

fn sub_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Subtract two vectors element-wise.

fn mul_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Multiply two vectors element-wise.

fn div_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Divide two vectors element-wise.

fn copysign_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Return a vector with the magnitude of a and the sign of b for each element.

fn reduce_max_f32x4(self, a: f32x4<Self>) -> f32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_f32x4(self, a: f32x4<Self>) -> f32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_max_precise_f32x4(self, a: f32x4<Self>) -> f32

Return the maximum element in the vector, ignoring quiet NaNs.

fn reduce_min_precise_f32x4(self, a: f32x4<Self>) -> f32

Return the minimum element in the vector, ignoring quiet NaNs.

fn reduce_sum_f32x4(self, a: f32x4<Self>) -> f32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_f32x4(self, a: f32x4<Self>) -> f32

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Return the element-wise maximum of two vectors.

fn min_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Return the element-wise minimum of two vectors.

fn max_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Return the element-wise maximum of two vectors.

fn min_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for equality.

fn simd_lt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for less than.

fn simd_le_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Interleave the lower half elements of two vectors.

fn zip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self>

Extract odd-indexed elements from two vectors.

fn interleave_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, ) -> (f32x4<Self>, f32x4<Self>)

Interleave two vectors.

fn deinterleave_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, ) -> (f32x4<Self>, f32x4<Self>)

Deinterleave two vectors.

fn mul_add_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, c: f32x4<Self>, ) -> f32x4<Self>

Compute (a * b) + c (fused multiply-add) for each element.

fn mul_add_precise_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, c: f32x4<Self>, ) -> f32x4<Self>

Compute (a * b) + c for each element, with a single rounding at the end.

fn mul_sub_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, c: f32x4<Self>, ) -> f32x4<Self>

Compute (a * b) - c (fused multiply-subtract) for each element.

fn mul_sub_precise_f32x4( self, a: f32x4<Self>, b: f32x4<Self>, c: f32x4<Self>, ) -> f32x4<Self>

Compute (a * b) - c for each element, with a single rounding at the end.

fn floor_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Return the largest integer less than or equal to each element, that is, round towards negative infinity.

fn ceil_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.

fn round_ties_even_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Round each element to the nearest integer, with ties rounding to the nearest even integer.

fn fract_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Return the fractional part of each element.

fn trunc_f32x4(self, a: f32x4<Self>) -> f32x4<Self>

Return the integer part of each element, rounding towards zero.

fn select_f32x4( self, a: mask32x4<Self>, b: f32x4<Self>, c: f32x4<Self>, ) -> f32x4<Self>

Select elements from b and c based on the mask operand a.

fn combine_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x8<Self>

Combine two vectors into a single vector with twice the width.

fn load_four_interleaved_f32x4(self, src: &[f32; 16]) -> [f32x4<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_f32x4( self, vectors: [f32x4<Self>; 4], dest: &mut [f32; 16], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn widen_f32x4(self, a: f32x4<Self>) -> (f64x2<Self>, f64x2<Self>)

Widen every f32 lane exactly into two same-width f64 vectors.

fn cvt_u32_f32x4(self, a: f32x4<Self>) -> u32x4<Self>

Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.

fn cvt_u32_precise_f32x4(self, a: f32x4<Self>) -> u32x4<Self>

Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.

fn cvt_i32_f32x4(self, a: f32x4<Self>) -> i32x4<Self>

Convert each floating-point element to a signed 32-bit integer, truncating towards zero.

fn cvt_i32_precise_f32x4(self, a: f32x4<Self>) -> i32x4<Self>

Convert each floating-point element to a signed 32-bit integer, truncating towards zero.

fn abs_i8x16(self, a: i8x16<Self>) -> i8x16<Self>

Compute the absolute value of each element.

fn splat_i8x16(self, val: i8) -> i8x16<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i8x16(self, a: i8x16<Self>) -> i8x16<Self>

Reverse the order of the vector’s elements.

fn slide_i8x16<const SHIFT: usize>( self, a: i8x16<Self>, b: i8x16<Self>, ) -> i8x16<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn count_ones_i8x16(self, a: i8x16<Self>) -> i8x16<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i8x16(self, a: i8x16<Self>) -> i8x16<Self>

Return the number of zeros in the binary representation of each element.

fn add_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Compute the bitwise AND of two vectors.

fn or_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Compute the bitwise OR of two vectors.

fn xor_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Compute the bitwise XOR of two vectors.

fn not_i8x16(self, a: i8x16<Self>) -> i8x16<Self>

Compute the bitwise NOT of the vector.

fn shl_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self>

Shift each element left by the given number of bits.

fn shlv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Shift each element left by the given number of bits.

fn shr_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self>

Shift each element right by the given number of bits.

fn shrv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i8x16(self, a: i8x16<Self>) -> i8

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i8x16(self, a: i8x16<Self>) -> i8

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i8x16(self, a: i8x16<Self>) -> i8

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i8x16(self, a: i8x16<Self>) -> i8

Return the product of all elements in the vector. Integer multiplication wraps.

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

Return the element-wise maximum of two vectors.

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

Return the element-wise minimum of two vectors.

fn simd_eq_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for less than.

fn simd_le_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i8x16( self, a: i8x16<Self>, b: i8x16<Self>, ) -> (i8x16<Self>, i8x16<Self>)

Interleave two vectors.

fn deinterleave_i8x16( self, a: i8x16<Self>, b: i8x16<Self>, ) -> (i8x16<Self>, i8x16<Self>)

Deinterleave two vectors.

fn select_i8x16( self, a: mask8x16<Self>, b: i8x16<Self>, c: i8x16<Self>, ) -> i8x16<Self>

Select elements from b and c based on the mask operand a.

fn combine_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x32<Self>

Combine two vectors into a single vector with twice the width.

fn neg_i8x16(self, a: i8x16<Self>) -> i8x16<Self>

Negate each element of the vector, wrapping on overflow.

fn load_four_interleaved_i8x16(self, src: &[i8; 64]) -> [i8x16<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_i8x16( self, vectors: [i8x16<Self>; 4], dest: &mut [i8; 64], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn widen_i8x16(self, a: i8x16<Self>) -> (i16x8<Self>, i16x8<Self>)

Widen every lane into two same-width vectors.

fn splat_u8x16(self, val: u8) -> u8x16<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u8x16(self, a: u8x16<Self>) -> u8x16<Self>

Reverse the order of the vector’s elements.

fn slide_u8x16<const SHIFT: usize>( self, a: u8x16<Self>, b: u8x16<Self>, ) -> u8x16<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn swizzle_dyn_within_blocks_u8x16( self, a: u8x16<Self>, indices: u8x16<Self>, ) -> u8x16<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u8x16( self, a: u8x16<Self>, indices: u8x16<Self>, ) -> u8x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_u8x16(self, a: u8x16<Self>) -> u8x16<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u8x16(self, a: u8x16<Self>) -> u8x16<Self>

Return the number of zeros in the binary representation of each element.

fn add_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Compute the bitwise AND of two vectors.

fn or_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Compute the bitwise OR of two vectors.

fn xor_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Compute the bitwise XOR of two vectors.

fn not_u8x16(self, a: u8x16<Self>) -> u8x16<Self>

Compute the bitwise NOT of the vector.

fn shl_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self>

Shift each element left by the given number of bits.

fn shlv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Shift each element left by the given number of bits.

fn shr_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self>

Shift each element right by the given number of bits.

fn shrv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u8x16(self, a: u8x16<Self>) -> u8

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u8x16(self, a: u8x16<Self>) -> u8

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u8x16(self, a: u8x16<Self>) -> u8

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u8x16(self, a: u8x16<Self>) -> u8

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Return the element-wise maximum of two vectors.

fn min_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for less than.

fn simd_le_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u8x16( self, a: u8x16<Self>, b: u8x16<Self>, ) -> (u8x16<Self>, u8x16<Self>)

Interleave two vectors.

fn deinterleave_u8x16( self, a: u8x16<Self>, b: u8x16<Self>, ) -> (u8x16<Self>, u8x16<Self>)

Deinterleave two vectors.

fn select_u8x16( self, a: mask8x16<Self>, b: u8x16<Self>, c: u8x16<Self>, ) -> u8x16<Self>

Select elements from b and c based on the mask operand a.

fn combine_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x32<Self>

Combine two vectors into a single vector with twice the width.

fn load_four_interleaved_u8x16(self, src: &[u8; 64]) -> [u8x16<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_u8x16( self, vectors: [u8x16<Self>; 4], dest: &mut [u8; 64], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn widen_u8x16(self, a: u8x16<Self>) -> (u16x8<Self>, u16x8<Self>)

Widen every lane into two same-width vectors.

fn splat_mask8x16(self, val: bool) -> mask8x16<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask8x16(self, bits: u64) -> mask8x16<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask8x16(self, a: mask8x16<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn set_mask8x16(self, a: &mut mask8x16<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask8x16<const OFFSET: usize>( self, a: mask8x16<Self>, ) -> mask8x16<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask8x16<const OFFSET: usize>( self, a: mask8x16<Self>, ) -> mask8x16<Self>

Rotate the mask elements to the right by OFFSET.

fn and_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>

Compute the logical AND of two masks.

fn or_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>

Compute the logical OR of two masks.

fn xor_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self>

Compute the logical XOR of two masks.

fn not_mask8x16(self, a: mask8x16<Self>) -> mask8x16<Self>

Compute the logical NOT of the mask.

fn reverse_mask8x16(self, a: mask8x16<Self>) -> mask8x16<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask8x16( self, a: mask8x16<Self>, b: mask8x16<Self>, c: mask8x16<Self>, ) -> mask8x16<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask8x16( self, a: mask8x16<Self>, b: mask8x16<Self>, ) -> mask8x16<Self>

Compare two vectors element-wise for equality.

fn any_true_mask8x16(self, a: mask8x16<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask8x16(self, a: mask8x16<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask8x16(self, a: mask8x16<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask8x16(self, a: mask8x16<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn combine_mask8x16( self, a: mask8x16<Self>, b: mask8x16<Self>, ) -> mask8x32<Self>

Combine two vectors into a single vector with twice the width.

fn abs_i16x8(self, a: i16x8<Self>) -> i16x8<Self>

Compute the absolute value of each element.

fn splat_i16x8(self, val: i16) -> i16x8<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i16x8(self, a: i16x8<Self>) -> i16x8<Self>

Reverse the order of the vector’s elements.

fn slide_i16x8<const SHIFT: usize>( self, a: i16x8<Self>, b: i16x8<Self>, ) -> i16x8<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn count_ones_i16x8(self, a: i16x8<Self>) -> i16x8<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i16x8(self, a: i16x8<Self>) -> i16x8<Self>

Return the number of zeros in the binary representation of each element.

fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Compute the bitwise AND of two vectors.

fn or_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Compute the bitwise OR of two vectors.

fn xor_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Compute the bitwise XOR of two vectors.

fn not_i16x8(self, a: i16x8<Self>) -> i16x8<Self>

Compute the bitwise NOT of the vector.

fn shl_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self>

Shift each element left by the given number of bits.

fn shlv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Shift each element left by the given number of bits.

fn shr_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self>

Shift each element right by the given number of bits.

fn shrv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i16x8(self, a: i16x8<Self>) -> i16

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i16x8(self, a: i16x8<Self>) -> i16

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i16x8(self, a: i16x8<Self>) -> i16

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i16x8(self, a: i16x8<Self>) -> i16

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Return the element-wise maximum of two vectors.

fn min_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i16x8( self, a: i16x8<Self>, b: i16x8<Self>, ) -> (i16x8<Self>, i16x8<Self>)

Interleave two vectors.

fn deinterleave_i16x8( self, a: i16x8<Self>, b: i16x8<Self>, ) -> (i16x8<Self>, i16x8<Self>)

Deinterleave two vectors.

fn select_i16x8( self, a: mask16x8<Self>, b: i16x8<Self>, c: i16x8<Self>, ) -> i16x8<Self>

Select elements from b and c based on the mask operand a.

fn combine_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x16<Self>

Combine two vectors into a single vector with twice the width.

fn neg_i16x8(self, a: i16x8<Self>) -> i16x8<Self>

Negate each element of the vector, wrapping on overflow.

fn load_four_interleaved_i16x8(self, src: &[i16; 32]) -> [i16x8<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_i16x8( self, vectors: [i16x8<Self>; 4], dest: &mut [i16; 32], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn widen_i16x8(self, a: i16x8<Self>) -> (i32x4<Self>, i32x4<Self>)

Widen every lane into two same-width vectors.

fn narrow_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i8x16<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i8x16<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i8x16<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn splat_u16x8(self, val: u16) -> u16x8<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u16x8(self, a: u16x8<Self>) -> u16x8<Self>

Reverse the order of the vector’s elements.

fn slide_u16x8<const SHIFT: usize>( self, a: u16x8<Self>, b: u16x8<Self>, ) -> u16x8<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn count_ones_u16x8(self, a: u16x8<Self>) -> u16x8<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u16x8(self, a: u16x8<Self>) -> u16x8<Self>

Return the number of zeros in the binary representation of each element.

fn add_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Compute the bitwise AND of two vectors.

fn or_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Compute the bitwise OR of two vectors.

fn xor_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Compute the bitwise XOR of two vectors.

fn not_u16x8(self, a: u16x8<Self>) -> u16x8<Self>

Compute the bitwise NOT of the vector.

fn shl_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self>

Shift each element left by the given number of bits.

fn shlv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Shift each element left by the given number of bits.

fn shr_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self>

Shift each element right by the given number of bits.

fn shrv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u16x8(self, a: u16x8<Self>) -> u16

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u16x8(self, a: u16x8<Self>) -> u16

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u16x8(self, a: u16x8<Self>) -> u16

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u16x8(self, a: u16x8<Self>) -> u16

Return the product of all elements in the vector. Integer multiplication wraps.

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

Return the element-wise maximum of two vectors.

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

Return the element-wise minimum of two vectors.

fn simd_eq_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u16x8( self, a: u16x8<Self>, b: u16x8<Self>, ) -> (u16x8<Self>, u16x8<Self>)

Interleave two vectors.

fn deinterleave_u16x8( self, a: u16x8<Self>, b: u16x8<Self>, ) -> (u16x8<Self>, u16x8<Self>)

Deinterleave two vectors.

fn select_u16x8( self, a: mask16x8<Self>, b: u16x8<Self>, c: u16x8<Self>, ) -> u16x8<Self>

Select elements from b and c based on the mask operand a.

fn combine_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x16<Self>

Combine two vectors into a single vector with twice the width.

fn load_four_interleaved_u16x8(self, src: &[u16; 32]) -> [u16x8<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_u16x8( self, vectors: [u16x8<Self>; 4], dest: &mut [u16; 32], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn widen_u16x8(self, a: u16x8<Self>) -> (u32x4<Self>, u32x4<Self>)

Widen every lane into two same-width vectors.

fn narrow_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u8x16<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u8x16<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u8x16<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn splat_mask16x8(self, val: bool) -> mask16x8<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask16x8(self, bits: u64) -> mask16x8<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask16x8(self, a: mask16x8<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn set_mask16x8(self, a: &mut mask16x8<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask16x8<const OFFSET: usize>( self, a: mask16x8<Self>, ) -> mask16x8<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask16x8<const OFFSET: usize>( self, a: mask16x8<Self>, ) -> mask16x8<Self>

Rotate the mask elements to the right by OFFSET.

fn and_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>

Compute the logical AND of two masks.

fn or_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>

Compute the logical OR of two masks.

fn xor_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self>

Compute the logical XOR of two masks.

fn not_mask16x8(self, a: mask16x8<Self>) -> mask16x8<Self>

Compute the logical NOT of the mask.

fn reverse_mask16x8(self, a: mask16x8<Self>) -> mask16x8<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask16x8( self, a: mask16x8<Self>, b: mask16x8<Self>, c: mask16x8<Self>, ) -> mask16x8<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask16x8( self, a: mask16x8<Self>, b: mask16x8<Self>, ) -> mask16x8<Self>

Compare two vectors element-wise for equality.

fn any_true_mask16x8(self, a: mask16x8<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask16x8(self, a: mask16x8<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask16x8(self, a: mask16x8<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask16x8(self, a: mask16x8<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn combine_mask16x8( self, a: mask16x8<Self>, b: mask16x8<Self>, ) -> mask16x16<Self>

Combine two vectors into a single vector with twice the width.

fn abs_i32x4(self, a: i32x4<Self>) -> i32x4<Self>

Compute the absolute value of each element.

fn splat_i32x4(self, val: i32) -> i32x4<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i32x4(self, a: i32x4<Self>) -> i32x4<Self>

Reverse the order of the vector’s elements.

fn slide_i32x4<const SHIFT: usize>( self, a: i32x4<Self>, b: i32x4<Self>, ) -> i32x4<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn count_ones_i32x4(self, a: i32x4<Self>) -> i32x4<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i32x4(self, a: i32x4<Self>) -> i32x4<Self>

Return the number of zeros in the binary representation of each element.

fn add_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Compute the bitwise AND of two vectors.

fn or_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Compute the bitwise OR of two vectors.

fn xor_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Compute the bitwise XOR of two vectors.

fn not_i32x4(self, a: i32x4<Self>) -> i32x4<Self>

Compute the bitwise NOT of the vector.

fn shl_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self>

Shift each element left by the given number of bits.

fn shlv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Shift each element left by the given number of bits.

fn shr_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self>

Shift each element right by the given number of bits.

fn shrv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i32x4(self, a: i32x4<Self>) -> i32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i32x4(self, a: i32x4<Self>) -> i32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i32x4(self, a: i32x4<Self>) -> i32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i32x4(self, a: i32x4<Self>) -> i32

Return the product of all elements in the vector. Integer multiplication wraps.

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

Return the element-wise maximum of two vectors.

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

Return the element-wise minimum of two vectors.

fn simd_eq_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for less than.

fn simd_le_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i32x4( self, a: i32x4<Self>, b: i32x4<Self>, ) -> (i32x4<Self>, i32x4<Self>)

Interleave two vectors.

fn deinterleave_i32x4( self, a: i32x4<Self>, b: i32x4<Self>, ) -> (i32x4<Self>, i32x4<Self>)

Deinterleave two vectors.

fn select_i32x4( self, a: mask32x4<Self>, b: i32x4<Self>, c: i32x4<Self>, ) -> i32x4<Self>

Select elements from b and c based on the mask operand a.

fn combine_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x8<Self>

Combine two vectors into a single vector with twice the width.

fn neg_i32x4(self, a: i32x4<Self>) -> i32x4<Self>

Negate each element of the vector, wrapping on overflow.

fn load_four_interleaved_i32x4(self, src: &[i32; 16]) -> [i32x4<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_i32x4( self, vectors: [i32x4<Self>; 4], dest: &mut [i32; 16], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn widen_i32x4(self, a: i32x4<Self>) -> (i64x2<Self>, i64x2<Self>)

Widen every lane into two same-width vectors.

fn narrow_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i16x8<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i16x8<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i16x8<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f32_i32x4(self, a: i32x4<Self>) -> f32x4<Self>

Convert each signed 32-bit integer element to a floating-point value.

fn splat_u32x4(self, val: u32) -> u32x4<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u32x4(self, a: u32x4<Self>) -> u32x4<Self>

Reverse the order of the vector’s elements.

fn slide_u32x4<const SHIFT: usize>( self, a: u32x4<Self>, b: u32x4<Self>, ) -> u32x4<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn count_ones_u32x4(self, a: u32x4<Self>) -> u32x4<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u32x4(self, a: u32x4<Self>) -> u32x4<Self>

Return the number of zeros in the binary representation of each element.

fn add_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Compute the bitwise AND of two vectors.

fn or_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Compute the bitwise OR of two vectors.

fn xor_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Compute the bitwise XOR of two vectors.

fn not_u32x4(self, a: u32x4<Self>) -> u32x4<Self>

Compute the bitwise NOT of the vector.

fn shl_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self>

Shift each element left by the given number of bits.

fn shlv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Shift each element left by the given number of bits.

fn shr_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self>

Shift each element right by the given number of bits.

fn shrv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u32x4(self, a: u32x4<Self>) -> u32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u32x4(self, a: u32x4<Self>) -> u32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u32x4(self, a: u32x4<Self>) -> u32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u32x4(self, a: u32x4<Self>) -> u32

Return the product of all elements in the vector. Integer multiplication wraps.

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

Return the element-wise maximum of two vectors.

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

Return the element-wise minimum of two vectors.

fn simd_eq_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for less than.

fn simd_le_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u32x4( self, a: u32x4<Self>, b: u32x4<Self>, ) -> (u32x4<Self>, u32x4<Self>)

Interleave two vectors.

fn deinterleave_u32x4( self, a: u32x4<Self>, b: u32x4<Self>, ) -> (u32x4<Self>, u32x4<Self>)

Deinterleave two vectors.

fn select_u32x4( self, a: mask32x4<Self>, b: u32x4<Self>, c: u32x4<Self>, ) -> u32x4<Self>

Select elements from b and c based on the mask operand a.

fn combine_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x8<Self>

Combine two vectors into a single vector with twice the width.

fn load_four_interleaved_u32x4(self, src: &[u32; 16]) -> [u32x4<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_u32x4( self, vectors: [u32x4<Self>; 4], dest: &mut [u32; 16], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn widen_u32x4(self, a: u32x4<Self>) -> (u64x2<Self>, u64x2<Self>)

Widen every lane into two same-width vectors.

fn narrow_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u16x8<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u16x8<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u16x8<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f32_u32x4(self, a: u32x4<Self>) -> f32x4<Self>

Convert each unsigned 32-bit integer element to a floating-point value.

fn splat_mask32x4(self, val: bool) -> mask32x4<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask32x4(self, bits: u64) -> mask32x4<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask32x4(self, a: mask32x4<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn set_mask32x4(self, a: &mut mask32x4<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask32x4<const OFFSET: usize>( self, a: mask32x4<Self>, ) -> mask32x4<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask32x4<const OFFSET: usize>( self, a: mask32x4<Self>, ) -> mask32x4<Self>

Rotate the mask elements to the right by OFFSET.

fn and_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>

Compute the logical AND of two masks.

fn or_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>

Compute the logical OR of two masks.

fn xor_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self>

Compute the logical XOR of two masks.

fn not_mask32x4(self, a: mask32x4<Self>) -> mask32x4<Self>

Compute the logical NOT of the mask.

fn reverse_mask32x4(self, a: mask32x4<Self>) -> mask32x4<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask32x4( self, a: mask32x4<Self>, b: mask32x4<Self>, c: mask32x4<Self>, ) -> mask32x4<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask32x4( self, a: mask32x4<Self>, b: mask32x4<Self>, ) -> mask32x4<Self>

Compare two vectors element-wise for equality.

fn any_true_mask32x4(self, a: mask32x4<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask32x4(self, a: mask32x4<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask32x4(self, a: mask32x4<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask32x4(self, a: mask32x4<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn combine_mask32x4( self, a: mask32x4<Self>, b: mask32x4<Self>, ) -> mask32x8<Self>

Combine two vectors into a single vector with twice the width.

fn abs_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Compute the absolute value of each element.

fn splat_f64x2(self, val: f64) -> f64x2<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Reverse the order of the vector’s elements.

fn slide_f64x2<const SHIFT: usize>( self, a: f64x2<Self>, b: f64x2<Self>, ) -> f64x2<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn neg_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Negate each element of the vector.

fn sqrt_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Compute the square root of each element.

fn approximate_recip_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Compute an approximate reciprocal (1. / x) for each element.

fn add_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Add two vectors element-wise.

fn sub_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Subtract two vectors element-wise.

fn mul_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Multiply two vectors element-wise.

fn div_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Divide two vectors element-wise.

fn copysign_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Return a vector with the magnitude of a and the sign of b for each element.

fn reduce_max_f64x2(self, a: f64x2<Self>) -> f64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_f64x2(self, a: f64x2<Self>) -> f64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_max_precise_f64x2(self, a: f64x2<Self>) -> f64

Return the maximum element in the vector, ignoring quiet NaNs.

fn reduce_min_precise_f64x2(self, a: f64x2<Self>) -> f64

Return the minimum element in the vector, ignoring quiet NaNs.

fn reduce_sum_f64x2(self, a: f64x2<Self>) -> f64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_f64x2(self, a: f64x2<Self>) -> f64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Return the element-wise maximum of two vectors.

fn min_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Return the element-wise minimum of two vectors.

fn max_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Return the element-wise maximum of two vectors.

fn min_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for equality.

fn simd_lt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for less than.

fn simd_le_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Interleave the lower half elements of two vectors.

fn zip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self>

Extract odd-indexed elements from two vectors.

fn interleave_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, ) -> (f64x2<Self>, f64x2<Self>)

Interleave two vectors.

fn deinterleave_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, ) -> (f64x2<Self>, f64x2<Self>)

Deinterleave two vectors.

fn mul_add_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, c: f64x2<Self>, ) -> f64x2<Self>

Compute (a * b) + c (fused multiply-add) for each element.

fn mul_add_precise_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, c: f64x2<Self>, ) -> f64x2<Self>

Compute (a * b) + c for each element, with a single rounding at the end.

fn mul_sub_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, c: f64x2<Self>, ) -> f64x2<Self>

Compute (a * b) - c (fused multiply-subtract) for each element.

fn mul_sub_precise_f64x2( self, a: f64x2<Self>, b: f64x2<Self>, c: f64x2<Self>, ) -> f64x2<Self>

Compute (a * b) - c for each element, with a single rounding at the end.

fn floor_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Return the largest integer less than or equal to each element, that is, round towards negative infinity.

fn ceil_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.

fn round_ties_even_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Round each element to the nearest integer, with ties rounding to the nearest even integer.

fn fract_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Return the fractional part of each element.

fn trunc_f64x2(self, a: f64x2<Self>) -> f64x2<Self>

Return the integer part of each element, rounding towards zero.

fn select_f64x2( self, a: mask64x2<Self>, b: f64x2<Self>, c: f64x2<Self>, ) -> f64x2<Self>

Select elements from b and c based on the mask operand a.

fn combine_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x4<Self>

Combine two vectors into a single vector with twice the width.

fn load_four_interleaved_f64x2(self, src: &[f64; 8]) -> [f64x2<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_f64x2( self, vectors: [f64x2<Self>; 4], dest: &mut [f64; 8], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn narrow_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f32x4<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn saturating_narrow_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f32x4<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn relaxed_narrow_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f32x4<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn cvt_u64_f64x2(self, a: f64x2<Self>) -> u64x2<Self>

Convert each floating-point element to an unsigned 64-bit integer, truncating towards zero.

fn cvt_u64_precise_f64x2(self, a: f64x2<Self>) -> u64x2<Self>

Convert each floating-point element to an unsigned 64-bit integer, truncating towards zero.

fn cvt_i64_f64x2(self, a: f64x2<Self>) -> i64x2<Self>

Convert each floating-point element to a signed 64-bit integer, truncating towards zero.

fn cvt_i64_precise_f64x2(self, a: f64x2<Self>) -> i64x2<Self>

Convert each floating-point element to a signed 64-bit integer, truncating towards zero.

fn abs_i64x2(self, a: i64x2<Self>) -> i64x2<Self>

Compute the absolute value of each element.

fn splat_i64x2(self, val: i64) -> i64x2<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i64x2(self, a: i64x2<Self>) -> i64x2<Self>

Reverse the order of the vector’s elements.

fn slide_i64x2<const SHIFT: usize>( self, a: i64x2<Self>, b: i64x2<Self>, ) -> i64x2<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn count_ones_i64x2(self, a: i64x2<Self>) -> i64x2<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i64x2(self, a: i64x2<Self>) -> i64x2<Self>

Return the number of zeros in the binary representation of each element.

fn add_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Compute the bitwise AND of two vectors.

fn or_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Compute the bitwise OR of two vectors.

fn xor_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Compute the bitwise XOR of two vectors.

fn not_i64x2(self, a: i64x2<Self>) -> i64x2<Self>

Compute the bitwise NOT of the vector.

fn shl_i64x2(self, a: i64x2<Self>, shift: u32) -> i64x2<Self>

Shift each element left by the given number of bits.

fn shlv_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Shift each element left by the given number of bits.

fn shr_i64x2(self, a: i64x2<Self>, shift: u32) -> i64x2<Self>

Shift each element right by the given number of bits.

fn shrv_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i64x2(self, a: i64x2<Self>) -> i64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i64x2(self, a: i64x2<Self>) -> i64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i64x2(self, a: i64x2<Self>) -> i64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i64x2(self, a: i64x2<Self>) -> i64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Return the element-wise maximum of two vectors.

fn min_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for less than.

fn simd_le_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i64x2( self, a: i64x2<Self>, b: i64x2<Self>, ) -> (i64x2<Self>, i64x2<Self>)

Interleave two vectors.

fn deinterleave_i64x2( self, a: i64x2<Self>, b: i64x2<Self>, ) -> (i64x2<Self>, i64x2<Self>)

Deinterleave two vectors.

fn select_i64x2( self, a: mask64x2<Self>, b: i64x2<Self>, c: i64x2<Self>, ) -> i64x2<Self>

Select elements from b and c based on the mask operand a.

fn combine_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x4<Self>

Combine two vectors into a single vector with twice the width.

fn neg_i64x2(self, a: i64x2<Self>) -> i64x2<Self>

Negate each element of the vector, wrapping on overflow.

fn load_four_interleaved_i64x2(self, src: &[i64; 8]) -> [i64x2<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_i64x2( self, vectors: [i64x2<Self>; 4], dest: &mut [i64; 8], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn narrow_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i32x4<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i32x4<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i32x4<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f64_i64x2(self, a: i64x2<Self>) -> f64x2<Self>

Convert each signed 64-bit integer element to a floating-point value.

fn splat_u64x2(self, val: u64) -> u64x2<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u64x2(self, a: u64x2<Self>) -> u64x2<Self>

Reverse the order of the vector’s elements.

fn slide_u64x2<const SHIFT: usize>( self, a: u64x2<Self>, b: u64x2<Self>, ) -> u64x2<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn count_ones_u64x2(self, a: u64x2<Self>) -> u64x2<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u64x2(self, a: u64x2<Self>) -> u64x2<Self>

Return the number of zeros in the binary representation of each element.

fn add_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Compute the bitwise AND of two vectors.

fn or_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Compute the bitwise OR of two vectors.

fn xor_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Compute the bitwise XOR of two vectors.

fn not_u64x2(self, a: u64x2<Self>) -> u64x2<Self>

Compute the bitwise NOT of the vector.

fn shl_u64x2(self, a: u64x2<Self>, shift: u32) -> u64x2<Self>

Shift each element left by the given number of bits.

fn shlv_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Shift each element left by the given number of bits.

fn shr_u64x2(self, a: u64x2<Self>, shift: u32) -> u64x2<Self>

Shift each element right by the given number of bits.

fn shrv_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u64x2(self, a: u64x2<Self>) -> u64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u64x2(self, a: u64x2<Self>) -> u64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u64x2(self, a: u64x2<Self>) -> u64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u64x2(self, a: u64x2<Self>) -> u64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Return the element-wise maximum of two vectors.

fn min_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for less than.

fn simd_le_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for less than or equal.

fn zip_low_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u64x2( self, a: u64x2<Self>, b: u64x2<Self>, ) -> (u64x2<Self>, u64x2<Self>)

Interleave two vectors.

fn deinterleave_u64x2( self, a: u64x2<Self>, b: u64x2<Self>, ) -> (u64x2<Self>, u64x2<Self>)

Deinterleave two vectors.

fn select_u64x2( self, a: mask64x2<Self>, b: u64x2<Self>, c: u64x2<Self>, ) -> u64x2<Self>

Select elements from b and c based on the mask operand a.

fn combine_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x4<Self>

Combine two vectors into a single vector with twice the width.

fn load_four_interleaved_u64x2(self, src: &[u64; 8]) -> [u64x2<Self>; 4]

Load four 128-bit vectors from an array with 4-way interleaving.

fn store_four_interleaved_u64x2( self, vectors: [u64x2<Self>; 4], dest: &mut [u64; 8], )

Store four 128-bit vectors to an array with 4-way interleaving.

fn narrow_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u32x4<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u32x4<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u32x4<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f64_u64x2(self, a: u64x2<Self>) -> f64x2<Self>

Convert each unsigned 64-bit integer element to a floating-point value.

fn splat_mask64x2(self, val: bool) -> mask64x2<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask64x2(self, bits: u64) -> mask64x2<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask64x2(self, a: mask64x2<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn set_mask64x2(self, a: &mut mask64x2<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask64x2<const OFFSET: usize>( self, a: mask64x2<Self>, ) -> mask64x2<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask64x2<const OFFSET: usize>( self, a: mask64x2<Self>, ) -> mask64x2<Self>

Rotate the mask elements to the right by OFFSET.

fn and_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>

Compute the logical AND of two masks.

fn or_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>

Compute the logical OR of two masks.

fn xor_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self>

Compute the logical XOR of two masks.

fn not_mask64x2(self, a: mask64x2<Self>) -> mask64x2<Self>

Compute the logical NOT of the mask.

fn reverse_mask64x2(self, a: mask64x2<Self>) -> mask64x2<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask64x2( self, a: mask64x2<Self>, b: mask64x2<Self>, c: mask64x2<Self>, ) -> mask64x2<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask64x2( self, a: mask64x2<Self>, b: mask64x2<Self>, ) -> mask64x2<Self>

Compare two vectors element-wise for equality.

fn any_true_mask64x2(self, a: mask64x2<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask64x2(self, a: mask64x2<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask64x2(self, a: mask64x2<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask64x2(self, a: mask64x2<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn combine_mask64x2( self, a: mask64x2<Self>, b: mask64x2<Self>, ) -> mask64x4<Self>

Combine two vectors into a single vector with twice the width.

fn slide_f32x8<const SHIFT: usize>( self, a: f32x8<Self>, b: f32x8<Self>, ) -> f32x8<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x16<Self>

Combine two vectors into a single vector with twice the width.

fn split_f32x8(self, a: f32x8<Self>) -> (f32x4<Self>, f32x4<Self>)

Split a vector into two vectors of half the width.

fn slide_i8x32<const SHIFT: usize>( self, a: i8x32<Self>, b: i8x32<Self>, ) -> i8x32<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x64<Self>

Combine two vectors into a single vector with twice the width.

fn split_i8x32(self, a: i8x32<Self>) -> (i8x16<Self>, i8x16<Self>)

Split a vector into two vectors of half the width.

fn slide_u8x32<const SHIFT: usize>( self, a: u8x32<Self>, b: u8x32<Self>, ) -> u8x32<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u8x32( self, a: u8x32<Self>, indices: u8x32<Self>, ) -> u8x32<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn combine_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x64<Self>

Combine two vectors into a single vector with twice the width.

fn split_u8x32(self, a: u8x32<Self>) -> (u8x16<Self>, u8x16<Self>)

Split a vector into two vectors of half the width.

fn set_mask8x32(self, a: &mut mask8x32<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask8x32<const OFFSET: usize>( self, a: mask8x32<Self>, ) -> mask8x32<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask8x32<const OFFSET: usize>( self, a: mask8x32<Self>, ) -> mask8x32<Self>

Rotate the mask elements to the right by OFFSET.

fn combine_mask8x32( self, a: mask8x32<Self>, b: mask8x32<Self>, ) -> mask8x64<Self>

Combine two vectors into a single vector with twice the width.

fn split_mask8x32(self, a: mask8x32<Self>) -> (mask8x16<Self>, mask8x16<Self>)

Split a vector into two vectors of half the width.

fn slide_i16x16<const SHIFT: usize>( self, a: i16x16<Self>, b: i16x16<Self>, ) -> i16x16<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x32<Self>

Combine two vectors into a single vector with twice the width.

fn split_i16x16(self, a: i16x16<Self>) -> (i16x8<Self>, i16x8<Self>)

Split a vector into two vectors of half the width.

fn slide_u16x16<const SHIFT: usize>( self, a: u16x16<Self>, b: u16x16<Self>, ) -> u16x16<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x32<Self>

Combine two vectors into a single vector with twice the width.

fn split_u16x16(self, a: u16x16<Self>) -> (u16x8<Self>, u16x8<Self>)

Split a vector into two vectors of half the width.

fn set_mask16x16(self, a: &mut mask16x16<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask16x16<const OFFSET: usize>( self, a: mask16x16<Self>, ) -> mask16x16<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask16x16<const OFFSET: usize>( self, a: mask16x16<Self>, ) -> mask16x16<Self>

Rotate the mask elements to the right by OFFSET.

fn combine_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x32<Self>

Combine two vectors into a single vector with twice the width.

fn split_mask16x16(self, a: mask16x16<Self>) -> (mask16x8<Self>, mask16x8<Self>)

Split a vector into two vectors of half the width.

fn slide_i32x8<const SHIFT: usize>( self, a: i32x8<Self>, b: i32x8<Self>, ) -> i32x8<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x16<Self>

Combine two vectors into a single vector with twice the width.

fn split_i32x8(self, a: i32x8<Self>) -> (i32x4<Self>, i32x4<Self>)

Split a vector into two vectors of half the width.

fn slide_u32x8<const SHIFT: usize>( self, a: u32x8<Self>, b: u32x8<Self>, ) -> u32x8<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x16<Self>

Combine two vectors into a single vector with twice the width.

fn split_u32x8(self, a: u32x8<Self>) -> (u32x4<Self>, u32x4<Self>)

Split a vector into two vectors of half the width.

fn set_mask32x8(self, a: &mut mask32x8<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask32x8<const OFFSET: usize>( self, a: mask32x8<Self>, ) -> mask32x8<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask32x8<const OFFSET: usize>( self, a: mask32x8<Self>, ) -> mask32x8<Self>

Rotate the mask elements to the right by OFFSET.

fn combine_mask32x8( self, a: mask32x8<Self>, b: mask32x8<Self>, ) -> mask32x16<Self>

Combine two vectors into a single vector with twice the width.

fn split_mask32x8(self, a: mask32x8<Self>) -> (mask32x4<Self>, mask32x4<Self>)

Split a vector into two vectors of half the width.

fn slide_f64x4<const SHIFT: usize>( self, a: f64x4<Self>, b: f64x4<Self>, ) -> f64x4<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x8<Self>

Combine two vectors into a single vector with twice the width.

fn split_f64x4(self, a: f64x4<Self>) -> (f64x2<Self>, f64x2<Self>)

Split a vector into two vectors of half the width.

fn slide_i64x4<const SHIFT: usize>( self, a: i64x4<Self>, b: i64x4<Self>, ) -> i64x4<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x8<Self>

Combine two vectors into a single vector with twice the width.

fn split_i64x4(self, a: i64x4<Self>) -> (i64x2<Self>, i64x2<Self>)

Split a vector into two vectors of half the width.

fn slide_u64x4<const SHIFT: usize>( self, a: u64x4<Self>, b: u64x4<Self>, ) -> u64x4<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn combine_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x8<Self>

Combine two vectors into a single vector with twice the width.

fn split_u64x4(self, a: u64x4<Self>) -> (u64x2<Self>, u64x2<Self>)

Split a vector into two vectors of half the width.

fn set_mask64x4(self, a: &mut mask64x4<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask64x4<const OFFSET: usize>( self, a: mask64x4<Self>, ) -> mask64x4<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask64x4<const OFFSET: usize>( self, a: mask64x4<Self>, ) -> mask64x4<Self>

Rotate the mask elements to the right by OFFSET.

fn combine_mask64x4( self, a: mask64x4<Self>, b: mask64x4<Self>, ) -> mask64x8<Self>

Combine two vectors into a single vector with twice the width.

fn split_mask64x4(self, a: mask64x4<Self>) -> (mask64x2<Self>, mask64x2<Self>)

Split a vector into two vectors of half the width.

fn slide_f32x16<const SHIFT: usize>( self, a: f32x16<Self>, b: f32x16<Self>, ) -> f32x16<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_f32x16(self, a: f32x16<Self>) -> (f32x8<Self>, f32x8<Self>)

Split a vector into two vectors of half the width.

fn slide_i8x64<const SHIFT: usize>( self, a: i8x64<Self>, b: i8x64<Self>, ) -> i8x64<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_i8x64(self, a: i8x64<Self>) -> (i8x32<Self>, i8x32<Self>)

Split a vector into two vectors of half the width.

fn slide_u8x64<const SHIFT: usize>( self, a: u8x64<Self>, b: u8x64<Self>, ) -> u8x64<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u8x64( self, a: u8x64<Self>, indices: u8x64<Self>, ) -> u8x64<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn split_u8x64(self, a: u8x64<Self>) -> (u8x32<Self>, u8x32<Self>)

Split a vector into two vectors of half the width.

fn set_mask8x64(self, a: &mut mask8x64<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask8x64<const OFFSET: usize>( self, a: mask8x64<Self>, ) -> mask8x64<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask8x64<const OFFSET: usize>( self, a: mask8x64<Self>, ) -> mask8x64<Self>

Rotate the mask elements to the right by OFFSET.

fn split_mask8x64(self, a: mask8x64<Self>) -> (mask8x32<Self>, mask8x32<Self>)

Split a vector into two vectors of half the width.

fn slide_i16x32<const SHIFT: usize>( self, a: i16x32<Self>, b: i16x32<Self>, ) -> i16x32<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_i16x32(self, a: i16x32<Self>) -> (i16x16<Self>, i16x16<Self>)

Split a vector into two vectors of half the width.

fn slide_u16x32<const SHIFT: usize>( self, a: u16x32<Self>, b: u16x32<Self>, ) -> u16x32<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_u16x32(self, a: u16x32<Self>) -> (u16x16<Self>, u16x16<Self>)

Split a vector into two vectors of half the width.

fn set_mask16x32(self, a: &mut mask16x32<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask16x32<const OFFSET: usize>( self, a: mask16x32<Self>, ) -> mask16x32<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask16x32<const OFFSET: usize>( self, a: mask16x32<Self>, ) -> mask16x32<Self>

Rotate the mask elements to the right by OFFSET.

fn split_mask16x32( self, a: mask16x32<Self>, ) -> (mask16x16<Self>, mask16x16<Self>)

Split a vector into two vectors of half the width.

fn slide_i32x16<const SHIFT: usize>( self, a: i32x16<Self>, b: i32x16<Self>, ) -> i32x16<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_i32x16(self, a: i32x16<Self>) -> (i32x8<Self>, i32x8<Self>)

Split a vector into two vectors of half the width.

fn slide_u32x16<const SHIFT: usize>( self, a: u32x16<Self>, b: u32x16<Self>, ) -> u32x16<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_u32x16(self, a: u32x16<Self>) -> (u32x8<Self>, u32x8<Self>)

Split a vector into two vectors of half the width.

fn set_mask32x16(self, a: &mut mask32x16<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask32x16<const OFFSET: usize>( self, a: mask32x16<Self>, ) -> mask32x16<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask32x16<const OFFSET: usize>( self, a: mask32x16<Self>, ) -> mask32x16<Self>

Rotate the mask elements to the right by OFFSET.

fn split_mask32x16(self, a: mask32x16<Self>) -> (mask32x8<Self>, mask32x8<Self>)

Split a vector into two vectors of half the width.

fn slide_f64x8<const SHIFT: usize>( self, a: f64x8<Self>, b: f64x8<Self>, ) -> f64x8<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_f64x8(self, a: f64x8<Self>) -> (f64x4<Self>, f64x4<Self>)

Split a vector into two vectors of half the width.

fn slide_i64x8<const SHIFT: usize>( self, a: i64x8<Self>, b: i64x8<Self>, ) -> i64x8<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_i64x8(self, a: i64x8<Self>) -> (i64x4<Self>, i64x4<Self>)

Split a vector into two vectors of half the width.

fn slide_u64x8<const SHIFT: usize>( self, a: u64x8<Self>, b: u64x8<Self>, ) -> u64x8<Self>

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn split_u64x8(self, a: u64x8<Self>) -> (u64x4<Self>, u64x4<Self>)

Split a vector into two vectors of half the width.

fn set_mask64x8(self, a: &mut mask64x8<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

fn rotate_elements_left_mask64x8<const OFFSET: usize>( self, a: mask64x8<Self>, ) -> mask64x8<Self>

Rotate the mask elements to the left by OFFSET.

fn rotate_elements_right_mask64x8<const OFFSET: usize>( self, a: mask64x8<Self>, ) -> mask64x8<Self>

Rotate the mask elements to the right by OFFSET.

fn split_mask64x8(self, a: mask64x8<Self>) -> (mask64x4<Self>, mask64x4<Self>)

Split a vector into two vectors of half the width.

fn slide_within_blocks_f32x4<const SHIFT: usize>( self, a: f32x4<Self>, b: f32x4<Self>, ) -> f32x4<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_f32x4( self, a: f32x4<Self>, indices: u8x16<Self>, ) -> f32x4<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_f32x4( self, a: f32x4<Self>, indices: u8x16<Self>, ) -> f32x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for greater than.

fn slide_within_blocks_i8x16<const SHIFT: usize>( self, a: i8x16<Self>, b: i8x16<Self>, ) -> i8x16<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i8x16( self, a: i8x16<Self>, indices: u8x16<Self>, ) -> i8x16<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i8x16( self, a: i8x16<Self>, indices: u8x16<Self>, ) -> i8x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for greater than.

fn abs_u8x16(self, a: u8x16<Self>) -> u8x16<Self>

Compute the absolute value of each element.

fn slide_within_blocks_u8x16<const SHIFT: usize>( self, a: u8x16<Self>, b: u8x16<Self>, ) -> u8x16<Self>

Like slide, but operates independently on each 128-bit block.

fn simd_ge_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self>

Compare two vectors element-wise for greater than.

fn slide_within_blocks_i16x8<const SHIFT: usize>( self, a: i16x8<Self>, b: i16x8<Self>, ) -> i16x8<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i16x8( self, a: i16x8<Self>, indices: u8x16<Self>, ) -> i16x8<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i16x8( self, a: i16x8<Self>, indices: u8x16<Self>, ) -> i16x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for greater than.

fn abs_u16x8(self, a: u16x8<Self>) -> u16x8<Self>

Compute the absolute value of each element.

fn slide_within_blocks_u16x8<const SHIFT: usize>( self, a: u16x8<Self>, b: u16x8<Self>, ) -> u16x8<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u16x8( self, a: u16x8<Self>, indices: u8x16<Self>, ) -> u16x8<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u16x8( self, a: u16x8<Self>, indices: u8x16<Self>, ) -> u16x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self>

Compare two vectors element-wise for greater than.

fn slide_within_blocks_i32x4<const SHIFT: usize>( self, a: i32x4<Self>, b: i32x4<Self>, ) -> i32x4<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i32x4( self, a: i32x4<Self>, indices: u8x16<Self>, ) -> i32x4<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i32x4( self, a: i32x4<Self>, indices: u8x16<Self>, ) -> i32x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for greater than.

fn abs_u32x4(self, a: u32x4<Self>) -> u32x4<Self>

Compute the absolute value of each element.

fn slide_within_blocks_u32x4<const SHIFT: usize>( self, a: u32x4<Self>, b: u32x4<Self>, ) -> u32x4<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u32x4( self, a: u32x4<Self>, indices: u8x16<Self>, ) -> u32x4<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u32x4( self, a: u32x4<Self>, indices: u8x16<Self>, ) -> u32x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self>

Compare two vectors element-wise for greater than.

fn slide_within_blocks_f64x2<const SHIFT: usize>( self, a: f64x2<Self>, b: f64x2<Self>, ) -> f64x2<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_f64x2( self, a: f64x2<Self>, indices: u8x16<Self>, ) -> f64x2<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_f64x2( self, a: f64x2<Self>, indices: u8x16<Self>, ) -> f64x2<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for greater than.

fn slide_within_blocks_i64x2<const SHIFT: usize>( self, a: i64x2<Self>, b: i64x2<Self>, ) -> i64x2<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i64x2( self, a: i64x2<Self>, indices: u8x16<Self>, ) -> i64x2<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i64x2( self, a: i64x2<Self>, indices: u8x16<Self>, ) -> i64x2<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for greater than.

fn abs_u64x2(self, a: u64x2<Self>) -> u64x2<Self>

Compute the absolute value of each element.

fn slide_within_blocks_u64x2<const SHIFT: usize>( self, a: u64x2<Self>, b: u64x2<Self>, ) -> u64x2<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u64x2( self, a: u64x2<Self>, indices: u8x16<Self>, ) -> u64x2<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u64x2( self, a: u64x2<Self>, indices: u8x16<Self>, ) -> u64x2<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn simd_ge_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> mask64x2<Self>

Compare two vectors element-wise for greater than.

fn abs_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Compute the absolute value of each element.

fn splat_f32x8(self, val: f32) -> f32x8<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_f32x8<const SHIFT: usize>( self, a: f32x8<Self>, b: f32x8<Self>, ) -> f32x8<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_f32x8( self, a: f32x8<Self>, indices: u8x32<Self>, ) -> f32x8<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_f32x8( self, a: f32x8<Self>, indices: u8x32<Self>, ) -> f32x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn neg_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Negate each element of the vector.

fn sqrt_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Compute the square root of each element.

fn approximate_recip_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Compute an approximate reciprocal (1. / x) for each element.

fn add_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Add two vectors element-wise.

fn sub_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Subtract two vectors element-wise.

fn mul_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Multiply two vectors element-wise.

fn div_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Divide two vectors element-wise.

fn copysign_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Return a vector with the magnitude of a and the sign of b for each element.

fn reduce_max_f32x8(self, a: f32x8<Self>) -> f32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_f32x8(self, a: f32x8<Self>) -> f32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_max_precise_f32x8(self, a: f32x8<Self>) -> f32

Return the maximum element in the vector, ignoring quiet NaNs.

fn reduce_min_precise_f32x8(self, a: f32x8<Self>) -> f32

Return the minimum element in the vector, ignoring quiet NaNs.

fn reduce_sum_f32x8(self, a: f32x8<Self>) -> f32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_f32x8(self, a: f32x8<Self>) -> f32

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Return the element-wise maximum of two vectors.

fn min_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Return the element-wise minimum of two vectors.

fn max_precise_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Return the element-wise maximum of two vectors.

fn min_precise_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for equality.

fn simd_lt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for greater than.

fn zip_low_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Interleave the lower half elements of two vectors.

fn zip_high_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self>

Extract odd-indexed elements from two vectors.

fn interleave_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, ) -> (f32x8<Self>, f32x8<Self>)

Interleave two vectors.

fn deinterleave_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, ) -> (f32x8<Self>, f32x8<Self>)

Deinterleave two vectors.

fn mul_add_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, c: f32x8<Self>, ) -> f32x8<Self>

Compute (a * b) + c (fused multiply-add) for each element.

fn mul_add_precise_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, c: f32x8<Self>, ) -> f32x8<Self>

Compute (a * b) + c for each element, with a single rounding at the end.

fn mul_sub_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, c: f32x8<Self>, ) -> f32x8<Self>

Compute (a * b) - c (fused multiply-subtract) for each element.

fn mul_sub_precise_f32x8( self, a: f32x8<Self>, b: f32x8<Self>, c: f32x8<Self>, ) -> f32x8<Self>

Compute (a * b) - c for each element, with a single rounding at the end.

fn floor_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Return the largest integer less than or equal to each element, that is, round towards negative infinity.

fn ceil_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.

fn round_ties_even_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Round each element to the nearest integer, with ties rounding to the nearest even integer.

fn fract_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Return the fractional part of each element.

fn trunc_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Return the integer part of each element, rounding towards zero.

fn select_f32x8( self, a: mask32x8<Self>, b: f32x8<Self>, c: f32x8<Self>, ) -> f32x8<Self>

Select elements from b and c based on the mask operand a.

fn widen_f32x8(self, a: f32x8<Self>) -> (f64x4<Self>, f64x4<Self>)

Widen every f32 lane exactly into two same-width f64 vectors.

fn cvt_u32_f32x8(self, a: f32x8<Self>) -> u32x8<Self>

Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.

fn cvt_u32_precise_f32x8(self, a: f32x8<Self>) -> u32x8<Self>

Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.

fn cvt_i32_f32x8(self, a: f32x8<Self>) -> i32x8<Self>

Convert each floating-point element to a signed 32-bit integer, truncating towards zero.

fn cvt_i32_precise_f32x8(self, a: f32x8<Self>) -> i32x8<Self>

Convert each floating-point element to a signed 32-bit integer, truncating towards zero.

fn abs_i8x32(self, a: i8x32<Self>) -> i8x32<Self>

Compute the absolute value of each element.

fn splat_i8x32(self, val: i8) -> i8x32<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i8x32(self, a: i8x32<Self>) -> i8x32<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_i8x32<const SHIFT: usize>( self, a: i8x32<Self>, b: i8x32<Self>, ) -> i8x32<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i8x32( self, a: i8x32<Self>, indices: u8x32<Self>, ) -> i8x32<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i8x32( self, a: i8x32<Self>, indices: u8x32<Self>, ) -> i8x32<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_i8x32(self, a: i8x32<Self>) -> i8x32<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i8x32(self, a: i8x32<Self>) -> i8x32<Self>

Return the number of zeros in the binary representation of each element.

fn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Compute the bitwise AND of two vectors.

fn or_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Compute the bitwise OR of two vectors.

fn xor_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Compute the bitwise XOR of two vectors.

fn not_i8x32(self, a: i8x32<Self>) -> i8x32<Self>

Compute the bitwise NOT of the vector.

fn shl_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self>

Shift each element left by the given number of bits.

fn shlv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Shift each element left by the given number of bits.

fn shr_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self>

Shift each element right by the given number of bits.

fn shrv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i8x32(self, a: i8x32<Self>) -> i8

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i8x32(self, a: i8x32<Self>) -> i8

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i8x32(self, a: i8x32<Self>) -> i8

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i8x32(self, a: i8x32<Self>) -> i8

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Return the element-wise maximum of two vectors.

fn min_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for less than.

fn simd_le_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for greater than.

fn zip_low_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i8x32( self, a: i8x32<Self>, b: i8x32<Self>, ) -> (i8x32<Self>, i8x32<Self>)

Interleave two vectors.

fn deinterleave_i8x32( self, a: i8x32<Self>, b: i8x32<Self>, ) -> (i8x32<Self>, i8x32<Self>)

Deinterleave two vectors.

fn select_i8x32( self, a: mask8x32<Self>, b: i8x32<Self>, c: i8x32<Self>, ) -> i8x32<Self>

Select elements from b and c based on the mask operand a.

fn neg_i8x32(self, a: i8x32<Self>) -> i8x32<Self>

Negate each element of the vector, wrapping on overflow.

fn widen_i8x32(self, a: i8x32<Self>) -> (i16x16<Self>, i16x16<Self>)

Widen every lane into two same-width vectors.

fn abs_u8x32(self, a: u8x32<Self>) -> u8x32<Self>

Compute the absolute value of each element.

fn splat_u8x32(self, val: u8) -> u8x32<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u8x32(self, a: u8x32<Self>) -> u8x32<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_u8x32<const SHIFT: usize>( self, a: u8x32<Self>, b: u8x32<Self>, ) -> u8x32<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u8x32( self, a: u8x32<Self>, indices: u8x32<Self>, ) -> u8x32<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn count_ones_u8x32(self, a: u8x32<Self>) -> u8x32<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u8x32(self, a: u8x32<Self>) -> u8x32<Self>

Return the number of zeros in the binary representation of each element.

fn add_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Compute the bitwise AND of two vectors.

fn or_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Compute the bitwise OR of two vectors.

fn xor_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Compute the bitwise XOR of two vectors.

fn not_u8x32(self, a: u8x32<Self>) -> u8x32<Self>

Compute the bitwise NOT of the vector.

fn shl_u8x32(self, a: u8x32<Self>, shift: u32) -> u8x32<Self>

Shift each element left by the given number of bits.

fn shlv_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Shift each element left by the given number of bits.

fn shr_u8x32(self, a: u8x32<Self>, shift: u32) -> u8x32<Self>

Shift each element right by the given number of bits.

fn shrv_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u8x32(self, a: u8x32<Self>) -> u8

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u8x32(self, a: u8x32<Self>) -> u8

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u8x32(self, a: u8x32<Self>) -> u8

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u8x32(self, a: u8x32<Self>) -> u8

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Return the element-wise maximum of two vectors.

fn min_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for less than.

fn simd_le_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> mask8x32<Self>

Compare two vectors element-wise for greater than.

fn zip_low_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u8x32( self, a: u8x32<Self>, b: u8x32<Self>, ) -> (u8x32<Self>, u8x32<Self>)

Interleave two vectors.

fn deinterleave_u8x32( self, a: u8x32<Self>, b: u8x32<Self>, ) -> (u8x32<Self>, u8x32<Self>)

Deinterleave two vectors.

fn select_u8x32( self, a: mask8x32<Self>, b: u8x32<Self>, c: u8x32<Self>, ) -> u8x32<Self>

Select elements from b and c based on the mask operand a.

fn widen_u8x32(self, a: u8x32<Self>) -> (u16x16<Self>, u16x16<Self>)

Widen every lane into two same-width vectors.

fn splat_mask8x32(self, val: bool) -> mask8x32<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask8x32(self, bits: u64) -> mask8x32<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask8x32(self, a: mask8x32<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn and_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>

Compute the logical AND of two masks.

fn or_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>

Compute the logical OR of two masks.

fn xor_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x32<Self>

Compute the logical XOR of two masks.

fn not_mask8x32(self, a: mask8x32<Self>) -> mask8x32<Self>

Compute the logical NOT of the mask.

fn reverse_mask8x32(self, a: mask8x32<Self>) -> mask8x32<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask8x32( self, a: mask8x32<Self>, b: mask8x32<Self>, c: mask8x32<Self>, ) -> mask8x32<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask8x32( self, a: mask8x32<Self>, b: mask8x32<Self>, ) -> mask8x32<Self>

Compare two vectors element-wise for equality.

fn any_true_mask8x32(self, a: mask8x32<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask8x32(self, a: mask8x32<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask8x32(self, a: mask8x32<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask8x32(self, a: mask8x32<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn abs_i16x16(self, a: i16x16<Self>) -> i16x16<Self>

Compute the absolute value of each element.

fn splat_i16x16(self, val: i16) -> i16x16<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i16x16(self, a: i16x16<Self>) -> i16x16<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_i16x16<const SHIFT: usize>( self, a: i16x16<Self>, b: i16x16<Self>, ) -> i16x16<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i16x16( self, a: i16x16<Self>, indices: u8x32<Self>, ) -> i16x16<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i16x16( self, a: i16x16<Self>, indices: u8x32<Self>, ) -> i16x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i16x16( self, a: i16x16<Self>, indices: u8x32<Self>, ) -> i16x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_i16x16(self, a: i16x16<Self>) -> i16x16<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i16x16(self, a: i16x16<Self>) -> i16x16<Self>

Return the number of zeros in the binary representation of each element.

fn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Compute the bitwise AND of two vectors.

fn or_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Compute the bitwise OR of two vectors.

fn xor_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Compute the bitwise XOR of two vectors.

fn not_i16x16(self, a: i16x16<Self>) -> i16x16<Self>

Compute the bitwise NOT of the vector.

fn shl_i16x16(self, a: i16x16<Self>, shift: u32) -> i16x16<Self>

Shift each element left by the given number of bits.

fn shlv_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Shift each element left by the given number of bits.

fn shr_i16x16(self, a: i16x16<Self>, shift: u32) -> i16x16<Self>

Shift each element right by the given number of bits.

fn shrv_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i16x16(self, a: i16x16<Self>) -> i16

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i16x16(self, a: i16x16<Self>) -> i16

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i16x16(self, a: i16x16<Self>) -> i16

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i16x16(self, a: i16x16<Self>) -> i16

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Return the element-wise maximum of two vectors.

fn min_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for less than.

fn simd_le_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for greater than.

fn zip_low_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i16x16( self, a: i16x16<Self>, b: i16x16<Self>, ) -> (i16x16<Self>, i16x16<Self>)

Interleave two vectors.

fn deinterleave_i16x16( self, a: i16x16<Self>, b: i16x16<Self>, ) -> (i16x16<Self>, i16x16<Self>)

Deinterleave two vectors.

fn select_i16x16( self, a: mask16x16<Self>, b: i16x16<Self>, c: i16x16<Self>, ) -> i16x16<Self>

Select elements from b and c based on the mask operand a.

fn neg_i16x16(self, a: i16x16<Self>) -> i16x16<Self>

Negate each element of the vector, wrapping on overflow.

fn widen_i16x16(self, a: i16x16<Self>) -> (i32x8<Self>, i32x8<Self>)

Widen every lane into two same-width vectors.

fn narrow_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i8x32<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i16x16( self, a: i16x16<Self>, b: i16x16<Self>, ) -> i8x32<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i8x32<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn abs_u16x16(self, a: u16x16<Self>) -> u16x16<Self>

Compute the absolute value of each element.

fn splat_u16x16(self, val: u16) -> u16x16<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u16x16(self, a: u16x16<Self>) -> u16x16<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_u16x16<const SHIFT: usize>( self, a: u16x16<Self>, b: u16x16<Self>, ) -> u16x16<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u16x16( self, a: u16x16<Self>, indices: u8x32<Self>, ) -> u16x16<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u16x16( self, a: u16x16<Self>, indices: u8x32<Self>, ) -> u16x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u16x16( self, a: u16x16<Self>, indices: u8x32<Self>, ) -> u16x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_u16x16(self, a: u16x16<Self>) -> u16x16<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u16x16(self, a: u16x16<Self>) -> u16x16<Self>

Return the number of zeros in the binary representation of each element.

fn add_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Compute the bitwise AND of two vectors.

fn or_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Compute the bitwise OR of two vectors.

fn xor_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Compute the bitwise XOR of two vectors.

fn not_u16x16(self, a: u16x16<Self>) -> u16x16<Self>

Compute the bitwise NOT of the vector.

fn shl_u16x16(self, a: u16x16<Self>, shift: u32) -> u16x16<Self>

Shift each element left by the given number of bits.

fn shlv_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Shift each element left by the given number of bits.

fn shr_u16x16(self, a: u16x16<Self>, shift: u32) -> u16x16<Self>

Shift each element right by the given number of bits.

fn shrv_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u16x16(self, a: u16x16<Self>) -> u16

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u16x16(self, a: u16x16<Self>) -> u16

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u16x16(self, a: u16x16<Self>) -> u16

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u16x16(self, a: u16x16<Self>) -> u16

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Return the element-wise maximum of two vectors.

fn min_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for less than.

fn simd_le_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> mask16x16<Self>

Compare two vectors element-wise for greater than.

fn zip_low_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u16x16( self, a: u16x16<Self>, b: u16x16<Self>, ) -> (u16x16<Self>, u16x16<Self>)

Interleave two vectors.

fn deinterleave_u16x16( self, a: u16x16<Self>, b: u16x16<Self>, ) -> (u16x16<Self>, u16x16<Self>)

Deinterleave two vectors.

fn select_u16x16( self, a: mask16x16<Self>, b: u16x16<Self>, c: u16x16<Self>, ) -> u16x16<Self>

Select elements from b and c based on the mask operand a.

fn widen_u16x16(self, a: u16x16<Self>) -> (u32x8<Self>, u32x8<Self>)

Widen every lane into two same-width vectors.

fn narrow_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u8x32<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u16x16( self, a: u16x16<Self>, b: u16x16<Self>, ) -> u8x32<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u8x32<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn splat_mask16x16(self, val: bool) -> mask16x16<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask16x16(self, bits: u64) -> mask16x16<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask16x16(self, a: mask16x16<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn and_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>

Compute the logical AND of two masks.

fn or_mask16x16(self, a: mask16x16<Self>, b: mask16x16<Self>) -> mask16x16<Self>

Compute the logical OR of two masks.

fn xor_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>

Compute the logical XOR of two masks.

fn not_mask16x16(self, a: mask16x16<Self>) -> mask16x16<Self>

Compute the logical NOT of the mask.

fn reverse_mask16x16(self, a: mask16x16<Self>) -> mask16x16<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, c: mask16x16<Self>, ) -> mask16x16<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask16x16( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>

Compare two vectors element-wise for equality.

fn any_true_mask16x16(self, a: mask16x16<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask16x16(self, a: mask16x16<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask16x16(self, a: mask16x16<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask16x16(self, a: mask16x16<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn abs_i32x8(self, a: i32x8<Self>) -> i32x8<Self>

Compute the absolute value of each element.

fn splat_i32x8(self, val: i32) -> i32x8<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i32x8(self, a: i32x8<Self>) -> i32x8<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_i32x8<const SHIFT: usize>( self, a: i32x8<Self>, b: i32x8<Self>, ) -> i32x8<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i32x8( self, a: i32x8<Self>, indices: u8x32<Self>, ) -> i32x8<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i32x8( self, a: i32x8<Self>, indices: u8x32<Self>, ) -> i32x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_i32x8(self, a: i32x8<Self>) -> i32x8<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i32x8(self, a: i32x8<Self>) -> i32x8<Self>

Return the number of zeros in the binary representation of each element.

fn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Compute the bitwise AND of two vectors.

fn or_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Compute the bitwise OR of two vectors.

fn xor_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Compute the bitwise XOR of two vectors.

fn not_i32x8(self, a: i32x8<Self>) -> i32x8<Self>

Compute the bitwise NOT of the vector.

fn shl_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self>

Shift each element left by the given number of bits.

fn shlv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Shift each element left by the given number of bits.

fn shr_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self>

Shift each element right by the given number of bits.

fn shrv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i32x8(self, a: i32x8<Self>) -> i32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i32x8(self, a: i32x8<Self>) -> i32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i32x8(self, a: i32x8<Self>) -> i32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i32x8(self, a: i32x8<Self>) -> i32

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Return the element-wise maximum of two vectors.

fn min_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for greater than.

fn zip_low_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i32x8( self, a: i32x8<Self>, b: i32x8<Self>, ) -> (i32x8<Self>, i32x8<Self>)

Interleave two vectors.

fn deinterleave_i32x8( self, a: i32x8<Self>, b: i32x8<Self>, ) -> (i32x8<Self>, i32x8<Self>)

Deinterleave two vectors.

fn select_i32x8( self, a: mask32x8<Self>, b: i32x8<Self>, c: i32x8<Self>, ) -> i32x8<Self>

Select elements from b and c based on the mask operand a.

fn neg_i32x8(self, a: i32x8<Self>) -> i32x8<Self>

Negate each element of the vector, wrapping on overflow.

fn widen_i32x8(self, a: i32x8<Self>) -> (i64x4<Self>, i64x4<Self>)

Widen every lane into two same-width vectors.

fn narrow_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i16x16<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i16x16<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i16x16<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f32_i32x8(self, a: i32x8<Self>) -> f32x8<Self>

Convert each signed 32-bit integer element to a floating-point value.

fn abs_u32x8(self, a: u32x8<Self>) -> u32x8<Self>

Compute the absolute value of each element.

fn splat_u32x8(self, val: u32) -> u32x8<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u32x8(self, a: u32x8<Self>) -> u32x8<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_u32x8<const SHIFT: usize>( self, a: u32x8<Self>, b: u32x8<Self>, ) -> u32x8<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u32x8( self, a: u32x8<Self>, indices: u8x32<Self>, ) -> u32x8<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u32x8( self, a: u32x8<Self>, indices: u8x32<Self>, ) -> u32x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_u32x8(self, a: u32x8<Self>) -> u32x8<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u32x8(self, a: u32x8<Self>) -> u32x8<Self>

Return the number of zeros in the binary representation of each element.

fn add_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Compute the bitwise AND of two vectors.

fn or_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Compute the bitwise OR of two vectors.

fn xor_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Compute the bitwise XOR of two vectors.

fn not_u32x8(self, a: u32x8<Self>) -> u32x8<Self>

Compute the bitwise NOT of the vector.

fn shl_u32x8(self, a: u32x8<Self>, shift: u32) -> u32x8<Self>

Shift each element left by the given number of bits.

fn shlv_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Shift each element left by the given number of bits.

fn shr_u32x8(self, a: u32x8<Self>, shift: u32) -> u32x8<Self>

Shift each element right by the given number of bits.

fn shrv_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u32x8(self, a: u32x8<Self>) -> u32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u32x8(self, a: u32x8<Self>) -> u32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u32x8(self, a: u32x8<Self>) -> u32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u32x8(self, a: u32x8<Self>) -> u32

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Return the element-wise maximum of two vectors.

fn min_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for greater than.

fn zip_low_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u32x8( self, a: u32x8<Self>, b: u32x8<Self>, ) -> (u32x8<Self>, u32x8<Self>)

Interleave two vectors.

fn deinterleave_u32x8( self, a: u32x8<Self>, b: u32x8<Self>, ) -> (u32x8<Self>, u32x8<Self>)

Deinterleave two vectors.

fn select_u32x8( self, a: mask32x8<Self>, b: u32x8<Self>, c: u32x8<Self>, ) -> u32x8<Self>

Select elements from b and c based on the mask operand a.

fn widen_u32x8(self, a: u32x8<Self>) -> (u64x4<Self>, u64x4<Self>)

Widen every lane into two same-width vectors.

fn narrow_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u16x16<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u16x16<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u16x16<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f32_u32x8(self, a: u32x8<Self>) -> f32x8<Self>

Convert each unsigned 32-bit integer element to a floating-point value.

fn splat_mask32x8(self, val: bool) -> mask32x8<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask32x8(self, bits: u64) -> mask32x8<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask32x8(self, a: mask32x8<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn and_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>

Compute the logical AND of two masks.

fn or_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>

Compute the logical OR of two masks.

fn xor_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x8<Self>

Compute the logical XOR of two masks.

fn not_mask32x8(self, a: mask32x8<Self>) -> mask32x8<Self>

Compute the logical NOT of the mask.

fn reverse_mask32x8(self, a: mask32x8<Self>) -> mask32x8<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask32x8( self, a: mask32x8<Self>, b: mask32x8<Self>, c: mask32x8<Self>, ) -> mask32x8<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask32x8( self, a: mask32x8<Self>, b: mask32x8<Self>, ) -> mask32x8<Self>

Compare two vectors element-wise for equality.

fn any_true_mask32x8(self, a: mask32x8<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask32x8(self, a: mask32x8<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask32x8(self, a: mask32x8<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask32x8(self, a: mask32x8<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn abs_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Compute the absolute value of each element.

fn splat_f64x4(self, val: f64) -> f64x4<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_f64x4<const SHIFT: usize>( self, a: f64x4<Self>, b: f64x4<Self>, ) -> f64x4<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_f64x4( self, a: f64x4<Self>, indices: u8x32<Self>, ) -> f64x4<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_f64x4( self, a: f64x4<Self>, indices: u8x32<Self>, ) -> f64x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn neg_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Negate each element of the vector.

fn sqrt_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Compute the square root of each element.

fn approximate_recip_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Compute an approximate reciprocal (1. / x) for each element.

fn add_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Add two vectors element-wise.

fn sub_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Subtract two vectors element-wise.

fn mul_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Multiply two vectors element-wise.

fn div_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Divide two vectors element-wise.

fn copysign_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Return a vector with the magnitude of a and the sign of b for each element.

fn reduce_max_f64x4(self, a: f64x4<Self>) -> f64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_f64x4(self, a: f64x4<Self>) -> f64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_max_precise_f64x4(self, a: f64x4<Self>) -> f64

Return the maximum element in the vector, ignoring quiet NaNs.

fn reduce_min_precise_f64x4(self, a: f64x4<Self>) -> f64

Return the minimum element in the vector, ignoring quiet NaNs.

fn reduce_sum_f64x4(self, a: f64x4<Self>) -> f64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_f64x4(self, a: f64x4<Self>) -> f64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Return the element-wise maximum of two vectors.

fn min_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Return the element-wise minimum of two vectors.

fn max_precise_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Return the element-wise maximum of two vectors.

fn min_precise_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for equality.

fn simd_lt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for less than.

fn simd_le_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for greater than.

fn zip_low_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Interleave the lower half elements of two vectors.

fn zip_high_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self>

Extract odd-indexed elements from two vectors.

fn interleave_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, ) -> (f64x4<Self>, f64x4<Self>)

Interleave two vectors.

fn deinterleave_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, ) -> (f64x4<Self>, f64x4<Self>)

Deinterleave two vectors.

fn mul_add_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, c: f64x4<Self>, ) -> f64x4<Self>

Compute (a * b) + c (fused multiply-add) for each element.

fn mul_add_precise_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, c: f64x4<Self>, ) -> f64x4<Self>

Compute (a * b) + c for each element, with a single rounding at the end.

fn mul_sub_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, c: f64x4<Self>, ) -> f64x4<Self>

Compute (a * b) - c (fused multiply-subtract) for each element.

fn mul_sub_precise_f64x4( self, a: f64x4<Self>, b: f64x4<Self>, c: f64x4<Self>, ) -> f64x4<Self>

Compute (a * b) - c for each element, with a single rounding at the end.

fn floor_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Return the largest integer less than or equal to each element, that is, round towards negative infinity.

fn ceil_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.

fn round_ties_even_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Round each element to the nearest integer, with ties rounding to the nearest even integer.

fn fract_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Return the fractional part of each element.

fn trunc_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Return the integer part of each element, rounding towards zero.

fn select_f64x4( self, a: mask64x4<Self>, b: f64x4<Self>, c: f64x4<Self>, ) -> f64x4<Self>

Select elements from b and c based on the mask operand a.

fn narrow_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f32x8<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn saturating_narrow_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f32x8<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn relaxed_narrow_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f32x8<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn cvt_u64_f64x4(self, a: f64x4<Self>) -> u64x4<Self>

Convert each floating-point element to an unsigned 64-bit integer, truncating towards zero.

fn cvt_u64_precise_f64x4(self, a: f64x4<Self>) -> u64x4<Self>

Convert each floating-point element to an unsigned 64-bit integer, truncating towards zero.

fn cvt_i64_f64x4(self, a: f64x4<Self>) -> i64x4<Self>

Convert each floating-point element to a signed 64-bit integer, truncating towards zero.

fn cvt_i64_precise_f64x4(self, a: f64x4<Self>) -> i64x4<Self>

Convert each floating-point element to a signed 64-bit integer, truncating towards zero.

fn abs_i64x4(self, a: i64x4<Self>) -> i64x4<Self>

Compute the absolute value of each element.

fn splat_i64x4(self, val: i64) -> i64x4<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i64x4(self, a: i64x4<Self>) -> i64x4<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_i64x4<const SHIFT: usize>( self, a: i64x4<Self>, b: i64x4<Self>, ) -> i64x4<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i64x4( self, a: i64x4<Self>, indices: u8x32<Self>, ) -> i64x4<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i64x4( self, a: i64x4<Self>, indices: u8x32<Self>, ) -> i64x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_i64x4(self, a: i64x4<Self>) -> i64x4<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i64x4(self, a: i64x4<Self>) -> i64x4<Self>

Return the number of zeros in the binary representation of each element.

fn add_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Compute the bitwise AND of two vectors.

fn or_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Compute the bitwise OR of two vectors.

fn xor_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Compute the bitwise XOR of two vectors.

fn not_i64x4(self, a: i64x4<Self>) -> i64x4<Self>

Compute the bitwise NOT of the vector.

fn shl_i64x4(self, a: i64x4<Self>, shift: u32) -> i64x4<Self>

Shift each element left by the given number of bits.

fn shlv_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Shift each element left by the given number of bits.

fn shr_i64x4(self, a: i64x4<Self>, shift: u32) -> i64x4<Self>

Shift each element right by the given number of bits.

fn shrv_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i64x4(self, a: i64x4<Self>) -> i64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i64x4(self, a: i64x4<Self>) -> i64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i64x4(self, a: i64x4<Self>) -> i64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i64x4(self, a: i64x4<Self>) -> i64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Return the element-wise maximum of two vectors.

fn min_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for less than.

fn simd_le_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for greater than.

fn zip_low_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i64x4( self, a: i64x4<Self>, b: i64x4<Self>, ) -> (i64x4<Self>, i64x4<Self>)

Interleave two vectors.

fn deinterleave_i64x4( self, a: i64x4<Self>, b: i64x4<Self>, ) -> (i64x4<Self>, i64x4<Self>)

Deinterleave two vectors.

fn select_i64x4( self, a: mask64x4<Self>, b: i64x4<Self>, c: i64x4<Self>, ) -> i64x4<Self>

Select elements from b and c based on the mask operand a.

fn neg_i64x4(self, a: i64x4<Self>) -> i64x4<Self>

Negate each element of the vector, wrapping on overflow.

fn narrow_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i32x8<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i32x8<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i32x8<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f64_i64x4(self, a: i64x4<Self>) -> f64x4<Self>

Convert each signed 64-bit integer element to a floating-point value.

fn abs_u64x4(self, a: u64x4<Self>) -> u64x4<Self>

Compute the absolute value of each element.

fn splat_u64x4(self, val: u64) -> u64x4<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u64x4(self, a: u64x4<Self>) -> u64x4<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_u64x4<const SHIFT: usize>( self, a: u64x4<Self>, b: u64x4<Self>, ) -> u64x4<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u64x4( self, a: u64x4<Self>, indices: u8x32<Self>, ) -> u64x4<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u64x4( self, a: u64x4<Self>, indices: u8x32<Self>, ) -> u64x4<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_u64x4(self, a: u64x4<Self>) -> u64x4<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u64x4(self, a: u64x4<Self>) -> u64x4<Self>

Return the number of zeros in the binary representation of each element.

fn add_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Compute the bitwise AND of two vectors.

fn or_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Compute the bitwise OR of two vectors.

fn xor_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Compute the bitwise XOR of two vectors.

fn not_u64x4(self, a: u64x4<Self>) -> u64x4<Self>

Compute the bitwise NOT of the vector.

fn shl_u64x4(self, a: u64x4<Self>, shift: u32) -> u64x4<Self>

Shift each element left by the given number of bits.

fn shlv_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Shift each element left by the given number of bits.

fn shr_u64x4(self, a: u64x4<Self>, shift: u32) -> u64x4<Self>

Shift each element right by the given number of bits.

fn shrv_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u64x4(self, a: u64x4<Self>) -> u64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u64x4(self, a: u64x4<Self>) -> u64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u64x4(self, a: u64x4<Self>) -> u64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u64x4(self, a: u64x4<Self>) -> u64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Return the element-wise maximum of two vectors.

fn min_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for less than.

fn simd_le_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for greater than.

fn zip_low_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u64x4( self, a: u64x4<Self>, b: u64x4<Self>, ) -> (u64x4<Self>, u64x4<Self>)

Interleave two vectors.

fn deinterleave_u64x4( self, a: u64x4<Self>, b: u64x4<Self>, ) -> (u64x4<Self>, u64x4<Self>)

Deinterleave two vectors.

fn select_u64x4( self, a: mask64x4<Self>, b: u64x4<Self>, c: u64x4<Self>, ) -> u64x4<Self>

Select elements from b and c based on the mask operand a.

fn narrow_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u32x8<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u32x8<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u32x8<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f64_u64x4(self, a: u64x4<Self>) -> f64x4<Self>

Convert each unsigned 64-bit integer element to a floating-point value.

fn splat_mask64x4(self, val: bool) -> mask64x4<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask64x4(self, bits: u64) -> mask64x4<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask64x4(self, a: mask64x4<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn and_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>

Compute the logical AND of two masks.

fn or_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>

Compute the logical OR of two masks.

fn xor_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x4<Self>

Compute the logical XOR of two masks.

fn not_mask64x4(self, a: mask64x4<Self>) -> mask64x4<Self>

Compute the logical NOT of the mask.

fn reverse_mask64x4(self, a: mask64x4<Self>) -> mask64x4<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask64x4( self, a: mask64x4<Self>, b: mask64x4<Self>, c: mask64x4<Self>, ) -> mask64x4<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask64x4( self, a: mask64x4<Self>, b: mask64x4<Self>, ) -> mask64x4<Self>

Compare two vectors element-wise for equality.

fn any_true_mask64x4(self, a: mask64x4<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask64x4(self, a: mask64x4<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask64x4(self, a: mask64x4<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask64x4(self, a: mask64x4<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Compute the absolute value of each element.

fn splat_f32x16(self, val: f32) -> f32x16<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_f32x16<const SHIFT: usize>( self, a: f32x16<Self>, b: f32x16<Self>, ) -> f32x16<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_f32x16( self, a: f32x16<Self>, indices: u8x64<Self>, ) -> f32x16<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_f32x16( self, a: f32x16<Self>, indices: u8x64<Self>, ) -> f32x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_f32x16( self, a: f32x16<Self>, indices: u8x64<Self>, ) -> f32x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Negate each element of the vector.

fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Compute the square root of each element.

fn approximate_recip_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Compute an approximate reciprocal (1. / x) for each element.

fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Add two vectors element-wise.

fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Subtract two vectors element-wise.

fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Multiply two vectors element-wise.

fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Divide two vectors element-wise.

fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Return a vector with the magnitude of a and the sign of b for each element.

fn reduce_max_f32x16(self, a: f32x16<Self>) -> f32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_f32x16(self, a: f32x16<Self>) -> f32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_max_precise_f32x16(self, a: f32x16<Self>) -> f32

Return the maximum element in the vector, ignoring quiet NaNs.

fn reduce_min_precise_f32x16(self, a: f32x16<Self>) -> f32

Return the minimum element in the vector, ignoring quiet NaNs.

fn reduce_sum_f32x16(self, a: f32x16<Self>) -> f32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_f32x16(self, a: f32x16<Self>) -> f32

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Return the element-wise maximum of two vectors.

fn min_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Return the element-wise minimum of two vectors.

fn max_precise_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Return the element-wise maximum of two vectors.

fn min_precise_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for equality.

fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for less than.

fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for greater than.

fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Interleave the lower half elements of two vectors.

fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self>

Extract odd-indexed elements from two vectors.

fn interleave_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, ) -> (f32x16<Self>, f32x16<Self>)

Interleave two vectors.

fn deinterleave_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, ) -> (f32x16<Self>, f32x16<Self>)

Deinterleave two vectors.

fn mul_add_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, c: f32x16<Self>, ) -> f32x16<Self>

Compute (a * b) + c (fused multiply-add) for each element.

fn mul_add_precise_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, c: f32x16<Self>, ) -> f32x16<Self>

Compute (a * b) + c for each element, with a single rounding at the end.

fn mul_sub_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, c: f32x16<Self>, ) -> f32x16<Self>

Compute (a * b) - c (fused multiply-subtract) for each element.

fn mul_sub_precise_f32x16( self, a: f32x16<Self>, b: f32x16<Self>, c: f32x16<Self>, ) -> f32x16<Self>

Compute (a * b) - c for each element, with a single rounding at the end.

fn floor_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Return the largest integer less than or equal to each element, that is, round towards negative infinity.

fn ceil_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.

fn round_ties_even_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Round each element to the nearest integer, with ties rounding to the nearest even integer.

fn fract_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Return the fractional part of each element.

fn trunc_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Return the integer part of each element, rounding towards zero.

fn select_f32x16( self, a: mask32x16<Self>, b: f32x16<Self>, c: f32x16<Self>, ) -> f32x16<Self>

Select elements from b and c based on the mask operand a.

fn widen_f32x16(self, a: f32x16<Self>) -> (f64x8<Self>, f64x8<Self>)

Widen every f32 lane exactly into two same-width f64 vectors.

fn cvt_u32_f32x16(self, a: f32x16<Self>) -> u32x16<Self>

Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.

fn cvt_u32_precise_f32x16(self, a: f32x16<Self>) -> u32x16<Self>

Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.

fn cvt_i32_f32x16(self, a: f32x16<Self>) -> i32x16<Self>

Convert each floating-point element to a signed 32-bit integer, truncating towards zero.

fn cvt_i32_precise_f32x16(self, a: f32x16<Self>) -> i32x16<Self>

Convert each floating-point element to a signed 32-bit integer, truncating towards zero.

fn abs_i8x64(self, a: i8x64<Self>) -> i8x64<Self>

Compute the absolute value of each element.

fn splat_i8x64(self, val: i8) -> i8x64<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i8x64(self, a: i8x64<Self>) -> i8x64<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_i8x64<const SHIFT: usize>( self, a: i8x64<Self>, b: i8x64<Self>, ) -> i8x64<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i8x64( self, a: i8x64<Self>, indices: u8x64<Self>, ) -> i8x64<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i8x64( self, a: i8x64<Self>, indices: u8x64<Self>, ) -> i8x64<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_i8x64(self, a: i8x64<Self>) -> i8x64<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i8x64(self, a: i8x64<Self>) -> i8x64<Self>

Return the number of zeros in the binary representation of each element.

fn add_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Compute the bitwise AND of two vectors.

fn or_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Compute the bitwise OR of two vectors.

fn xor_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Compute the bitwise XOR of two vectors.

fn not_i8x64(self, a: i8x64<Self>) -> i8x64<Self>

Compute the bitwise NOT of the vector.

fn shl_i8x64(self, a: i8x64<Self>, shift: u32) -> i8x64<Self>

Shift each element left by the given number of bits.

fn shlv_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Shift each element left by the given number of bits.

fn shr_i8x64(self, a: i8x64<Self>, shift: u32) -> i8x64<Self>

Shift each element right by the given number of bits.

fn shrv_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i8x64(self, a: i8x64<Self>) -> i8

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i8x64(self, a: i8x64<Self>) -> i8

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i8x64(self, a: i8x64<Self>) -> i8

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i8x64(self, a: i8x64<Self>) -> i8

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Return the element-wise maximum of two vectors.

fn min_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for less than.

fn simd_le_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for greater than.

fn zip_low_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i8x64( self, a: i8x64<Self>, b: i8x64<Self>, ) -> (i8x64<Self>, i8x64<Self>)

Interleave two vectors.

fn deinterleave_i8x64( self, a: i8x64<Self>, b: i8x64<Self>, ) -> (i8x64<Self>, i8x64<Self>)

Deinterleave two vectors.

fn select_i8x64( self, a: mask8x64<Self>, b: i8x64<Self>, c: i8x64<Self>, ) -> i8x64<Self>

Select elements from b and c based on the mask operand a.

fn neg_i8x64(self, a: i8x64<Self>) -> i8x64<Self>

Negate each element of the vector, wrapping on overflow.

fn widen_i8x64(self, a: i8x64<Self>) -> (i16x32<Self>, i16x32<Self>)

Widen every lane into two same-width vectors.

fn abs_u8x64(self, a: u8x64<Self>) -> u8x64<Self>

Compute the absolute value of each element.

fn splat_u8x64(self, val: u8) -> u8x64<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u8x64(self, a: u8x64<Self>) -> u8x64<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_u8x64<const SHIFT: usize>( self, a: u8x64<Self>, b: u8x64<Self>, ) -> u8x64<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u8x64( self, a: u8x64<Self>, indices: u8x64<Self>, ) -> u8x64<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn count_ones_u8x64(self, a: u8x64<Self>) -> u8x64<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u8x64(self, a: u8x64<Self>) -> u8x64<Self>

Return the number of zeros in the binary representation of each element.

fn add_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Compute the bitwise AND of two vectors.

fn or_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Compute the bitwise OR of two vectors.

fn xor_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Compute the bitwise XOR of two vectors.

fn not_u8x64(self, a: u8x64<Self>) -> u8x64<Self>

Compute the bitwise NOT of the vector.

fn shl_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self>

Shift each element left by the given number of bits.

fn shlv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Shift each element left by the given number of bits.

fn shr_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self>

Shift each element right by the given number of bits.

fn shrv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u8x64(self, a: u8x64<Self>) -> u8

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u8x64(self, a: u8x64<Self>) -> u8

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u8x64(self, a: u8x64<Self>) -> u8

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u8x64(self, a: u8x64<Self>) -> u8

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Return the element-wise maximum of two vectors.

fn min_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for less than.

fn simd_le_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self>

Compare two vectors element-wise for greater than.

fn zip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u8x64( self, a: u8x64<Self>, b: u8x64<Self>, ) -> (u8x64<Self>, u8x64<Self>)

Interleave two vectors.

fn deinterleave_u8x64( self, a: u8x64<Self>, b: u8x64<Self>, ) -> (u8x64<Self>, u8x64<Self>)

Deinterleave two vectors.

fn select_u8x64( self, a: mask8x64<Self>, b: u8x64<Self>, c: u8x64<Self>, ) -> u8x64<Self>

Select elements from b and c based on the mask operand a.

fn widen_u8x64(self, a: u8x64<Self>) -> (u16x32<Self>, u16x32<Self>)

Widen every lane into two same-width vectors.

fn splat_mask8x64(self, val: bool) -> mask8x64<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask8x64(self, bits: u64) -> mask8x64<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask8x64(self, a: mask8x64<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn and_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>

Compute the logical AND of two masks.

fn or_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>

Compute the logical OR of two masks.

fn xor_mask8x64(self, a: mask8x64<Self>, b: mask8x64<Self>) -> mask8x64<Self>

Compute the logical XOR of two masks.

fn not_mask8x64(self, a: mask8x64<Self>) -> mask8x64<Self>

Compute the logical NOT of the mask.

fn reverse_mask8x64(self, a: mask8x64<Self>) -> mask8x64<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask8x64( self, a: mask8x64<Self>, b: mask8x64<Self>, c: mask8x64<Self>, ) -> mask8x64<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask8x64( self, a: mask8x64<Self>, b: mask8x64<Self>, ) -> mask8x64<Self>

Compare two vectors element-wise for equality.

fn any_true_mask8x64(self, a: mask8x64<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask8x64(self, a: mask8x64<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask8x64(self, a: mask8x64<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask8x64(self, a: mask8x64<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn abs_i16x32(self, a: i16x32<Self>) -> i16x32<Self>

Compute the absolute value of each element.

fn splat_i16x32(self, val: i16) -> i16x32<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i16x32(self, a: i16x32<Self>) -> i16x32<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_i16x32<const SHIFT: usize>( self, a: i16x32<Self>, b: i16x32<Self>, ) -> i16x32<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i16x32( self, a: i16x32<Self>, indices: u8x64<Self>, ) -> i16x32<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i16x32( self, a: i16x32<Self>, indices: u8x64<Self>, ) -> i16x32<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i16x32( self, a: i16x32<Self>, indices: u8x64<Self>, ) -> i16x32<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_i16x32(self, a: i16x32<Self>) -> i16x32<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i16x32(self, a: i16x32<Self>) -> i16x32<Self>

Return the number of zeros in the binary representation of each element.

fn add_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Compute the bitwise AND of two vectors.

fn or_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Compute the bitwise OR of two vectors.

fn xor_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Compute the bitwise XOR of two vectors.

fn not_i16x32(self, a: i16x32<Self>) -> i16x32<Self>

Compute the bitwise NOT of the vector.

fn shl_i16x32(self, a: i16x32<Self>, shift: u32) -> i16x32<Self>

Shift each element left by the given number of bits.

fn shlv_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Shift each element left by the given number of bits.

fn shr_i16x32(self, a: i16x32<Self>, shift: u32) -> i16x32<Self>

Shift each element right by the given number of bits.

fn shrv_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i16x32(self, a: i16x32<Self>) -> i16

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i16x32(self, a: i16x32<Self>) -> i16

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i16x32(self, a: i16x32<Self>) -> i16

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i16x32(self, a: i16x32<Self>) -> i16

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Return the element-wise maximum of two vectors.

fn min_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for less than.

fn simd_le_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for greater than.

fn zip_low_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i16x32( self, a: i16x32<Self>, b: i16x32<Self>, ) -> (i16x32<Self>, i16x32<Self>)

Interleave two vectors.

fn deinterleave_i16x32( self, a: i16x32<Self>, b: i16x32<Self>, ) -> (i16x32<Self>, i16x32<Self>)

Deinterleave two vectors.

fn select_i16x32( self, a: mask16x32<Self>, b: i16x32<Self>, c: i16x32<Self>, ) -> i16x32<Self>

Select elements from b and c based on the mask operand a.

fn neg_i16x32(self, a: i16x32<Self>) -> i16x32<Self>

Negate each element of the vector, wrapping on overflow.

fn widen_i16x32(self, a: i16x32<Self>) -> (i32x16<Self>, i32x16<Self>)

Widen every lane into two same-width vectors.

fn narrow_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i8x64<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i16x32( self, a: i16x32<Self>, b: i16x32<Self>, ) -> i8x64<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i8x64<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn abs_u16x32(self, a: u16x32<Self>) -> u16x32<Self>

Compute the absolute value of each element.

fn splat_u16x32(self, val: u16) -> u16x32<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u16x32(self, a: u16x32<Self>) -> u16x32<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_u16x32<const SHIFT: usize>( self, a: u16x32<Self>, b: u16x32<Self>, ) -> u16x32<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u16x32( self, a: u16x32<Self>, indices: u8x64<Self>, ) -> u16x32<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u16x32( self, a: u16x32<Self>, indices: u8x64<Self>, ) -> u16x32<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u16x32( self, a: u16x32<Self>, indices: u8x64<Self>, ) -> u16x32<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_u16x32(self, a: u16x32<Self>) -> u16x32<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u16x32(self, a: u16x32<Self>) -> u16x32<Self>

Return the number of zeros in the binary representation of each element.

fn add_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Compute the bitwise AND of two vectors.

fn or_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Compute the bitwise OR of two vectors.

fn xor_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Compute the bitwise XOR of two vectors.

fn not_u16x32(self, a: u16x32<Self>) -> u16x32<Self>

Compute the bitwise NOT of the vector.

fn shl_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self>

Shift each element left by the given number of bits.

fn shlv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Shift each element left by the given number of bits.

fn shr_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self>

Shift each element right by the given number of bits.

fn shrv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u16x32(self, a: u16x32<Self>) -> u16

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u16x32(self, a: u16x32<Self>) -> u16

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u16x32(self, a: u16x32<Self>) -> u16

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u16x32(self, a: u16x32<Self>) -> u16

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Return the element-wise maximum of two vectors.

fn min_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for less than.

fn simd_le_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self>

Compare two vectors element-wise for greater than.

fn zip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u16x32( self, a: u16x32<Self>, b: u16x32<Self>, ) -> (u16x32<Self>, u16x32<Self>)

Interleave two vectors.

fn deinterleave_u16x32( self, a: u16x32<Self>, b: u16x32<Self>, ) -> (u16x32<Self>, u16x32<Self>)

Deinterleave two vectors.

fn select_u16x32( self, a: mask16x32<Self>, b: u16x32<Self>, c: u16x32<Self>, ) -> u16x32<Self>

Select elements from b and c based on the mask operand a.

fn widen_u16x32(self, a: u16x32<Self>) -> (u32x16<Self>, u32x16<Self>)

Widen every lane into two same-width vectors.

fn narrow_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u8x64<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u16x32( self, a: u16x32<Self>, b: u16x32<Self>, ) -> u8x64<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u8x64<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn splat_mask16x32(self, val: bool) -> mask16x32<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask16x32(self, bits: u64) -> mask16x32<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask16x32(self, a: mask16x32<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn and_mask16x32( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>

Compute the logical AND of two masks.

fn or_mask16x32(self, a: mask16x32<Self>, b: mask16x32<Self>) -> mask16x32<Self>

Compute the logical OR of two masks.

fn xor_mask16x32( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>

Compute the logical XOR of two masks.

fn not_mask16x32(self, a: mask16x32<Self>) -> mask16x32<Self>

Compute the logical NOT of the mask.

fn reverse_mask16x32(self, a: mask16x32<Self>) -> mask16x32<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask16x32( self, a: mask16x32<Self>, b: mask16x32<Self>, c: mask16x32<Self>, ) -> mask16x32<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask16x32( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>

Compare two vectors element-wise for equality.

fn any_true_mask16x32(self, a: mask16x32<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask16x32(self, a: mask16x32<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask16x32(self, a: mask16x32<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask16x32(self, a: mask16x32<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn abs_i32x16(self, a: i32x16<Self>) -> i32x16<Self>

Compute the absolute value of each element.

fn splat_i32x16(self, val: i32) -> i32x16<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i32x16(self, a: i32x16<Self>) -> i32x16<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_i32x16<const SHIFT: usize>( self, a: i32x16<Self>, b: i32x16<Self>, ) -> i32x16<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i32x16( self, a: i32x16<Self>, indices: u8x64<Self>, ) -> i32x16<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i32x16( self, a: i32x16<Self>, indices: u8x64<Self>, ) -> i32x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i32x16( self, a: i32x16<Self>, indices: u8x64<Self>, ) -> i32x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_i32x16(self, a: i32x16<Self>) -> i32x16<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i32x16(self, a: i32x16<Self>) -> i32x16<Self>

Return the number of zeros in the binary representation of each element.

fn add_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Compute the bitwise AND of two vectors.

fn or_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Compute the bitwise OR of two vectors.

fn xor_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Compute the bitwise XOR of two vectors.

fn not_i32x16(self, a: i32x16<Self>) -> i32x16<Self>

Compute the bitwise NOT of the vector.

fn shl_i32x16(self, a: i32x16<Self>, shift: u32) -> i32x16<Self>

Shift each element left by the given number of bits.

fn shlv_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Shift each element left by the given number of bits.

fn shr_i32x16(self, a: i32x16<Self>, shift: u32) -> i32x16<Self>

Shift each element right by the given number of bits.

fn shrv_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i32x16(self, a: i32x16<Self>) -> i32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i32x16(self, a: i32x16<Self>) -> i32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i32x16(self, a: i32x16<Self>) -> i32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i32x16(self, a: i32x16<Self>) -> i32

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Return the element-wise maximum of two vectors.

fn min_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for less than.

fn simd_le_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for greater than.

fn zip_low_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i32x16( self, a: i32x16<Self>, b: i32x16<Self>, ) -> (i32x16<Self>, i32x16<Self>)

Interleave two vectors.

fn deinterleave_i32x16( self, a: i32x16<Self>, b: i32x16<Self>, ) -> (i32x16<Self>, i32x16<Self>)

Deinterleave two vectors.

fn select_i32x16( self, a: mask32x16<Self>, b: i32x16<Self>, c: i32x16<Self>, ) -> i32x16<Self>

Select elements from b and c based on the mask operand a.

fn neg_i32x16(self, a: i32x16<Self>) -> i32x16<Self>

Negate each element of the vector, wrapping on overflow.

fn widen_i32x16(self, a: i32x16<Self>) -> (i64x8<Self>, i64x8<Self>)

Widen every lane into two same-width vectors.

fn narrow_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i16x32<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i32x16( self, a: i32x16<Self>, b: i32x16<Self>, ) -> i16x32<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i16x32<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f32_i32x16(self, a: i32x16<Self>) -> f32x16<Self>

Convert each signed 32-bit integer element to a floating-point value.

fn abs_u32x16(self, a: u32x16<Self>) -> u32x16<Self>

Compute the absolute value of each element.

fn splat_u32x16(self, val: u32) -> u32x16<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u32x16(self, a: u32x16<Self>) -> u32x16<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_u32x16<const SHIFT: usize>( self, a: u32x16<Self>, b: u32x16<Self>, ) -> u32x16<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u32x16( self, a: u32x16<Self>, indices: u8x64<Self>, ) -> u32x16<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u32x16( self, a: u32x16<Self>, indices: u8x64<Self>, ) -> u32x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u32x16( self, a: u32x16<Self>, indices: u8x64<Self>, ) -> u32x16<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_u32x16(self, a: u32x16<Self>) -> u32x16<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u32x16(self, a: u32x16<Self>) -> u32x16<Self>

Return the number of zeros in the binary representation of each element.

fn add_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Compute the bitwise AND of two vectors.

fn or_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Compute the bitwise OR of two vectors.

fn xor_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Compute the bitwise XOR of two vectors.

fn not_u32x16(self, a: u32x16<Self>) -> u32x16<Self>

Compute the bitwise NOT of the vector.

fn shl_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self>

Shift each element left by the given number of bits.

fn shlv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Shift each element left by the given number of bits.

fn shr_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self>

Shift each element right by the given number of bits.

fn shrv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u32x16(self, a: u32x16<Self>) -> u32

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u32x16(self, a: u32x16<Self>) -> u32

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u32x16(self, a: u32x16<Self>) -> u32

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u32x16(self, a: u32x16<Self>) -> u32

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Return the element-wise maximum of two vectors.

fn min_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for less than.

fn simd_le_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self>

Compare two vectors element-wise for greater than.

fn zip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u32x16( self, a: u32x16<Self>, b: u32x16<Self>, ) -> (u32x16<Self>, u32x16<Self>)

Interleave two vectors.

fn deinterleave_u32x16( self, a: u32x16<Self>, b: u32x16<Self>, ) -> (u32x16<Self>, u32x16<Self>)

Deinterleave two vectors.

fn select_u32x16( self, a: mask32x16<Self>, b: u32x16<Self>, c: u32x16<Self>, ) -> u32x16<Self>

Select elements from b and c based on the mask operand a.

fn widen_u32x16(self, a: u32x16<Self>) -> (u64x8<Self>, u64x8<Self>)

Widen every lane into two same-width vectors.

fn narrow_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u16x32<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u32x16( self, a: u32x16<Self>, b: u32x16<Self>, ) -> u16x32<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u16x32<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f32_u32x16(self, a: u32x16<Self>) -> f32x16<Self>

Convert each unsigned 32-bit integer element to a floating-point value.

fn splat_mask32x16(self, val: bool) -> mask32x16<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask32x16(self, bits: u64) -> mask32x16<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask32x16(self, a: mask32x16<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn and_mask32x16( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>

Compute the logical AND of two masks.

fn or_mask32x16(self, a: mask32x16<Self>, b: mask32x16<Self>) -> mask32x16<Self>

Compute the logical OR of two masks.

fn xor_mask32x16( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>

Compute the logical XOR of two masks.

fn not_mask32x16(self, a: mask32x16<Self>) -> mask32x16<Self>

Compute the logical NOT of the mask.

fn reverse_mask32x16(self, a: mask32x16<Self>) -> mask32x16<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask32x16( self, a: mask32x16<Self>, b: mask32x16<Self>, c: mask32x16<Self>, ) -> mask32x16<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask32x16( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>

Compare two vectors element-wise for equality.

fn any_true_mask32x16(self, a: mask32x16<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask32x16(self, a: mask32x16<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask32x16(self, a: mask32x16<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask32x16(self, a: mask32x16<Self>) -> bool

Returns true if all logical lanes in this mask are false.

fn abs_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Compute the absolute value of each element.

fn splat_f64x8(self, val: f64) -> f64x8<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_f64x8<const SHIFT: usize>( self, a: f64x8<Self>, b: f64x8<Self>, ) -> f64x8<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_f64x8( self, a: f64x8<Self>, indices: u8x64<Self>, ) -> f64x8<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_f64x8( self, a: f64x8<Self>, indices: u8x64<Self>, ) -> f64x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn neg_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Negate each element of the vector.

fn sqrt_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Compute the square root of each element.

fn approximate_recip_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Compute an approximate reciprocal (1. / x) for each element.

fn add_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Add two vectors element-wise.

fn sub_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Subtract two vectors element-wise.

fn mul_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Multiply two vectors element-wise.

fn div_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Divide two vectors element-wise.

fn copysign_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Return a vector with the magnitude of a and the sign of b for each element.

fn reduce_max_f64x8(self, a: f64x8<Self>) -> f64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_f64x8(self, a: f64x8<Self>) -> f64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_max_precise_f64x8(self, a: f64x8<Self>) -> f64

Return the maximum element in the vector, ignoring quiet NaNs.

fn reduce_min_precise_f64x8(self, a: f64x8<Self>) -> f64

Return the minimum element in the vector, ignoring quiet NaNs.

fn reduce_sum_f64x8(self, a: f64x8<Self>) -> f64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_f64x8(self, a: f64x8<Self>) -> f64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Return the element-wise maximum of two vectors.

fn min_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Return the element-wise minimum of two vectors.

fn max_precise_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Return the element-wise maximum of two vectors.

fn min_precise_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for equality.

fn simd_lt_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for greater than.

fn zip_low_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Interleave the lower half elements of two vectors.

fn zip_high_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self>

Extract odd-indexed elements from two vectors.

fn interleave_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, ) -> (f64x8<Self>, f64x8<Self>)

Interleave two vectors.

fn deinterleave_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, ) -> (f64x8<Self>, f64x8<Self>)

Deinterleave two vectors.

fn mul_add_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, c: f64x8<Self>, ) -> f64x8<Self>

Compute (a * b) + c (fused multiply-add) for each element.

fn mul_add_precise_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, c: f64x8<Self>, ) -> f64x8<Self>

Compute (a * b) + c for each element, with a single rounding at the end.

fn mul_sub_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, c: f64x8<Self>, ) -> f64x8<Self>

Compute (a * b) - c (fused multiply-subtract) for each element.

fn mul_sub_precise_f64x8( self, a: f64x8<Self>, b: f64x8<Self>, c: f64x8<Self>, ) -> f64x8<Self>

Compute (a * b) - c for each element, with a single rounding at the end.

fn floor_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Return the largest integer less than or equal to each element, that is, round towards negative infinity.

fn ceil_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.

fn round_ties_even_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Round each element to the nearest integer, with ties rounding to the nearest even integer.

fn fract_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Return the fractional part of each element.

fn trunc_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Return the integer part of each element, rounding towards zero.

fn select_f64x8( self, a: mask64x8<Self>, b: f64x8<Self>, c: f64x8<Self>, ) -> f64x8<Self>

Select elements from b and c based on the mask operand a.

fn narrow_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f32x16<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn saturating_narrow_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f32x16<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn relaxed_narrow_f64x8(self, a: f64x8<Self>, b: f64x8<Self>) -> f32x16<Self>

Convert the lanes of two f64 vectors to f32 and concatenate them into one same-width vector.

fn cvt_u64_f64x8(self, a: f64x8<Self>) -> u64x8<Self>

Convert each floating-point element to an unsigned 64-bit integer, truncating towards zero.

fn cvt_u64_precise_f64x8(self, a: f64x8<Self>) -> u64x8<Self>

Convert each floating-point element to an unsigned 64-bit integer, truncating towards zero.

fn cvt_i64_f64x8(self, a: f64x8<Self>) -> i64x8<Self>

Convert each floating-point element to a signed 64-bit integer, truncating towards zero.

fn cvt_i64_precise_f64x8(self, a: f64x8<Self>) -> i64x8<Self>

Convert each floating-point element to a signed 64-bit integer, truncating towards zero.

fn abs_i64x8(self, a: i64x8<Self>) -> i64x8<Self>

Compute the absolute value of each element.

fn splat_i64x8(self, val: i64) -> i64x8<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_i64x8(self, a: i64x8<Self>) -> i64x8<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_i64x8<const SHIFT: usize>( self, a: i64x8<Self>, b: i64x8<Self>, ) -> i64x8<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_i64x8( self, a: i64x8<Self>, indices: u8x64<Self>, ) -> i64x8<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_i64x8( self, a: i64x8<Self>, indices: u8x64<Self>, ) -> i64x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_i64x8(self, a: i64x8<Self>) -> i64x8<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_i64x8(self, a: i64x8<Self>) -> i64x8<Self>

Return the number of zeros in the binary representation of each element.

fn add_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Compute the bitwise AND of two vectors.

fn or_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Compute the bitwise OR of two vectors.

fn xor_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Compute the bitwise XOR of two vectors.

fn not_i64x8(self, a: i64x8<Self>) -> i64x8<Self>

Compute the bitwise NOT of the vector.

fn shl_i64x8(self, a: i64x8<Self>, shift: u32) -> i64x8<Self>

Shift each element left by the given number of bits.

fn shlv_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Shift each element left by the given number of bits.

fn shr_i64x8(self, a: i64x8<Self>, shift: u32) -> i64x8<Self>

Shift each element right by the given number of bits.

fn shrv_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_i64x8(self, a: i64x8<Self>) -> i64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_i64x8(self, a: i64x8<Self>) -> i64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_i64x8(self, a: i64x8<Self>) -> i64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_i64x8(self, a: i64x8<Self>) -> i64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Return the element-wise maximum of two vectors.

fn min_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for equality.

fn simd_lt_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for greater than.

fn zip_low_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Interleave the lower half elements of two vectors.

fn zip_high_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Extract odd-indexed elements from two vectors.

fn interleave_i64x8( self, a: i64x8<Self>, b: i64x8<Self>, ) -> (i64x8<Self>, i64x8<Self>)

Interleave two vectors.

fn deinterleave_i64x8( self, a: i64x8<Self>, b: i64x8<Self>, ) -> (i64x8<Self>, i64x8<Self>)

Deinterleave two vectors.

fn select_i64x8( self, a: mask64x8<Self>, b: i64x8<Self>, c: i64x8<Self>, ) -> i64x8<Self>

Select elements from b and c based on the mask operand a.

fn neg_i64x8(self, a: i64x8<Self>) -> i64x8<Self>

Negate each element of the vector, wrapping on overflow.

fn narrow_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i32x16<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i32x16<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i32x16<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f64_i64x8(self, a: i64x8<Self>) -> f64x8<Self>

Convert each signed 64-bit integer element to a floating-point value.

fn abs_u64x8(self, a: u64x8<Self>) -> u64x8<Self>

Compute the absolute value of each element.

fn splat_u64x8(self, val: u64) -> u64x8<Self>

Create a SIMD vector with all elements set to the given value.

fn reverse_u64x8(self, a: u64x8<Self>) -> u64x8<Self>

Reverse the order of the vector’s elements.

fn slide_within_blocks_u64x8<const SHIFT: usize>( self, a: u64x8<Self>, b: u64x8<Self>, ) -> u64x8<Self>

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks_u64x8( self, a: u64x8<Self>, indices: u8x64<Self>, ) -> u64x8<Self>

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise_u64x8( self, a: u64x8<Self>, indices: u8x64<Self>, ) -> u64x8<Self>

Dynamically swizzle this vector’s bytes across the whole vector.

fn count_ones_u64x8(self, a: u64x8<Self>) -> u64x8<Self>

Return the number of ones in the binary representation of each element.

fn count_zeros_u64x8(self, a: u64x8<Self>) -> u64x8<Self>

Return the number of zeros in the binary representation of each element.

fn add_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Add two vectors element-wise, wrapping on overflow.

fn saturating_add_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Add two vectors element-wise, saturating on overflow.

fn sub_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Subtract two vectors element-wise, wrapping on overflow.

fn saturating_sub_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Subtract two vectors element-wise, saturating on overflow.

fn mul_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Multiply two vectors element-wise, wrapping on overflow.

fn and_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Compute the bitwise AND of two vectors.

fn or_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Compute the bitwise OR of two vectors.

fn xor_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Compute the bitwise XOR of two vectors.

fn not_u64x8(self, a: u64x8<Self>) -> u64x8<Self>

Compute the bitwise NOT of the vector.

fn shl_u64x8(self, a: u64x8<Self>, shift: u32) -> u64x8<Self>

Shift each element left by the given number of bits.

fn shlv_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Shift each element left by the given number of bits.

fn shr_u64x8(self, a: u64x8<Self>, shift: u32) -> u64x8<Self>

Shift each element right by the given number of bits.

fn shrv_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Shift each element right by the corresponding element in another vector.

fn reduce_max_u64x8(self, a: u64x8<Self>) -> u64

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min_u64x8(self, a: u64x8<Self>) -> u64

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_sum_u64x8(self, a: u64x8<Self>) -> u64

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product_u64x8(self, a: u64x8<Self>) -> u64

Return the product of all elements in the vector. Integer multiplication wraps.

fn max_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Return the element-wise maximum of two vectors.

fn min_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Return the element-wise minimum of two vectors.

fn simd_eq_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for equality.

fn simd_lt_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for less than or equal.

fn simd_ge_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for greater than or equal.

fn simd_gt_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> mask64x8<Self>

Compare two vectors element-wise for greater than.

fn zip_low_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Interleave the lower half elements of two vectors.

fn zip_high_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Interleave the upper half elements of two vectors.

fn unzip_low_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Extract even-indexed elements from two vectors.

fn unzip_high_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Extract odd-indexed elements from two vectors.

fn interleave_u64x8( self, a: u64x8<Self>, b: u64x8<Self>, ) -> (u64x8<Self>, u64x8<Self>)

Interleave two vectors.

fn deinterleave_u64x8( self, a: u64x8<Self>, b: u64x8<Self>, ) -> (u64x8<Self>, u64x8<Self>)

Deinterleave two vectors.

fn select_u64x8( self, a: mask64x8<Self>, b: u64x8<Self>, c: u64x8<Self>, ) -> u64x8<Self>

Select elements from b and c based on the mask operand a.

fn narrow_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u32x16<Self>

Truncate the lanes of two vectors and concatenate them into one same-width vector.

fn saturating_narrow_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u32x16<Self>

Narrow the lanes of two vectors with saturation and concatenate them into one same-width vector.

fn relaxed_narrow_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u32x16<Self>

Narrow the lanes of two vectors using the cheapest operation for the active SIMD backend and concatenate them into one same-width vector.

fn cvt_f64_u64x8(self, a: u64x8<Self>) -> f64x8<Self>

Convert each unsigned 64-bit integer element to a floating-point value.

fn splat_mask64x8(self, val: bool) -> mask64x8<Self>

Create a SIMD mask with all lanes set from the given boolean value.

fn from_bitmask_mask64x8(self, bits: u64) -> mask64x8<Self>

Create a SIMD mask from a compact bitmask.

fn to_bitmask_mask64x8(self, a: mask64x8<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

fn and_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>

Compute the logical AND of two masks.

fn or_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>

Compute the logical OR of two masks.

fn xor_mask64x8(self, a: mask64x8<Self>, b: mask64x8<Self>) -> mask64x8<Self>

Compute the logical XOR of two masks.

fn not_mask64x8(self, a: mask64x8<Self>) -> mask64x8<Self>

Compute the logical NOT of the mask.

fn reverse_mask64x8(self, a: mask64x8<Self>) -> mask64x8<Self>

Reverse the order of the mask’s logical lanes.

fn select_mask64x8( self, a: mask64x8<Self>, b: mask64x8<Self>, c: mask64x8<Self>, ) -> mask64x8<Self>

Select elements from b and c based on the mask operand a.

fn simd_eq_mask64x8( self, a: mask64x8<Self>, b: mask64x8<Self>, ) -> mask64x8<Self>

Compare two vectors element-wise for equality.

fn any_true_mask64x8(self, a: mask64x8<Self>) -> bool

Returns true if any logical lanes in this mask are true.

fn all_true_mask64x8(self, a: mask64x8<Self>) -> bool

Returns true if all logical lanes in this mask are true.

fn any_false_mask64x8(self, a: mask64x8<Self>) -> bool

Returns true if any logical lanes in this mask are false.

fn all_false_mask64x8(self, a: mask64x8<Self>) -> bool

Returns true if all logical lanes in this mask are false.