Struct Avx2 

pub struct Avx2 {
    pub avx2: Avx2,
}

Available on x86 or x86-64 only.

The SIMD token for the “AVX2” and “FMA” level.

Fields

avx2: Avx2

Implementations

impl Avx2

pub const unsafe fn new_unchecked() -> Self

Create a SIMD token.

Safety

The AVX2 and FMA CPU features must be available.

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 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 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 CPU features enabled.

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

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

fn load_array_f32x4(self, val: [f32; 4]) -> f32x4<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_f32x4(self, val: &[f32; 4]) -> f32x4<Self>

Create a SIMD vector from an array of the same length.

fn as_array_f32x4(self, a: f32x4<Self>) -> [f32; 4]

Convert a SIMD vector to an array.

fn as_array_ref_f32x4(self, a: &f32x4<Self>) -> &[f32; 4]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_f32x4(self, a: &mut f32x4<Self>) -> &mut [f32; 4]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_f32x4(self, a: f32x4<Self>, dest: &mut [f32; 4])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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 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 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 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 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 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 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 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 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 reinterpret_f64_f32x4(self, a: f32x4<Self>) -> f64x2<Self>

Reinterpret the bits of this vector as a vector of f64 elements.

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

Reinterpret the bits of this vector as a vector of i32 elements.

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

Reinterpret the bits of this vector as a vector of u8 elements.

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

Reinterpret the bits of this vector as a vector of u32 elements.

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 load_array_i8x16(self, val: [i8; 16]) -> i8x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i8x16(self, val: &[i8; 16]) -> i8x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i8x16(self, a: i8x16<Self>) -> [i8; 16]

Convert a SIMD vector to an array.

