Struct Avx2 

pub struct Avx2 { /* private fields */ }

Available on x86 or x86-64 only.

A token for AVX2 intrinsics on x86 and x86_64, representing the x86-64-v3 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 Avx2

pub const fn assume_supported() -> Self

Available on target features avx2 and bmi1 and bmi2 and cmpxchg16b and f16c and fma and fxsr and lzcnt and movbe and popcnt and xsave only.

Create a SIMD token proving that the x86-64-v3 features are available.

Most users should safely obtain the token from Level::new instead of calling this function.

This function can be called without an unsafe block from a function with all the required target features enabled via the #[target_feature] annotation.

Safety

When invoking this function through an unsafe block, the caller must ensure that the current CPU supports avx2, bmi1, bmi2, cmpxchg16b, f16c, fma, fxsr, lzcnt, movbe, popcnt, xsave.

Trait Implementations

impl Clone for Avx2

fn clone(&self) -> Avx2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Avx2

impl Debug for Avx2

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

Formats the value using the given formatter.

impl Simd for Avx2

type f32s = f32x8<Avx2>

A native-width SIMD vector of f32s.

type f64s = f64x4<Avx2>

A native-width SIMD vector of f64s.

type u8s = u8x32<Avx2>

A native-width SIMD vector of u8s.

type i8s = i8x32<Avx2>

A native-width SIMD vector of i8s.

type u16s = u16x16<Avx2>

A native-width SIMD vector of u16s.

type i16s = i16x16<Avx2>

A native-width SIMD vector of i16s.

type u32s = u32x8<Avx2>

A native-width SIMD vector of u32s.

type i32s = i32x8<Avx2>

A native-width SIMD vector of i32s.

type u64s = u64x4<Avx2>

A native-width SIMD vector of u64s.

type i64s = i64x4<Avx2>

A native-width SIMD vector of i64s.

type mask8s = mask8x32<Avx2>

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

type mask16s = mask16x16<Avx2>

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

type mask32s = mask32x8<Avx2>

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

type mask64s = mask64x4<Avx2>

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 function with SIMD instructions enabled, without forcing inlining.

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

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

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

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

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

Compute the absolute value of each element.

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 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_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 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 splat_i8x16(self, val: i8) -> i8x16<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 slide_u8x16<const SHIFT: usize>( self, a: u8x16<Self>, b: u8x16<Self>, ) -> u8x16<Self>

Concatenate [self, rhs] and extract Self::N 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 add_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 splat_i16x8(self, val: i16) -> i16x8<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 slide_u16x8<const SHIFT: usize>( self, a: u16x8<Self>, b: u16x8<Self>, ) -> u16x8<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 splat_i32x4(self, val: i32) -> i32x4<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 slide_u32x4<const SHIFT: usize>( self, a: u32x4<Self>, b: u32x4<Self>, ) -> u32x4<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 splat_f64x2(self, val: f64) -> f64x2<Self>

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

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

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

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

Compute the absolute value of each element.

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 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_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 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 splat_i64x2(self, val: i64) -> i64x2<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 slide_u64x2<const SHIFT: usize>( self, a: u64x2<Self>, b: u64x2<Self>, ) -> u64x2<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 splat_f32x8(self, val: f32) -> f32x8<Self>

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

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

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

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 abs_f32x8(self, a: f32x8<Self>) -> f32x8<Self>

Compute the absolute value of each element.

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 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 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_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 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 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 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 splat_i8x32(self, val: i8) -> i8x32<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 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 splat_u8x32(self, val: u8) -> u8x32<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 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 set_mask8x32(self, a: &mut mask8x32<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

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 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 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 splat_i16x16(self, val: i16) -> i16x16<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 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 splat_u16x16(self, val: u16) -> u16x16<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 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 set_mask16x16(self, a: &mut mask16x16<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

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 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 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 splat_i32x8(self, val: i32) -> i32x8<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 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 splat_u32x8(self, val: u32) -> u32x8<Self>

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

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

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 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 set_mask32x8(self, a: &mut mask32x8<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

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 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 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 splat_f64x4(self, val: f64) -> f64x4<Self>

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

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

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

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 abs_f64x4(self, a: f64x4<Self>) -> f64x4<Self>

Compute the absolute value of each element.

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 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 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_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 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 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 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 splat_i64x4(self, val: i64) -> i64x4<Self>

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

fn slide_i64x4<const SHIFT: usize>( self, a: i64x4<Self>, b: i64x4<Self>, ) -> i64x4<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 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 splat_u64x4(self, val: u64) -> u64x4<Self>

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

fn slide_u64x4<const SHIFT: usize>( self, a: u64x4<Self>, b: u64x4<Self>, ) -> u64x4<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 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 set_mask64x4(self, a: &mut mask64x4<Self>, index: usize, value: bool)

Set one logical lane of a SIMD mask.

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 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 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::N 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::N 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::N 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 from_bitmask_mask8x64(self, bits: u64) -> mask8x64<Self>

Create a SIMD mask from a compact bitmask.

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

Set one logical lane of a SIMD mask.

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::N 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::N 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 to_bitmask_mask16x32(self, a: mask16x32<Self>) -> u64

Convert a SIMD mask to a compact bitmask.

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

Set one logical lane of a SIMD mask.

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::N 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::N 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 from_bitmask_mask32x16(self, bits: u64) -> mask32x16<Self>

Create a SIMD mask from a compact bitmask.

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

Set one logical lane of a SIMD mask.

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::N 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::N 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::N 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 from_bitmask_mask64x8(self, bits: u64) -> mask64x8<Self>

Create a SIMD mask from a compact bitmask.

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

Set one logical lane of a SIMD mask.

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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 splat_f32x16(self, val: f32) -> f32x16<Self>

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

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 abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self>

Compute the absolute value of each element.

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 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_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 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 splat_i8x64(self, val: i8) -> i8x64<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 splat_u8x64(self, val: u8) -> u8x64<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 splat_i16x32(self, val: i16) -> i16x32<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 splat_u16x32(self, val: u16) -> u16x32<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 splat_i32x16(self, val: i32) -> i32x16<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 splat_u32x16(self, val: u32) -> u32x16<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

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

Subtract two vectors element-wise, wrapping 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 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 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 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 splat_f64x8(self, val: f64) -> f64x8<Self>

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

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 abs_f64x8(self, a: f64x8<Self>) -> f64x8<Self>

Compute the absolute value of each element.

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 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_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 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 splat_i64x8(self, val: i64) -> i64x8<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

fn sub_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>

Subtract two vectors element-wise, wrapping 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 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 splat_u64x8(self, val: u64) -> u64x8<Self>

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

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

Add two vectors element-wise, wrapping on overflow.

fn sub_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>

Subtract two vectors element-wise, wrapping 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 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 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 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.