fn as_array_ref_i8x16(self, a: &i8x16<Self>) -> &[i8; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i8x16(self, a: &mut i8x16<Self>) -> &mut [i8; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i8x16(self, a: i8x16<Self>, dest: &mut [i8; 16])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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 reinterpret_u8_i8x16(self, a: i8x16<Self>) -> u8x16<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

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

Reinterpret the bits of this vector as a vector of u32 elements.

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

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

fn load_array_u8x16(self, val: [u8; 16]) -> u8x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u8x16(self, val: &[u8; 16]) -> u8x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u8x16(self, a: u8x16<Self>) -> [u8; 16]

Convert a SIMD vector to an array.

fn as_array_ref_u8x16(self, a: &u8x16<Self>) -> &[u8; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u8x16(self, a: &mut u8x16<Self>) -> &mut [u8; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u8x16(self, a: u8x16<Self>, dest: &mut [u8; 16])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

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

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

Zero-extend each element to a wider integer type.

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

Reinterpret the bits of this vector as a vector of u32 elements.

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

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

fn load_array_mask8x16(self, val: [i8; 16]) -> mask8x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask8x16(self, val: &[i8; 16]) -> mask8x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask8x16(self, a: mask8x16<Self>) -> [i8; 16]

Convert a SIMD vector to an array.

fn as_array_ref_mask8x16(self, a: &mask8x16<Self>) -> &[i8; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask8x16(self, a: &mut mask8x16<Self>) -> &mut [i8; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask8x16(self, a: mask8x16<Self>, dest: &mut [i8; 16])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask8x16<const SHIFT: usize>( self, a: mask8x16<Self>, b: mask8x16<Self>, ) -> mask8x16<Self>

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

fn slide_within_blocks_mask8x16<const SHIFT: usize>( self, a: mask8x16<Self>, b: mask8x16<Self>, ) -> mask8x16<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

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

Returns true if all elements in this mask are true (all ones).

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

Returns true if any elements in this mask are false (all zeroes).

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

Returns true if all elements in this mask are false (all zeroes).

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 load_array_i16x8(self, val: [i16; 8]) -> i16x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i16x8(self, val: &[i16; 8]) -> i16x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i16x8(self, a: i16x8<Self>) -> [i16; 8]

Convert a SIMD vector to an array.

fn as_array_ref_i16x8(self, a: &i16x8<Self>) -> &[i16; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i16x8(self, a: &mut i16x8<Self>) -> &mut [i16; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i16x8(self, a: i16x8<Self>, dest: &mut [i16; 8])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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 reinterpret_u8_i16x8(self, a: i16x8<Self>) -> u8x16<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

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

Reinterpret the bits of this vector as a vector of u32 elements.

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

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

fn load_array_u16x8(self, val: [u16; 8]) -> u16x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u16x8(self, val: &[u16; 8]) -> u16x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u16x8(self, a: u16x8<Self>) -> [u16; 8]

Convert a SIMD vector to an array.

fn as_array_ref_u16x8(self, a: &u16x8<Self>) -> &[u16; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u16x8(self, a: &mut u16x8<Self>) -> &mut [u16; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u16x8(self, a: u16x8<Self>, dest: &mut [u16; 8])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

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

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

Reinterpret the bits of this vector as a vector of u8 elements.

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

Reinterpret the bits of this vector as a vector of u32 elements.

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

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

fn load_array_mask16x8(self, val: [i16; 8]) -> mask16x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask16x8(self, val: &[i16; 8]) -> mask16x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask16x8(self, a: mask16x8<Self>) -> [i16; 8]

Convert a SIMD vector to an array.

fn as_array_ref_mask16x8(self, a: &mask16x8<Self>) -> &[i16; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask16x8(self, a: &mut mask16x8<Self>) -> &mut [i16; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask16x8(self, a: mask16x8<Self>, dest: &mut [i16; 8])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask16x8<const SHIFT: usize>( self, a: mask16x8<Self>, b: mask16x8<Self>, ) -> mask16x8<Self>

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

fn slide_within_blocks_mask16x8<const SHIFT: usize>( self, a: mask16x8<Self>, b: mask16x8<Self>, ) -> mask16x8<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

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

Returns true if all elements in this mask are true (all ones).

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

Returns true if any elements in this mask are false (all zeroes).

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

Returns true if all elements in this mask are false (all zeroes).

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 load_array_i32x4(self, val: [i32; 4]) -> i32x4<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i32x4(self, val: &[i32; 4]) -> i32x4<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i32x4(self, a: i32x4<Self>) -> [i32; 4]

Convert a SIMD vector to an array.

fn as_array_ref_i32x4(self, a: &i32x4<Self>) -> &[i32; 4]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i32x4(self, a: &mut i32x4<Self>) -> &mut [i32; 4]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i32x4(self, a: i32x4<Self>, dest: &mut [i32; 4])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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 reinterpret_u8_i32x4(self, a: i32x4<Self>) -> u8x16<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

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

Reinterpret the bits of this vector as a vector of u32 elements.

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 load_array_u32x4(self, val: [u32; 4]) -> u32x4<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u32x4(self, val: &[u32; 4]) -> u32x4<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u32x4(self, a: u32x4<Self>) -> [u32; 4]

Convert a SIMD vector to an array.

fn as_array_ref_u32x4(self, a: &u32x4<Self>) -> &[u32; 4]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u32x4(self, a: &mut u32x4<Self>) -> &mut [u32; 4]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u32x4(self, a: u32x4<Self>, dest: &mut [u32; 4])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

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

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

Reinterpret the bits of this vector as a vector of u8 elements.

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: i32) -> mask32x4<Self>

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

fn load_array_mask32x4(self, val: [i32; 4]) -> mask32x4<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask32x4(self, val: &[i32; 4]) -> mask32x4<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask32x4(self, a: mask32x4<Self>) -> [i32; 4]

Convert a SIMD vector to an array.

fn as_array_ref_mask32x4(self, a: &mask32x4<Self>) -> &[i32; 4]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask32x4(self, a: &mut mask32x4<Self>) -> &mut [i32; 4]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask32x4(self, a: mask32x4<Self>, dest: &mut [i32; 4])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask32x4<const SHIFT: usize>( self, a: mask32x4<Self>, b: mask32x4<Self>, ) -> mask32x4<Self>

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

fn slide_within_blocks_mask32x4<const SHIFT: usize>( self, a: mask32x4<Self>, b: mask32x4<Self>, ) -> mask32x4<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

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

Returns true if all elements in this mask are true (all ones).

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

Returns true if any elements in this mask are false (all zeroes).

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

Returns true if all elements in this mask are false (all zeroes).

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 load_array_f64x2(self, val: [f64; 2]) -> f64x2<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_f64x2(self, val: &[f64; 2]) -> f64x2<Self>

Create a SIMD vector from an array of the same length.

fn as_array_f64x2(self, a: f64x2<Self>) -> [f64; 2]

Convert a SIMD vector to an array.

fn as_array_ref_f64x2(self, a: &f64x2<Self>) -> &[f64; 2]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_f64x2(self, a: &mut f64x2<Self>) -> &mut [f64; 2]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_f64x2(self, a: f64x2<Self>, dest: &mut [f64; 2])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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 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 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 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 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 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 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 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 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 reinterpret_f32_f64x2(self, a: f64x2<Self>) -> f32x4<Self>

Reinterpret the bits of this vector as a vector of f32 elements.

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

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

fn load_array_mask64x2(self, val: [i64; 2]) -> mask64x2<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask64x2(self, val: &[i64; 2]) -> mask64x2<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask64x2(self, a: mask64x2<Self>) -> [i64; 2]

Convert a SIMD vector to an array.

fn as_array_ref_mask64x2(self, a: &mask64x2<Self>) -> &[i64; 2]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask64x2(self, a: &mut mask64x2<Self>) -> &mut [i64; 2]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask64x2(self, a: mask64x2<Self>, dest: &mut [i64; 2])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask64x2<const SHIFT: usize>( self, a: mask64x2<Self>, b: mask64x2<Self>, ) -> mask64x2<Self>

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

fn slide_within_blocks_mask64x2<const SHIFT: usize>( self, a: mask64x2<Self>, b: mask64x2<Self>, ) -> mask64x2<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

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

Returns true if all elements in this mask are true (all ones).

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

Returns true if any elements in this mask are false (all zeroes).

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

Returns true if all elements in this mask are false (all zeroes).

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 load_array_f32x8(self, val: [f32; 8]) -> f32x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_f32x8(self, val: &[f32; 8]) -> f32x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_f32x8(self, a: f32x8<Self>) -> [f32; 8]

Convert a SIMD vector to an array.

fn as_array_ref_f32x8(self, a: &f32x8<Self>) -> &[f32; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_f32x8(self, a: &mut f32x8<Self>) -> &mut [f32; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_f32x8(self, a: f32x8<Self>, dest: &mut [f32; 8])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_f32x8(self, a: u8x32<Self>) -> f32x8<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_f32x8(self, a: f32x8<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Compare two vectors element-wise for equality.

fn simd_lt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for less than.

fn simd_le_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

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

fn simd_ge_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

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

fn simd_gt_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> mask32x8<Self>

Compare two vectors element-wise for greater than.

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

Interleave the lower half elements of two vectors.

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

Interleave the upper half elements of two vectors.

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

Extract even-indexed elements from two vectors.

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

Extract odd-indexed elements from two vectors.

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

Reinterpret the bits of this vector as a vector of f64 elements.

fn reinterpret_i32_f32x8(self, a: f32x8<Self>) -> i32x8<Self>

Reinterpret the bits of this vector as a vector of i32 elements.

fn reinterpret_u8_f32x8(self, a: f32x8<Self>) -> u8x32<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_f32x8(self, a: f32x8<Self>) -> u32x8<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

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 load_array_i8x32(self, val: [i8; 32]) -> i8x32<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i8x32(self, val: &[i8; 32]) -> i8x32<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i8x32(self, a: i8x32<Self>) -> [i8; 32]

Convert a SIMD vector to an array.

fn as_array_ref_i8x32(self, a: &i8x32<Self>) -> &[i8; 32]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i8x32(self, a: &mut i8x32<Self>) -> &mut [i8; 32]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i8x32(self, a: i8x32<Self>, dest: &mut [i8; 32])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_i8x32(self, a: u8x32<Self>) -> i8x32<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_i8x32(self, a: i8x32<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Compare two vectors element-wise for equality.

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

Compare two vectors element-wise for less than.

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

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

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

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

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

Compare two vectors element-wise for greater than.

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

Interleave the lower half elements of two vectors.

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

Interleave the upper half elements of two vectors.

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

Extract even-indexed elements from two vectors.

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

Extract odd-indexed elements from two vectors.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_i8x32(self, a: i8x32<Self>) -> u32x8<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

fn splat_u8x32(self, val: u8) -> u8x32<Self>

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

fn load_array_u8x32(self, val: [u8; 32]) -> u8x32<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u8x32(self, val: &[u8; 32]) -> u8x32<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u8x32(self, a: u8x32<Self>) -> [u8; 32]

Convert a SIMD vector to an array.

fn as_array_ref_u8x32(self, a: &u8x32<Self>) -> &[u8; 32]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u8x32(self, a: &mut u8x32<Self>) -> &mut [u8; 32]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u8x32(self, a: u8x32<Self>, dest: &mut [u8; 32])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Compare two vectors element-wise for equality.

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

Compare two vectors element-wise for less than.

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

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

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

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

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

Compare two vectors element-wise for greater than.

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

Interleave the lower half elements of two vectors.

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

Interleave the upper half elements of two vectors.

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

Extract even-indexed elements from two vectors.

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

Extract odd-indexed elements from two vectors.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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>) -> u16x32<Self>

Zero-extend each element to a wider integer type.

fn reinterpret_u32_u8x32(self, a: u8x32<Self>) -> u32x8<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

fn splat_mask8x32(self, val: i8) -> mask8x32<Self>

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

fn load_array_mask8x32(self, val: [i8; 32]) -> mask8x32<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask8x32(self, val: &[i8; 32]) -> mask8x32<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask8x32(self, a: mask8x32<Self>) -> [i8; 32]

Convert a SIMD vector to an array.

fn as_array_ref_mask8x32(self, a: &mask8x32<Self>) -> &[i8; 32]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask8x32(self, a: &mut mask8x32<Self>) -> &mut [i8; 32]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask8x32(self, a: mask8x32<Self>, dest: &mut [i8; 32])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_mask8x32(self, a: u8x32<Self>) -> mask8x32<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_mask8x32(self, a: mask8x32<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask8x32<const SHIFT: usize>( self, a: mask8x32<Self>, b: mask8x32<Self>, ) -> mask8x32<Self>

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

fn slide_within_blocks_mask8x32<const SHIFT: usize>( self, a: mask8x32<Self>, b: mask8x32<Self>, ) -> mask8x32<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

fn all_true_mask8x32(self, a: mask8x32<Self>) -> bool

Returns true if all elements in this mask are true (all ones).

fn any_false_mask8x32(self, a: mask8x32<Self>) -> bool

Returns true if any elements in this mask are false (all zeroes).

fn all_false_mask8x32(self, a: mask8x32<Self>) -> bool

Returns true if all elements in this mask are false (all zeroes).

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 load_array_i16x16(self, val: [i16; 16]) -> i16x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i16x16(self, val: &[i16; 16]) -> i16x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i16x16(self, a: i16x16<Self>) -> [i16; 16]

Convert a SIMD vector to an array.

fn as_array_ref_i16x16(self, a: &i16x16<Self>) -> &[i16; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i16x16(self, a: &mut i16x16<Self>) -> &mut [i16; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i16x16(self, a: i16x16<Self>, dest: &mut [i16; 16])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_i16x16(self, a: u8x32<Self>) -> i16x16<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_i16x16(self, a: i16x16<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Compare two vectors element-wise for equality.

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

Compare two vectors element-wise for less than.

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

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

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

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

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

Compare two vectors element-wise for greater than.

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

Interleave the lower half elements of two vectors.

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

Interleave the upper half elements of two vectors.

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

Extract even-indexed elements from two vectors.

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

Extract odd-indexed elements from two vectors.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_i16x16(self, a: i16x16<Self>) -> u32x8<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

fn splat_u16x16(self, val: u16) -> u16x16<Self>

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

fn load_array_u16x16(self, val: [u16; 16]) -> u16x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u16x16(self, val: &[u16; 16]) -> u16x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u16x16(self, a: u16x16<Self>) -> [u16; 16]

Convert a SIMD vector to an array.

fn as_array_ref_u16x16(self, a: &u16x16<Self>) -> &[u16; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u16x16(self, a: &mut u16x16<Self>) -> &mut [u16; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u16x16(self, a: u16x16<Self>, dest: &mut [u16; 16])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_u16x16(self, a: u8x32<Self>) -> u16x16<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_u16x16(self, a: u16x16<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Compare two vectors element-wise for equality.

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

Compare two vectors element-wise for less than.

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

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

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

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

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

Compare two vectors element-wise for greater than.

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

Interleave the lower half elements of two vectors.

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

Interleave the upper half elements of two vectors.

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

Extract even-indexed elements from two vectors.

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

Extract odd-indexed elements from two vectors.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Truncate each element to a narrower integer type.

fn reinterpret_u8_u16x16(self, a: u16x16<Self>) -> u8x32<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_u16x16(self, a: u16x16<Self>) -> u32x8<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

fn splat_mask16x16(self, val: i16) -> mask16x16<Self>

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

fn load_array_mask16x16(self, val: [i16; 16]) -> mask16x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask16x16(self, val: &[i16; 16]) -> mask16x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask16x16(self, a: mask16x16<Self>) -> [i16; 16]

Convert a SIMD vector to an array.

fn as_array_ref_mask16x16(self, a: &mask16x16<Self>) -> &[i16; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask16x16(self, a: &mut mask16x16<Self>) -> &mut [i16; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask16x16(self, a: mask16x16<Self>, dest: &mut [i16; 16])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_mask16x16(self, a: u8x32<Self>) -> mask16x16<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_mask16x16(self, a: mask16x16<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask16x16<const SHIFT: usize>( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>

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

fn slide_within_blocks_mask16x16<const SHIFT: usize>( self, a: mask16x16<Self>, b: mask16x16<Self>, ) -> mask16x16<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

fn all_true_mask16x16(self, a: mask16x16<Self>) -> bool

Returns true if all elements in this mask are true (all ones).

fn any_false_mask16x16(self, a: mask16x16<Self>) -> bool

Returns true if any elements in this mask are false (all zeroes).

fn all_false_mask16x16(self, a: mask16x16<Self>) -> bool

Returns true if all elements in this mask are false (all zeroes).

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 load_array_i32x8(self, val: [i32; 8]) -> i32x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i32x8(self, val: &[i32; 8]) -> i32x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i32x8(self, a: i32x8<Self>) -> [i32; 8]

Convert a SIMD vector to an array.

fn as_array_ref_i32x8(self, a: &i32x8<Self>) -> &[i32; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i32x8(self, a: &mut i32x8<Self>) -> &mut [i32; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i32x8(self, a: i32x8<Self>, dest: &mut [i32; 8])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_i32x8(self, a: u8x32<Self>) -> i32x8<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_i32x8(self, a: i32x8<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Compare two vectors element-wise for equality.

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

Compare two vectors element-wise for less than.

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

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

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

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

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

Compare two vectors element-wise for greater than.

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

Interleave the lower half elements of two vectors.

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

Interleave the upper half elements of two vectors.

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

Extract even-indexed elements from two vectors.

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

Extract odd-indexed elements from two vectors.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_i32x8(self, a: i32x8<Self>) -> u32x8<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

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 load_array_u32x8(self, val: [u32; 8]) -> u32x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u32x8(self, val: &[u32; 8]) -> u32x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u32x8(self, a: u32x8<Self>) -> [u32; 8]

Convert a SIMD vector to an array.

fn as_array_ref_u32x8(self, a: &u32x8<Self>) -> &[u32; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u32x8(self, a: &mut u32x8<Self>) -> &mut [u32; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u32x8(self, a: u32x8<Self>, dest: &mut [u32; 8])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_u32x8(self, a: u8x32<Self>) -> u32x8<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_u32x8(self, a: u32x8<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Compare two vectors element-wise for equality.

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

Compare two vectors element-wise for less than.

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

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

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

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

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

Compare two vectors element-wise for greater than.

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

Interleave the lower half elements of two vectors.

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

Interleave the upper half elements of two vectors.

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

Extract even-indexed elements from two vectors.

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

Extract odd-indexed elements from two vectors.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Reinterpret the bits of this vector as a vector of u8 elements.

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: i32) -> mask32x8<Self>

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

fn load_array_mask32x8(self, val: [i32; 8]) -> mask32x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask32x8(self, val: &[i32; 8]) -> mask32x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask32x8(self, a: mask32x8<Self>) -> [i32; 8]

Convert a SIMD vector to an array.

fn as_array_ref_mask32x8(self, a: &mask32x8<Self>) -> &[i32; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask32x8(self, a: &mut mask32x8<Self>) -> &mut [i32; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask32x8(self, a: mask32x8<Self>, dest: &mut [i32; 8])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_mask32x8(self, a: u8x32<Self>) -> mask32x8<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_mask32x8(self, a: mask32x8<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask32x8<const SHIFT: usize>( self, a: mask32x8<Self>, b: mask32x8<Self>, ) -> mask32x8<Self>

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

fn slide_within_blocks_mask32x8<const SHIFT: usize>( self, a: mask32x8<Self>, b: mask32x8<Self>, ) -> mask32x8<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

fn all_true_mask32x8(self, a: mask32x8<Self>) -> bool

Returns true if all elements in this mask are true (all ones).

fn any_false_mask32x8(self, a: mask32x8<Self>) -> bool

Returns true if any elements in this mask are false (all zeroes).

fn all_false_mask32x8(self, a: mask32x8<Self>) -> bool

Returns true if all elements in this mask are false (all zeroes).

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 load_array_f64x4(self, val: [f64; 4]) -> f64x4<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_f64x4(self, val: &[f64; 4]) -> f64x4<Self>

Create a SIMD vector from an array of the same length.

fn as_array_f64x4(self, a: f64x4<Self>) -> [f64; 4]

Convert a SIMD vector to an array.

fn as_array_ref_f64x4(self, a: &f64x4<Self>) -> &[f64; 4]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_f64x4(self, a: &mut f64x4<Self>) -> &mut [f64; 4]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_f64x4(self, a: f64x4<Self>, dest: &mut [f64; 4])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_f64x4(self, a: u8x32<Self>) -> f64x4<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_f64x4(self, a: f64x4<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Compare two vectors element-wise for equality.

fn simd_lt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for less than.

fn simd_le_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

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

fn simd_ge_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

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

fn simd_gt_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> mask64x4<Self>

Compare two vectors element-wise for greater than.

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

Interleave the lower half elements of two vectors.

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

Interleave the upper half elements of two vectors.

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

Extract even-indexed elements from two vectors.

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

Extract odd-indexed elements from two vectors.

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

Reinterpret the bits of this vector as a vector of f32 elements.

fn splat_mask64x4(self, val: i64) -> mask64x4<Self>

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

fn load_array_mask64x4(self, val: [i64; 4]) -> mask64x4<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask64x4(self, val: &[i64; 4]) -> mask64x4<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask64x4(self, a: mask64x4<Self>) -> [i64; 4]

Convert a SIMD vector to an array.

fn as_array_ref_mask64x4(self, a: &mask64x4<Self>) -> &[i64; 4]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask64x4(self, a: &mut mask64x4<Self>) -> &mut [i64; 4]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask64x4(self, a: mask64x4<Self>, dest: &mut [i64; 4])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_mask64x4(self, a: u8x32<Self>) -> mask64x4<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_mask64x4(self, a: mask64x4<Self>) -> u8x32<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask64x4<const SHIFT: usize>( self, a: mask64x4<Self>, b: mask64x4<Self>, ) -> mask64x4<Self>

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

fn slide_within_blocks_mask64x4<const SHIFT: usize>( self, a: mask64x4<Self>, b: mask64x4<Self>, ) -> mask64x4<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

fn all_true_mask64x4(self, a: mask64x4<Self>) -> bool

Returns true if all elements in this mask are true (all ones).

fn any_false_mask64x4(self, a: mask64x4<Self>) -> bool

Returns true if any elements in this mask are false (all zeroes).

fn all_false_mask64x4(self, a: mask64x4<Self>) -> bool

Returns true if all elements in this mask are false (all zeroes).

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

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

fn load_array_f32x16(self, val: [f32; 16]) -> f32x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_f32x16(self, val: &[f32; 16]) -> f32x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_f32x16(self, a: f32x16<Self>) -> [f32; 16]

Convert a SIMD vector to an array.

fn as_array_ref_f32x16(self, a: &f32x16<Self>) -> &[f32; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_f32x16(self, a: &mut f32x16<Self>) -> &mut [f32; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_f32x16(self, a: f32x16<Self>, dest: &mut [f32; 16])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_f32x16(self, a: u8x64<Self>) -> f32x16<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_f32x16(self, a: f32x16<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Split a vector into two vectors of half the width.

fn reinterpret_f64_f32x16(self, a: f32x16<Self>) -> f64x8<Self>

Reinterpret the bits of this vector as a vector of f64 elements.

fn reinterpret_i32_f32x16(self, a: f32x16<Self>) -> i32x16<Self>

Reinterpret the bits of this vector as a vector of i32 elements.

fn load_interleaved_128_f32x16(self, src: &[f32; 16]) -> f32x16<Self>

Load elements from an array with 4-way interleaving.

fn store_interleaved_128_f32x16(self, a: f32x16<Self>, dest: &mut [f32; 16])

Store elements to an array with 4-way interleaving.

fn reinterpret_u8_f32x16(self, a: f32x16<Self>) -> u8x64<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_f32x16(self, a: f32x16<Self>) -> u32x16<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

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 load_array_i8x64(self, val: [i8; 64]) -> i8x64<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i8x64(self, val: &[i8; 64]) -> i8x64<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i8x64(self, a: i8x64<Self>) -> [i8; 64]

Convert a SIMD vector to an array.

fn as_array_ref_i8x64(self, a: &i8x64<Self>) -> &[i8; 64]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i8x64(self, a: &mut i8x64<Self>) -> &mut [i8; 64]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i8x64(self, a: i8x64<Self>, dest: &mut [i8; 64])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_i8x64(self, a: u8x64<Self>) -> i8x64<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_i8x64(self, a: i8x64<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Split a vector into two vectors of half the width.

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

Negate each element of the vector, wrapping on overflow.

fn reinterpret_u8_i8x64(self, a: i8x64<Self>) -> u8x64<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_i8x64(self, a: i8x64<Self>) -> u32x16<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

fn splat_u8x64(self, val: u8) -> u8x64<Self>

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

fn load_array_u8x64(self, val: [u8; 64]) -> u8x64<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u8x64(self, val: &[u8; 64]) -> u8x64<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u8x64(self, a: u8x64<Self>) -> [u8; 64]

Convert a SIMD vector to an array.

fn as_array_ref_u8x64(self, a: &u8x64<Self>) -> &[u8; 64]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u8x64(self, a: &mut u8x64<Self>) -> &mut [u8; 64]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u8x64(self, a: u8x64<Self>, dest: &mut [u8; 64])

Store a SIMD vector into an array of the same length.

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

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

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

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Split a vector into two vectors of half the width.

fn load_interleaved_128_u8x64(self, src: &[u8; 64]) -> u8x64<Self>

Load elements from an array with 4-way interleaving.

fn store_interleaved_128_u8x64(self, a: u8x64<Self>, dest: &mut [u8; 64])

Store elements to an array with 4-way interleaving.

fn reinterpret_u32_u8x64(self, a: u8x64<Self>) -> u32x16<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

fn splat_mask8x64(self, val: i8) -> mask8x64<Self>

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

fn load_array_mask8x64(self, val: [i8; 64]) -> mask8x64<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask8x64(self, val: &[i8; 64]) -> mask8x64<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask8x64(self, a: mask8x64<Self>) -> [i8; 64]

Convert a SIMD vector to an array.

fn as_array_ref_mask8x64(self, a: &mask8x64<Self>) -> &[i8; 64]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask8x64(self, a: &mut mask8x64<Self>) -> &mut [i8; 64]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask8x64(self, a: mask8x64<Self>, dest: &mut [i8; 64])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_mask8x64(self, a: u8x64<Self>) -> mask8x64<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_mask8x64(self, a: mask8x64<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask8x64<const SHIFT: usize>( self, a: mask8x64<Self>, b: mask8x64<Self>, ) -> mask8x64<Self>

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

fn slide_within_blocks_mask8x64<const SHIFT: usize>( self, a: mask8x64<Self>, b: mask8x64<Self>, ) -> mask8x64<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

fn all_true_mask8x64(self, a: mask8x64<Self>) -> bool

Returns true if all elements in this mask are true (all ones).

fn any_false_mask8x64(self, a: mask8x64<Self>) -> bool

Returns true if any elements in this mask are false (all zeroes).

fn all_false_mask8x64(self, a: mask8x64<Self>) -> bool

Returns true if all elements in this mask are false (all zeroes).

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

Split a vector into two vectors of half the width.

fn splat_i16x32(self, val: i16) -> i16x32<Self>

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

fn load_array_i16x32(self, val: [i16; 32]) -> i16x32<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i16x32(self, val: &[i16; 32]) -> i16x32<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i16x32(self, a: i16x32<Self>) -> [i16; 32]

Convert a SIMD vector to an array.

fn as_array_ref_i16x32(self, a: &i16x32<Self>) -> &[i16; 32]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i16x32(self, a: &mut i16x32<Self>) -> &mut [i16; 32]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i16x32(self, a: i16x32<Self>, dest: &mut [i16; 32])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_i16x32(self, a: u8x64<Self>) -> i16x32<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_i16x32(self, a: i16x32<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Split a vector into two vectors of half the width.

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

Negate each element of the vector, wrapping on overflow.

fn reinterpret_u8_i16x32(self, a: i16x32<Self>) -> u8x64<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_i16x32(self, a: i16x32<Self>) -> u32x16<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

fn splat_u16x32(self, val: u16) -> u16x32<Self>

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

fn load_array_u16x32(self, val: [u16; 32]) -> u16x32<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u16x32(self, val: &[u16; 32]) -> u16x32<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u16x32(self, a: u16x32<Self>) -> [u16; 32]

Convert a SIMD vector to an array.

fn as_array_ref_u16x32(self, a: &u16x32<Self>) -> &[u16; 32]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u16x32(self, a: &mut u16x32<Self>) -> &mut [u16; 32]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u16x32(self, a: u16x32<Self>, dest: &mut [u16; 32])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_u16x32(self, a: u8x64<Self>) -> u16x32<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_u16x32(self, a: u16x32<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Split a vector into two vectors of half the width.

fn load_interleaved_128_u16x32(self, src: &[u16; 32]) -> u16x32<Self>

Load elements from an array with 4-way interleaving.

fn store_interleaved_128_u16x32(self, a: u16x32<Self>, dest: &mut [u16; 32])

Store elements to an array with 4-way interleaving.

fn narrow_u16x32(self, a: u16x32<Self>) -> u8x32<Self>

Truncate each element to a narrower integer type.

fn reinterpret_u8_u16x32(self, a: u16x32<Self>) -> u8x64<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_u16x32(self, a: u16x32<Self>) -> u32x16<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

fn splat_mask16x32(self, val: i16) -> mask16x32<Self>

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

fn load_array_mask16x32(self, val: [i16; 32]) -> mask16x32<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask16x32(self, val: &[i16; 32]) -> mask16x32<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask16x32(self, a: mask16x32<Self>) -> [i16; 32]

Convert a SIMD vector to an array.

fn as_array_ref_mask16x32(self, a: &mask16x32<Self>) -> &[i16; 32]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask16x32(self, a: &mut mask16x32<Self>) -> &mut [i16; 32]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask16x32(self, a: mask16x32<Self>, dest: &mut [i16; 32])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_mask16x32(self, a: u8x64<Self>) -> mask16x32<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_mask16x32(self, a: mask16x32<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask16x32<const SHIFT: usize>( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>

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

fn slide_within_blocks_mask16x32<const SHIFT: usize>( self, a: mask16x32<Self>, b: mask16x32<Self>, ) -> mask16x32<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

fn all_true_mask16x32(self, a: mask16x32<Self>) -> bool

Returns true if all elements in this mask are true (all ones).

fn any_false_mask16x32(self, a: mask16x32<Self>) -> bool

Returns true if any elements in this mask are false (all zeroes).

fn all_false_mask16x32(self, a: mask16x32<Self>) -> bool

Returns true if all elements in this mask are false (all zeroes).

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

Split a vector into two vectors of half the width.

fn splat_i32x16(self, val: i32) -> i32x16<Self>

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

fn load_array_i32x16(self, val: [i32; 16]) -> i32x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_i32x16(self, val: &[i32; 16]) -> i32x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_i32x16(self, a: i32x16<Self>) -> [i32; 16]

Convert a SIMD vector to an array.

fn as_array_ref_i32x16(self, a: &i32x16<Self>) -> &[i32; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_i32x16(self, a: &mut i32x16<Self>) -> &mut [i32; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_i32x16(self, a: i32x16<Self>, dest: &mut [i32; 16])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_i32x16(self, a: u8x64<Self>) -> i32x16<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_i32x16(self, a: i32x16<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Split a vector into two vectors of half the width.

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

Negate each element of the vector, wrapping on overflow.

fn reinterpret_u8_i32x16(self, a: i32x16<Self>) -> u8x64<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

fn reinterpret_u32_i32x16(self, a: i32x16<Self>) -> u32x16<Self>

Reinterpret the bits of this vector as a vector of u32 elements.

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 load_array_u32x16(self, val: [u32; 16]) -> u32x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_u32x16(self, val: &[u32; 16]) -> u32x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_u32x16(self, a: u32x16<Self>) -> [u32; 16]

Convert a SIMD vector to an array.

fn as_array_ref_u32x16(self, a: &u32x16<Self>) -> &[u32; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_u32x16(self, a: &mut u32x16<Self>) -> &mut [u32; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_u32x16(self, a: u32x16<Self>, dest: &mut [u32; 16])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_u32x16(self, a: u8x64<Self>) -> u32x16<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_u32x16(self, a: u32x16<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Return the element-wise minimum of two vectors.

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

Return the element-wise maximum of two vectors.

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

Split a vector into two vectors of half the width.

fn load_interleaved_128_u32x16(self, src: &[u32; 16]) -> u32x16<Self>

Load elements from an array with 4-way interleaving.

fn store_interleaved_128_u32x16(self, a: u32x16<Self>, dest: &mut [u32; 16])

Store elements to an array with 4-way interleaving.

fn reinterpret_u8_u32x16(self, a: u32x16<Self>) -> u8x64<Self>

Reinterpret the bits of this vector as a vector of u8 elements.

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: i32) -> mask32x16<Self>

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

fn load_array_mask32x16(self, val: [i32; 16]) -> mask32x16<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask32x16(self, val: &[i32; 16]) -> mask32x16<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask32x16(self, a: mask32x16<Self>) -> [i32; 16]

Convert a SIMD vector to an array.

fn as_array_ref_mask32x16(self, a: &mask32x16<Self>) -> &[i32; 16]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask32x16(self, a: &mut mask32x16<Self>) -> &mut [i32; 16]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask32x16(self, a: mask32x16<Self>, dest: &mut [i32; 16])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_mask32x16(self, a: u8x64<Self>) -> mask32x16<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_mask32x16(self, a: mask32x16<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask32x16<const SHIFT: usize>( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>

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

fn slide_within_blocks_mask32x16<const SHIFT: usize>( self, a: mask32x16<Self>, b: mask32x16<Self>, ) -> mask32x16<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

fn all_true_mask32x16(self, a: mask32x16<Self>) -> bool

Returns true if all elements in this mask are true (all ones).

fn any_false_mask32x16(self, a: mask32x16<Self>) -> bool

Returns true if any elements in this mask are false (all zeroes).

fn all_false_mask32x16(self, a: mask32x16<Self>) -> bool

Returns true if all elements in this mask are false (all zeroes).

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

Split a vector into two vectors of half the width.

fn splat_f64x8(self, val: f64) -> f64x8<Self>

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

fn load_array_f64x8(self, val: [f64; 8]) -> f64x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_f64x8(self, val: &[f64; 8]) -> f64x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_f64x8(self, a: f64x8<Self>) -> [f64; 8]

Convert a SIMD vector to an array.

fn as_array_ref_f64x8(self, a: &f64x8<Self>) -> &[f64; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_f64x8(self, a: &mut f64x8<Self>) -> &mut [f64; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_f64x8(self, a: f64x8<Self>, dest: &mut [f64; 8])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_f64x8(self, a: u8x64<Self>) -> f64x8<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_f64x8(self, a: f64x8<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

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

Split a vector into two vectors of half the width.

fn reinterpret_f32_f64x8(self, a: f64x8<Self>) -> f32x16<Self>

Reinterpret the bits of this vector as a vector of f32 elements.

fn splat_mask64x8(self, val: i64) -> mask64x8<Self>

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

fn load_array_mask64x8(self, val: [i64; 8]) -> mask64x8<Self>

Create a SIMD vector from an array of the same length.

fn load_array_ref_mask64x8(self, val: &[i64; 8]) -> mask64x8<Self>

Create a SIMD vector from an array of the same length.

fn as_array_mask64x8(self, a: mask64x8<Self>) -> [i64; 8]

Convert a SIMD vector to an array.

fn as_array_ref_mask64x8(self, a: &mask64x8<Self>) -> &[i64; 8]

Project a reference to a SIMD vector to a reference to the equivalent array.

fn as_array_mut_mask64x8(self, a: &mut mask64x8<Self>) -> &mut [i64; 8]

Project a mutable reference to a SIMD vector to a mutable reference to the equivalent array.

fn store_array_mask64x8(self, a: mask64x8<Self>, dest: &mut [i64; 8])

Store a SIMD vector into an array of the same length.

fn cvt_from_bytes_mask64x8(self, a: u8x64<Self>) -> mask64x8<Self>

Reinterpret a vector of bytes as a SIMD vector of a given type, with the equivalent byte length.

fn cvt_to_bytes_mask64x8(self, a: mask64x8<Self>) -> u8x64<Self>

Reinterpret a SIMD vector as a vector of bytes, with the equivalent byte length.

fn slide_mask64x8<const SHIFT: usize>( self, a: mask64x8<Self>, b: mask64x8<Self>, ) -> mask64x8<Self>

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

fn slide_within_blocks_mask64x8<const SHIFT: usize>( self, a: mask64x8<Self>, b: mask64x8<Self>, ) -> mask64x8<Self>

Like slide, but operates independently on each 128-bit block.

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 elements in this mask are true (all ones).

fn all_true_mask64x8(self, a: mask64x8<Self>) -> bool

Returns true if all elements in this mask are true (all ones).

fn any_false_mask64x8(self, a: mask64x8<Self>) -> bool

Returns true if any elements in this mask are false (all zeroes).

fn all_false_mask64x8(self, a: mask64x8<Self>) -> bool

Returns true if all elements in this mask are false (all zeroes).

fn split_mask64x8(self, a: mask64x8<Self>) -> (mask64x4<Self>, mask64x4<Self>)

Split a vector into two vectors of half the width.

impl Copy for Avx2