Struct thermite::backends::avx2::AVX2

pub struct AVX2;

Trait Implementations

impl Clone for AVX2

fn clone(&self) -> AVX2

Returns a copy 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 Hash for AVX2

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<AVX2> for AVX2

fn eq(&self, other: &AVX2) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Shl<<AVX2 as Simd>::Vu32> for f32x8<AVX2>

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the << operation.

impl Shl<<AVX2 as Simd>::Vu32> for f64x8<AVX2>

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the << operation.

impl Shl<<AVX2 as Simd>::Vu32> for i32x8<AVX2>

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the << operation.

impl Shl<<AVX2 as Simd>::Vu32> for i64x8<AVX2>

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the << operation.

impl Shl<<AVX2 as Simd>::Vu32> for u32x8<AVX2>

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the << operation.

impl Shl<<AVX2 as Simd>::Vu32> for u64x8<AVX2>

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the << operation.

impl ShlAssign<<AVX2 as Simd>::Vu32> for f32x8<AVX2>

fn shl_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the <<= operation.

impl ShlAssign<<AVX2 as Simd>::Vu32> for f64x8<AVX2>

fn shl_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the <<= operation.

impl ShlAssign<<AVX2 as Simd>::Vu32> for i32x8<AVX2>

fn shl_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the <<= operation.

impl ShlAssign<<AVX2 as Simd>::Vu32> for i64x8<AVX2>

fn shl_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the <<= operation.

impl ShlAssign<<AVX2 as Simd>::Vu32> for u32x8<AVX2>

fn shl_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the <<= operation.

impl ShlAssign<<AVX2 as Simd>::Vu32> for u64x8<AVX2>

fn shl_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the <<= operation.

impl Shr<<AVX2 as Simd>::Vu32> for f32x8<AVX2>

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the >> operation.

impl Shr<<AVX2 as Simd>::Vu32> for f64x8<AVX2>

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the >> operation.

impl Shr<<AVX2 as Simd>::Vu32> for i32x8<AVX2>

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the >> operation.

impl Shr<<AVX2 as Simd>::Vu32> for i64x8<AVX2>

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the >> operation.

impl Shr<<AVX2 as Simd>::Vu32> for u32x8<AVX2>

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the >> operation.

impl Shr<<AVX2 as Simd>::Vu32> for u64x8<AVX2>

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: <AVX2 as Simd>::Vu32) -> Self

Performs the >> operation.

impl ShrAssign<<AVX2 as Simd>::Vu32> for f32x8<AVX2>

fn shr_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the >>= operation.

impl ShrAssign<<AVX2 as Simd>::Vu32> for f64x8<AVX2>

fn shr_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the >>= operation.

impl ShrAssign<<AVX2 as Simd>::Vu32> for i32x8<AVX2>

fn shr_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the >>= operation.

impl ShrAssign<<AVX2 as Simd>::Vu32> for i64x8<AVX2>

fn shr_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the >>= operation.

impl ShrAssign<<AVX2 as Simd>::Vu32> for u32x8<AVX2>

fn shr_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the >>= operation.

impl ShrAssign<<AVX2 as Simd>::Vu32> for u64x8<AVX2>

fn shr_assign(&mut self, rhs: <AVX2 as Simd>::Vu32)

Performs the >>= operation.

impl Simd for AVX2

const INSTRSET: SimdInstructionSet

type Vi32 = i32x8<AVX2>

32-bit signed integer vector

type Vi64 = i64x8<AVX2>

64-bit signed integer vector

type Vu32 = u32x8<AVX2>

32-bit unsigned integer vector

type Vu64 = u64x8<AVX2>

64-bit unsigned integer vector

type Vf32 = f32x8<AVX2>

Single-precision 32-bit floating point vector

type Vf64 = f64x8<AVX2>

Double-precision 64-bit floating point vector

type Vusize = u64x8<AVX2>

type Visize = i64x8<AVX2>

impl SimdBitwise<AVX2> for f32x8<AVX2>

fn and_not(self, other: Self) -> Self

Computes !self & other, may be more performant than the naive version

const FULL_BITMASK: u16

Bitmask corresponding to all lanes of the mask being truthy.

fn bitmask(self) -> u16

Returns an integer where each bit corresponds to the binary truthy-ness of each lane from the mask.

unsafe fn _mm_not(self) -> Self

unsafe fn _mm_bitand(self, rhs: Self) -> Self

unsafe fn _mm_bitor(self, rhs: Self) -> Self

unsafe fn _mm_bitxor(self, rhs: Self) -> Self

unsafe fn _mm_shr(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shl(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shli(self, count: u32) -> Self

unsafe fn _mm_shri(self, count: u32) -> Self

impl SimdBitwise<AVX2> for f64x8<AVX2>

fn and_not(self, other: Self) -> Self

Computes !self & other, may be more performant than the naive version

const FULL_BITMASK: u16

Bitmask corresponding to all lanes of the mask being truthy.

fn bitmask(self) -> u16

Returns an integer where each bit corresponds to the binary truthy-ness of each lane from the mask.

unsafe fn _mm_not(self) -> Self

unsafe fn _mm_bitand(self, rhs: Self) -> Self

unsafe fn _mm_bitor(self, rhs: Self) -> Self

unsafe fn _mm_bitxor(self, rhs: Self) -> Self

unsafe fn _mm_shr(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shl(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shli(self, count: u32) -> Self

unsafe fn _mm_shri(self, count: u32) -> Self

impl SimdBitwise<AVX2> for i32x8<AVX2>

fn and_not(self, other: Self) -> Self

Computes !self & other, may be more performant than the naive version

const FULL_BITMASK: u16

Bitmask corresponding to all lanes of the mask being truthy.

fn bitmask(self) -> u16

Returns an integer where each bit corresponds to the binary truthy-ness of each lane from the mask.

unsafe fn _mm_not(self) -> Self

unsafe fn _mm_bitand(self, rhs: Self) -> Self

unsafe fn _mm_bitor(self, rhs: Self) -> Self

unsafe fn _mm_bitxor(self, rhs: Self) -> Self

unsafe fn _mm_shr(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shl(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shli(self, count: u32) -> Self

unsafe fn _mm_shri(self, count: u32) -> Self

impl SimdBitwise<AVX2> for i64x8<AVX2>

fn and_not(self, other: Self) -> Self

Computes !self & other, may be more performant than the naive version

const FULL_BITMASK: u16

Bitmask corresponding to all lanes of the mask being truthy.

fn bitmask(self) -> u16

Returns an integer where each bit corresponds to the binary truthy-ness of each lane from the mask.

unsafe fn _mm_not(self) -> Self

unsafe fn _mm_bitand(self, rhs: Self) -> Self

unsafe fn _mm_bitor(self, rhs: Self) -> Self

unsafe fn _mm_bitxor(self, rhs: Self) -> Self

unsafe fn _mm_shr(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shl(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shli(self, count: u32) -> Self

unsafe fn _mm_shri(self, count: u32) -> Self

impl SimdBitwise<AVX2> for u32x8<AVX2>

fn and_not(self, other: Self) -> Self

Computes !self & other, may be more performant than the naive version

const FULL_BITMASK: u16

Bitmask corresponding to all lanes of the mask being truthy.

fn bitmask(self) -> u16

Returns an integer where each bit corresponds to the binary truthy-ness of each lane from the mask.

unsafe fn _mm_not(self) -> Self

unsafe fn _mm_bitand(self, rhs: Self) -> Self

unsafe fn _mm_bitor(self, rhs: Self) -> Self

unsafe fn _mm_bitxor(self, rhs: Self) -> Self

unsafe fn _mm_shr(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shl(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shli(self, count: u32) -> Self

unsafe fn _mm_shri(self, count: u32) -> Self

impl SimdBitwise<AVX2> for u64x8<AVX2>

fn and_not(self, other: Self) -> Self

Computes !self & other, may be more performant than the naive version

const FULL_BITMASK: u16

Bitmask corresponding to all lanes of the mask being truthy.

fn bitmask(self) -> u16

Returns an integer where each bit corresponds to the binary truthy-ness of each lane from the mask.

unsafe fn _mm_not(self) -> Self

unsafe fn _mm_bitand(self, rhs: Self) -> Self

unsafe fn _mm_bitor(self, rhs: Self) -> Self

unsafe fn _mm_bitxor(self, rhs: Self) -> Self

unsafe fn _mm_shr(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shl(self, count: u32x8<AVX2>) -> Self

unsafe fn _mm_shli(self, count: u32) -> Self

unsafe fn _mm_shri(self, count: u32) -> Self

impl SimdFloatVector<AVX2> for f32x8<AVX2>

type Vu = u32x8<AVX2>

type Vi = i32x8<AVX2>

fn epsilon() -> Self

fn infinity() -> Self

fn neg_infinity() -> Self

fn neg_zero() -> Self

fn nan() -> Self

unsafe fn load_f16_unaligned_unchecked(src: *const f16) -> Self

unsafe fn store_f16_unaligned_unchecked(&self, dst: *mut f16)

unsafe fn to_int_fast(self) -> Self::Vi

Can convert to a signed integer faster than a regular cast, but may not provide correct results above a certain range.

unsafe fn to_uint_fast(self) -> Self::Vu

Can convert to an unsigned integer faster than a regular cast, but may not provide correct results above a certain range.

fn sum(self) -> Self::Element

Compute the horizontal sum of all elements

fn product(self) -> Self::Element

Compute the horizontal product of all elements

fn mul_add(self, m: Self, a: Self) -> Self

Fused multiply-add

fn mul_sub(self, m: Self, s: Self) -> Self

Fused multiply-subtract

fn nmul_add(self, m: Self, a: Self) -> Self

Fused negated multiply-add

fn nmul_sub(self, m: Self, s: Self) -> Self

Fused negated multiply-subtract

fn mul_adde(self, m: Self, a: Self) -> Self

Fused multiply-add, with at worst precision equal to x * m + a

fn mul_sube(self, m: Self, s: Self) -> Self

Fused multiply-subtract, with at worst precision equal to x * m - s

fn nmul_adde(self, m: Self, a: Self) -> Self

Fused negated multiply-add, with at worst precision equal to a - x * m

fn nmul_sube(self, m: Self, s: Self) -> Self

Fused negated multiply-subtract, with at worst precision equal to -x * m - s

fn floor(self) -> Self

Rounds downward towards negative infinity.

fn ceil(self) -> Self

Rounds upwards towards positive infinity.

fn round(self) -> Self

Rounds to the nearest representable integer.

fn trunc(self) -> Self

Truncates any rational value towards zero

fn sqrt(self) -> Self

Calculates the square-root of each element in the vector.

fn rsqrt(self) -> Self

Compute the approximate reciprocal of the square root 1/sqrt(x)

fn rcp(self) -> Self

Computes the approximate reciprocal/inverse of each value

fn is_subnormal(self) -> Mask<AVX2, Self>

fn is_zero_or_subnormal(self) -> Mask<AVX2, Self>

fn load_f16_unaligned(src: &[f16]) -> Self

Load half-precision floats and up-convert them into Self

fn store_f16_unaligned(&self, dst: &mut [f16])

Down-convert self into half-precision and store

fn as_ord_int(self) -> Self::Vi

Converts floating-point values to integer values that can be used for total equality, ordering and hashing.

fn combine_sign(self, sign: Self) -> Self

Same as self * sign.signum() or select(sign_bit(sign), -self, self), but more efficient where possible.

fn fract(self) -> Self

Returns the fractional part of a number (the part between 0 and ±1)

fn approx_eq(self, other: Self, tolerance: Self) -> Mask<S, Self>

fn clamp(self, min: Self, max: Self) -> Self

fn saturate(self) -> Self

Clamps self to between 0 and 1

fn is_finite(self) -> Mask<S, Self>

fn is_infinite(self) -> Mask<S, Self>

fn is_normal(self) -> Mask<S, Self>

fn is_nan(self) -> Mask<S, Self>

impl SimdFloatVector<AVX2> for f64x8<AVX2>

type Vu = u64x8<AVX2>

type Vi = i64x8<AVX2>

fn epsilon() -> Self

fn infinity() -> Self

fn neg_infinity() -> Self

fn neg_zero() -> Self

fn nan() -> Self

unsafe fn load_f16_unaligned_unchecked(src: *const f16) -> Self

unsafe fn store_f16_unaligned_unchecked(&self, dst: *mut f16)

unsafe fn to_int_fast(self) -> Self::Vi

Can convert to a signed integer faster than a regular cast, but may not provide correct results above a certain range.

unsafe fn to_uint_fast(self) -> Self::Vu

Can convert to an unsigned integer faster than a regular cast, but may not provide correct results above a certain range.

fn sum(self) -> Self::Element

Compute the horizontal sum of all elements

fn product(self) -> Self::Element

Compute the horizontal product of all elements

fn mul_add(self, m: Self, a: Self) -> Self

Fused multiply-add

fn mul_sub(self, m: Self, s: Self) -> Self

Fused multiply-subtract

fn nmul_add(self, m: Self, a: Self) -> Self

Fused negated multiply-add

fn nmul_sub(self, m: Self, s: Self) -> Self

Fused negated multiply-subtract

fn mul_adde(self, m: Self, a: Self) -> Self

Fused multiply-add, with at worst precision equal to x * m + a

fn mul_sube(self, m: Self, s: Self) -> Self

Fused multiply-subtract, with at worst precision equal to x * m - s

fn nmul_adde(self, m: Self, a: Self) -> Self

Fused negated multiply-add, with at worst precision equal to a - x * m

fn nmul_sube(self, m: Self, s: Self) -> Self

Fused negated multiply-subtract, with at worst precision equal to -x * m - s

fn floor(self) -> Self

Rounds downward towards negative infinity.

fn ceil(self) -> Self

Rounds upwards towards positive infinity.

fn round(self) -> Self

Rounds to the nearest representable integer.

fn trunc(self) -> Self

Truncates any rational value towards zero

fn sqrt(self) -> Self

Calculates the square-root of each element in the vector.

fn is_subnormal(self) -> Mask<AVX2, Self>

fn is_zero_or_subnormal(self) -> Mask<AVX2, Self>

fn load_f16_unaligned(src: &[f16]) -> Self

Load half-precision floats and up-convert them into Self

fn store_f16_unaligned(&self, dst: &mut [f16])

Down-convert self into half-precision and store

fn as_ord_int(self) -> Self::Vi

Converts floating-point values to integer values that can be used for total equality, ordering and hashing.

fn combine_sign(self, sign: Self) -> Self

Same as self * sign.signum() or select(sign_bit(sign), -self, self), but more efficient where possible.

fn fract(self) -> Self

Returns the fractional part of a number (the part between 0 and ±1)

fn rsqrt(self) -> Self

Compute the approximate reciprocal of the square root 1/sqrt(x)

fn rcp(self) -> Self

Computes the approximate reciprocal/inverse of each value

fn approx_eq(self, other: Self, tolerance: Self) -> Mask<S, Self>

fn clamp(self, min: Self, max: Self) -> Self

fn saturate(self) -> Self

Clamps self to between 0 and 1

fn is_finite(self) -> Mask<S, Self>

fn is_infinite(self) -> Mask<S, Self>

fn is_normal(self) -> Mask<S, Self>

fn is_nan(self) -> Mask<S, Self>

impl SimdFromBits<AVX2, u32x8<AVX2>> for f32x8<AVX2>

fn from_bits(bits: u32x8<AVX2>) -> Self

impl SimdFromBits<AVX2, u32x8<AVX2>> for i32x8<AVX2>

fn from_bits(bits: u32x8<AVX2>) -> Self

impl SimdFromBits<AVX2, u64x8<AVX2>> for f64x8<AVX2>

fn from_bits(bits: u64x8<AVX2>) -> Self

impl SimdFromBits<AVX2, u64x8<AVX2>> for i64x8<AVX2>

fn from_bits(bits: u64x8<AVX2>) -> Self

impl SimdFromCast<AVX2, f32x8<AVX2>> for f64x8<AVX2>

fn from_cast(from: f32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f32x8<AVX2>> for i32x8<AVX2>

fn from_cast(from: f32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f32x8<AVX2>> for i64x8<AVX2>

fn from_cast(from: f32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f32x8<AVX2>> for u32x8<AVX2>

fn from_cast(from: f32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f32x8<AVX2>> for u64x8<AVX2>

fn from_cast(from: f32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f64x8<AVX2>> for f32x8<AVX2>

fn from_cast(from: f64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f64x8<AVX2>> for i32x8<AVX2>

fn from_cast(from: f64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f64x8<AVX2>> for i64x8<AVX2>

fn from_cast(from: f64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f64x8<AVX2>> for u32x8<AVX2>

fn from_cast(from: f64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, f64x8<AVX2>> for u64x8<AVX2>

fn from_cast(from: f64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, f64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i32x8<AVX2>> for f32x8<AVX2>

fn from_cast(from: i32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i32x8<AVX2>> for f64x8<AVX2>

fn from_cast(from: i32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i32x8<AVX2>> for i64x8<AVX2>

fn from_cast(from: i32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i32x8<AVX2>> for u32x8<AVX2>

fn from_cast(from: i32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i32x8<AVX2>> for u64x8<AVX2>

fn from_cast(from: i32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i64x8<AVX2>> for f32x8<AVX2>

fn from_cast(from: i64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i64x8<AVX2>> for f64x8<AVX2>

fn from_cast(from: i64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i64x8<AVX2>> for i32x8<AVX2>

fn from_cast(from: i64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i64x8<AVX2>> for u32x8<AVX2>

fn from_cast(from: i64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, i64x8<AVX2>> for u64x8<AVX2>

fn from_cast(from: i64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, i64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u32x8<AVX2>> for f32x8<AVX2>

fn from_cast(from: u32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u32x8<AVX2>> for f64x8<AVX2>

fn from_cast(from: u32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u32x8<AVX2>> for i32x8<AVX2>

fn from_cast(from: u32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u32x8<AVX2>> for i64x8<AVX2>

fn from_cast(from: u32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u32x8<AVX2>> for u64x8<AVX2>

fn from_cast(from: u32x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u32x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u64x8<AVX2>> for f32x8<AVX2>

fn from_cast(from: u64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u64x8<AVX2>> for f64x8<AVX2>

fn from_cast(from: u64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u64x8<AVX2>> for i32x8<AVX2>

fn from_cast(from: u64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u64x8<AVX2>> for i64x8<AVX2>

fn from_cast(from: u64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdFromCast<AVX2, u64x8<AVX2>> for u32x8<AVX2>

fn from_cast(from: u64x8<AVX2>) -> Self

Casts one vector to another, performing proper numeric conversions on each element.

fn from_cast_mask(from: Mask<AVX2, u64x8<AVX2>>) -> Mask<AVX2, Self>

Casts one mask to another, not caring about the value types, but rather expanding or truncating the mask bits as efficiently as possible.

impl SimdIntVector<AVX2> for i32x8<AVX2>

fn saturating_add(self, rhs: Self) -> Self

Saturating addition, will not wrap

fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction, will not wrap

fn wrapping_sum(self) -> Self::Element

Sum all lanes together, wrapping the result if it can’t fit in T

fn wrapping_product(self) -> Self::Element

Multiply all lanes together, wrapping the result if it can’t fit in T

fn rolv(self, cnt: u32x8<AVX2>) -> Self

Rotates the bits in each lane to the left (towards HSB) by the number of bits specified in the corresponding lane of cnt

fn rorv(self, cnt: u32x8<AVX2>) -> Self

Rotates the bits in each lane to the right (towards LSB) by the number of bits specified in the corresponding lane of cnt

fn reverse_bits(self) -> Self

Reverses the bits of each lane in the vector.

fn count_ones(self) -> Self

Counts the number of 1 bits in each lane of the vector.

fn leading_zeros(self) -> Self

Counts the number of leading zeros in each lane of the vector.

fn trailing_zeros(self) -> Self

Counts the number of trailing zeros in each lane of the vector.

fn rol(self, cnt: u32) -> Self

Rotates the bits in each lane to the left (towards HSB) by the number of bits specified in cnt

fn ror(self, cnt: u32) -> Self

Rotates the bits in each lane to the right (towards LSB) by the number of bits specified in cnt

fn count_zeros(self) -> Self

Counts the number of 0 bits in each lane of the vector.

fn leading_ones(self) -> Self

Counts the number of leading ones in each lane of the vector.

fn trailing_ones(self) -> Self

Counts the number of trailing ones in each lane of the vector.

impl SimdIntVector<AVX2> for i64x8<AVX2>

fn saturating_add(self, rhs: Self) -> Self

Saturating addition, will not wrap

fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction, will not wrap

fn wrapping_sum(self) -> Self::Element

Sum all lanes together, wrapping the result if it can’t fit in T

fn wrapping_product(self) -> Self::Element

Multiply all lanes together, wrapping the result if it can’t fit in T

fn rolv(self, cnt: u32x8<AVX2>) -> Self

Rotates the bits in each lane to the left (towards HSB) by the number of bits specified in the corresponding lane of cnt

fn rorv(self, cnt: u32x8<AVX2>) -> Self

Rotates the bits in each lane to the right (towards LSB) by the number of bits specified in the corresponding lane of cnt

fn reverse_bits(self) -> Self

Reverses the bits of each lane in the vector.

fn count_ones(self) -> Self

Counts the number of 1 bits in each lane of the vector.

fn leading_zeros(self) -> Self

Counts the number of leading zeros in each lane of the vector.

fn trailing_zeros(self) -> Self

Counts the number of trailing zeros in each lane of the vector.

fn rol(self, cnt: u32) -> Self

Rotates the bits in each lane to the left (towards HSB) by the number of bits specified in cnt

fn ror(self, cnt: u32) -> Self

Rotates the bits in each lane to the right (towards LSB) by the number of bits specified in cnt

fn count_zeros(self) -> Self

Counts the number of 0 bits in each lane of the vector.

fn leading_ones(self) -> Self

Counts the number of leading ones in each lane of the vector.

fn trailing_ones(self) -> Self

Counts the number of trailing ones in each lane of the vector.

impl SimdIntVector<AVX2> for u32x8<AVX2>

fn saturating_add(self, rhs: Self) -> Self

Saturating addition, will not wrap

fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction, will not wrap

fn wrapping_sum(self) -> Self::Element

Sum all lanes together, wrapping the result if it can’t fit in T

fn wrapping_product(self) -> Self::Element

Multiply all lanes together, wrapping the result if it can’t fit in T

fn rolv(self, cnt: u32x8<AVX2>) -> Self

Rotates the bits in each lane to the left (towards HSB) by the number of bits specified in the corresponding lane of cnt

fn rorv(self, cnt: u32x8<AVX2>) -> Self

Rotates the bits in each lane to the right (towards LSB) by the number of bits specified in the corresponding lane of cnt

fn reverse_bits(self) -> Self

Reverses the bits of each lane in the vector.

fn count_ones(self) -> Self

Counts the number of 1 bits in each lane of the vector.

fn leading_zeros(self) -> Self

Counts the number of leading zeros in each lane of the vector.

fn trailing_zeros(self) -> Self

Counts the number of trailing zeros in each lane of the vector.

fn rol(self, cnt: u32) -> Self

Rotates the bits in each lane to the left (towards HSB) by the number of bits specified in cnt

fn ror(self, cnt: u32) -> Self

Rotates the bits in each lane to the right (towards LSB) by the number of bits specified in cnt

fn count_zeros(self) -> Self

Counts the number of 0 bits in each lane of the vector.

fn leading_ones(self) -> Self

Counts the number of leading ones in each lane of the vector.

fn trailing_ones(self) -> Self

Counts the number of trailing ones in each lane of the vector.

impl SimdIntVector<AVX2> for u64x8<AVX2>

fn saturating_add(self, rhs: Self) -> Self

Saturating addition, will not wrap

fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction, will not wrap

fn wrapping_sum(self) -> Self::Element

Sum all lanes together, wrapping the result if it can’t fit in T

fn wrapping_product(self) -> Self::Element

Multiply all lanes together, wrapping the result if it can’t fit in T

fn rolv(self, cnt: u32x8<AVX2>) -> Self

Rotates the bits in each lane to the left (towards HSB) by the number of bits specified in the corresponding lane of cnt

fn rorv(self, cnt: u32x8<AVX2>) -> Self

Rotates the bits in each lane to the right (towards LSB) by the number of bits specified in the corresponding lane of cnt

fn reverse_bits(self) -> Self

Reverses the bits of each lane in the vector.

fn count_ones(self) -> Self

Counts the number of 1 bits in each lane of the vector.

fn leading_zeros(self) -> Self

Counts the number of leading zeros in each lane of the vector.

fn trailing_zeros(self) -> Self

Counts the number of trailing zeros in each lane of the vector.

fn rol(self, cnt: u32) -> Self

Rotates the bits in each lane to the left (towards HSB) by the number of bits specified in cnt

fn ror(self, cnt: u32) -> Self

Rotates the bits in each lane to the right (towards LSB) by the number of bits specified in cnt

fn count_zeros(self) -> Self

Counts the number of 0 bits in each lane of the vector.

fn leading_ones(self) -> Self

Counts the number of leading ones in each lane of the vector.

fn trailing_ones(self) -> Self

Counts the number of trailing ones in each lane of the vector.

impl SimdIntoBits<AVX2, u32x8<AVX2>> for f32x8<AVX2>

fn into_bits(self) -> u32x8<AVX2>

impl SimdIntoBits<AVX2, u32x8<AVX2>> for i32x8<AVX2>

fn into_bits(self) -> u32x8<AVX2>

impl SimdIntoBits<AVX2, u64x8<AVX2>> for f64x8<AVX2>

fn into_bits(self) -> u64x8<AVX2>

impl SimdIntoBits<AVX2, u64x8<AVX2>> for i64x8<AVX2>

fn into_bits(self) -> u64x8<AVX2>

impl SimdSignedVector<AVX2> for f32x8<AVX2>

fn neg_one() -> Self

fn min_positive() -> Self

Minimum positive number

fn signum(self) -> Self

Returns -1 if less than zero, +1 otherwise.

fn copysign(self, sign: Self) -> Self

Copies the sign from sign to self

fn abs(self) -> Self

Absolute value

fn conditional_neg(self, mask: Mask<AVX2, impl SimdCastTo<AVX2, Self>>) -> Self

For each lane, if the mask is true, negate the value.

fn select_negative(self, neg: Self, pos: Self) -> Self

On platforms with true “select” instructions, they often only check the HSB, which happens to correspond to the “sign” bit for both floats and twos-compliment integers, so we can save a cmpgt(self, zero) by calling this

unsafe fn _mm_neg(self) -> Self

fn is_positive(self) -> Mask<S, Self>

Test if positive, greater or equal to zero

fn is_negative(self) -> Mask<S, Self>

Test if negative, less than zero

impl SimdSignedVector<AVX2> for f64x8<AVX2>

fn neg_one() -> Self

fn min_positive() -> Self

Minimum positive number

fn signum(self) -> Self

Returns -1 if less than zero, +1 otherwise.

fn copysign(self, sign: Self) -> Self

Copies the sign from sign to self

fn abs(self) -> Self

Absolute value

fn conditional_neg(self, mask: Mask<AVX2, impl SimdCastTo<AVX2, Self>>) -> Self

For each lane, if the mask is true, negate the value.

fn select_negative(self, neg: Self, pos: Self) -> Self

On platforms with true “select” instructions, they often only check the HSB, which happens to correspond to the “sign” bit for both floats and twos-compliment integers, so we can save a cmpgt(self, zero) by calling this

unsafe fn _mm_neg(self) -> Self

fn is_positive(self) -> Mask<S, Self>

Test if positive, greater or equal to zero

fn is_negative(self) -> Mask<S, Self>

Test if negative, less than zero

impl SimdSignedVector<AVX2> for i32x8<AVX2>

fn neg_one() -> Self

fn min_positive() -> Self

Minimum positive number

fn abs(self) -> Self

Absolute value

fn is_positive(self) -> Mask<AVX2, Self>

Test if positive, greater or equal to zero

fn is_negative(self) -> Mask<AVX2, Self>

Test if negative, less than zero

fn select_negative(self, neg: Self, pos: Self) -> Self

On platforms with true “select” instructions, they often only check the HSB, which happens to correspond to the “sign” bit for both floats and twos-compliment integers, so we can save a cmpgt(self, zero) by calling this

fn conditional_neg(self, mask: Mask<AVX2, impl SimdCastTo<AVX2, Self>>) -> Self

For each lane, if the mask is true, negate the value.

unsafe fn _mm_neg(self) -> Self

fn copysign(self, sign: Self) -> Self

Copies the sign from sign to self

fn signum(self) -> Self

Returns -1 if less than zero, +1 otherwise.

impl SimdSignedVector<AVX2> for i64x8<AVX2>

fn neg_one() -> Self

fn min_positive() -> Self

Minimum positive number

fn abs(self) -> Self

Absolute value

fn is_positive(self) -> Mask<AVX2, Self>

Test if positive, greater or equal to zero

fn is_negative(self) -> Mask<AVX2, Self>

Test if negative, less than zero

fn select_negative(self, neg: Self, pos: Self) -> Self

On platforms with true “select” instructions, they often only check the HSB, which happens to correspond to the “sign” bit for both floats and twos-compliment integers, so we can save a cmpgt(self, zero) by calling this

fn conditional_neg(self, mask: Mask<AVX2, impl SimdCastTo<AVX2, Self>>) -> Self

For each lane, if the mask is true, negate the value.

unsafe fn _mm_neg(self) -> Self

fn copysign(self, sign: Self) -> Self

Copies the sign from sign to self

fn signum(self) -> Self

Returns -1 if less than zero, +1 otherwise.

impl SimdUnsignedIntVector<AVX2> for u32x8<AVX2>

fn next_power_of_two_m1(self) -> Self

Returns next_power_of_two(x) - 1

fn log2p1(self) -> Self

Returns floor(log2(x)) + 1

fn is_power_of_two(self) -> Mask<S, Self>

Returns a mask wherein if a lane was a power of two, the corresponding mask lane will be truthy

impl SimdUnsignedIntVector<AVX2> for u64x8<AVX2>

fn next_power_of_two_m1(self) -> Self

Returns next_power_of_two(x) - 1

fn log2p1(self) -> Self

Returns floor(log2(x)) + 1

fn is_power_of_two(self) -> Mask<S, Self>

Returns a mask wherein if a lane was a power of two, the corresponding mask lane will be truthy

impl SimdVector<AVX2> for f32x8<AVX2>

fn zero() -> Self

fn one() -> Self

fn indexed() -> Self

Returns a vector where the first lane is zero, and each subsequent lane is one plus the previous lane.

fn min_value() -> Self

Maximum representable valid value

fn max_value() -> Self

Minimum representable valid value (may be negative)

fn min(self, other: Self) -> Self

Per-lane, select the minimum value

fn max(self, other: Self) -> Self

Per-lane, select the maximum value

fn min_element(self) -> Self::Element

Find the minimum value across all lanes

fn max_element(self) -> Self::Element

Find the maximum value across all lanes

fn eq(self, other: Self) -> Mask<AVX2, Self>

fn ne(self, other: Self) -> Mask<AVX2, Self>

fn lt(self, other: Self) -> Mask<AVX2, Self>

fn le(self, other: Self) -> Mask<AVX2, Self>

fn gt(self, other: Self) -> Mask<AVX2, Self>

fn ge(self, other: Self) -> Mask<AVX2, Self>

unsafe fn _mm_add(self, rhs: Self) -> Self

unsafe fn _mm_sub(self, rhs: Self) -> Self

unsafe fn _mm_mul(self, rhs: Self) -> Self

unsafe fn _mm_div(self, rhs: Self) -> Self

unsafe fn _mm_rem(self, rhs: Self) -> Self

fn gather(src: &[Self::Element], indices: S::Vu32) -> Self

Loads values from arbitrary addresses in memory based on offsets from a base address.

fn scatter(self, dst: &mut [Self::Element], indices: S::Vu32)

Stores values to arbitrary addresses in memory based on offsets from a base address.

fn gather_masked(
    src: &[Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>,
    default: Self
) -> Self

fn scatter_masked(
    self,
    dst: &mut [Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>
)

fn conditional_add(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Add self and value only if the corresponding lane in the given mask is true.

fn conditional_sub(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Subtracts value from self only if the corresponding lane in the given mask is true.

impl SimdVector<AVX2> for f64x8<AVX2>

fn zero() -> Self

fn one() -> Self

fn indexed() -> Self

Returns a vector where the first lane is zero, and each subsequent lane is one plus the previous lane.

fn min_value() -> Self

Maximum representable valid value

fn max_value() -> Self

Minimum representable valid value (may be negative)

fn min(self, other: Self) -> Self

Per-lane, select the minimum value

fn max(self, other: Self) -> Self

Per-lane, select the maximum value

fn min_element(self) -> Self::Element

Find the minimum value across all lanes

fn max_element(self) -> Self::Element

Find the maximum value across all lanes

fn eq(self, other: Self) -> Mask<AVX2, Self>

fn ne(self, other: Self) -> Mask<AVX2, Self>

fn lt(self, other: Self) -> Mask<AVX2, Self>

fn le(self, other: Self) -> Mask<AVX2, Self>

fn gt(self, other: Self) -> Mask<AVX2, Self>

fn ge(self, other: Self) -> Mask<AVX2, Self>

unsafe fn _mm_add(self, rhs: Self) -> Self

unsafe fn _mm_sub(self, rhs: Self) -> Self

unsafe fn _mm_mul(self, rhs: Self) -> Self

unsafe fn _mm_div(self, rhs: Self) -> Self

unsafe fn _mm_rem(self, rhs: Self) -> Self

fn gather(src: &[Self::Element], indices: S::Vu32) -> Self

Loads values from arbitrary addresses in memory based on offsets from a base address.

fn scatter(self, dst: &mut [Self::Element], indices: S::Vu32)

Stores values to arbitrary addresses in memory based on offsets from a base address.

fn gather_masked(
    src: &[Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>,
    default: Self
) -> Self

fn scatter_masked(
    self,
    dst: &mut [Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>
)

fn conditional_add(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Add self and value only if the corresponding lane in the given mask is true.

fn conditional_sub(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Subtracts value from self only if the corresponding lane in the given mask is true.

impl SimdVector<AVX2> for i32x8<AVX2>

fn zero() -> Self

fn one() -> Self

fn indexed() -> Self

Returns a vector where the first lane is zero, and each subsequent lane is one plus the previous lane.

fn min(self, other: Self) -> Self

Per-lane, select the minimum value

fn max(self, other: Self) -> Self

Per-lane, select the maximum value

fn min_value() -> Self

Maximum representable valid value

fn max_value() -> Self

Minimum representable valid value (may be negative)

fn min_element(self) -> Self::Element

Find the minimum value across all lanes

fn max_element(self) -> Self::Element

Find the maximum value across all lanes

fn eq(self, other: Self) -> Mask<AVX2, Self>

fn gt(self, other: Self) -> Mask<AVX2, Self>

fn ge(self, other: Self) -> Mask<AVX2, Self>

unsafe fn _mm_add(self, rhs: Self) -> Self

unsafe fn _mm_sub(self, rhs: Self) -> Self

unsafe fn _mm_mul(self, rhs: Self) -> Self

unsafe fn _mm_div(self, rhs: Self) -> Self

unsafe fn _mm_rem(self, rhs: Self) -> Self

fn gather(src: &[Self::Element], indices: S::Vu32) -> Self

Loads values from arbitrary addresses in memory based on offsets from a base address.

fn scatter(self, dst: &mut [Self::Element], indices: S::Vu32)

Stores values to arbitrary addresses in memory based on offsets from a base address.

fn gather_masked(
    src: &[Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>,
    default: Self
) -> Self

fn scatter_masked(
    self,
    dst: &mut [Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>
)

fn conditional_add(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Add self and value only if the corresponding lane in the given mask is true.

fn conditional_sub(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Subtracts value from self only if the corresponding lane in the given mask is true.

fn ne(self, other: Self) -> Mask<S, Self>

fn lt(self, other: Self) -> Mask<S, Self>

fn le(self, other: Self) -> Mask<S, Self>

impl SimdVector<AVX2> for i64x8<AVX2>

fn zero() -> Self

fn one() -> Self

fn indexed() -> Self

Returns a vector where the first lane is zero, and each subsequent lane is one plus the previous lane.

fn min_value() -> Self

Maximum representable valid value

fn max_value() -> Self

Minimum representable valid value (may be negative)

fn min_element(self) -> Self::Element

Find the minimum value across all lanes

fn max_element(self) -> Self::Element

Find the maximum value across all lanes

fn eq(self, other: Self) -> Mask<AVX2, Self>

fn gt(self, other: Self) -> Mask<AVX2, Self>

fn ge(self, other: Self) -> Mask<AVX2, Self>

unsafe fn _mm_add(self, rhs: Self) -> Self

unsafe fn _mm_sub(self, rhs: Self) -> Self

unsafe fn _mm_mul(self, rhs: Self) -> Self

unsafe fn _mm_div(self, rhs: Self) -> Self

unsafe fn _mm_rem(self, rhs: Self) -> Self

fn gather(src: &[Self::Element], indices: S::Vu32) -> Self

Loads values from arbitrary addresses in memory based on offsets from a base address.

fn scatter(self, dst: &mut [Self::Element], indices: S::Vu32)

Stores values to arbitrary addresses in memory based on offsets from a base address.

fn gather_masked(
    src: &[Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>,
    default: Self
) -> Self

fn scatter_masked(
    self,
    dst: &mut [Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>
)

fn min(self, other: Self) -> Self

Per-lane, select the minimum value

fn max(self, other: Self) -> Self

Per-lane, select the maximum value

fn conditional_add(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Add self and value only if the corresponding lane in the given mask is true.

fn conditional_sub(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Subtracts value from self only if the corresponding lane in the given mask is true.

fn ne(self, other: Self) -> Mask<S, Self>

fn lt(self, other: Self) -> Mask<S, Self>

fn le(self, other: Self) -> Mask<S, Self>

impl SimdVector<AVX2> for u32x8<AVX2>

fn zero() -> Self

fn one() -> Self

fn indexed() -> Self

Returns a vector where the first lane is zero, and each subsequent lane is one plus the previous lane.

fn min(self, other: Self) -> Self

Per-lane, select the minimum value

fn max(self, other: Self) -> Self

Per-lane, select the maximum value

fn min_value() -> Self

Maximum representable valid value

fn max_value() -> Self

Minimum representable valid value (may be negative)

fn min_element(self) -> Self::Element

Find the minimum value across all lanes

fn max_element(self) -> Self::Element

Find the maximum value across all lanes

fn eq(self, other: Self) -> Mask<AVX2, Self>

fn gt(self, other: Self) -> Mask<AVX2, Self>

fn ge(self, other: Self) -> Mask<AVX2, Self>

unsafe fn _mm_add(self, rhs: Self) -> Self

unsafe fn _mm_sub(self, rhs: Self) -> Self

unsafe fn _mm_mul(self, rhs: Self) -> Self

unsafe fn _mm_div(self, rhs: Self) -> Self

unsafe fn _mm_rem(self, rhs: Self) -> Self

fn gather(src: &[Self::Element], indices: S::Vu32) -> Self

Loads values from arbitrary addresses in memory based on offsets from a base address.

fn scatter(self, dst: &mut [Self::Element], indices: S::Vu32)

Stores values to arbitrary addresses in memory based on offsets from a base address.

fn gather_masked(
    src: &[Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>,
    default: Self
) -> Self

fn scatter_masked(
    self,
    dst: &mut [Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>
)

fn conditional_add(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Add self and value only if the corresponding lane in the given mask is true.

fn conditional_sub(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Subtracts value from self only if the corresponding lane in the given mask is true.

fn ne(self, other: Self) -> Mask<S, Self>

fn lt(self, other: Self) -> Mask<S, Self>

fn le(self, other: Self) -> Mask<S, Self>

impl SimdVector<AVX2> for u64x8<AVX2>

fn zero() -> Self

fn one() -> Self

fn indexed() -> Self

Returns a vector where the first lane is zero, and each subsequent lane is one plus the previous lane.

fn min_value() -> Self

Maximum representable valid value

fn max_value() -> Self

Minimum representable valid value (may be negative)

fn min_element(self) -> Self::Element

Find the minimum value across all lanes

fn max_element(self) -> Self::Element

Find the maximum value across all lanes

fn eq(self, other: Self) -> Mask<AVX2, Self>

fn gt(self, other: Self) -> Mask<AVX2, Self>

fn ge(self, other: Self) -> Mask<AVX2, Self>

unsafe fn _mm_add(self, rhs: Self) -> Self

unsafe fn _mm_sub(self, rhs: Self) -> Self

unsafe fn _mm_mul(self, rhs: Self) -> Self

unsafe fn _mm_div(self, rhs: Self) -> Self

unsafe fn _mm_rem(self, rhs: Self) -> Self

fn gather(src: &[Self::Element], indices: S::Vu32) -> Self

Loads values from arbitrary addresses in memory based on offsets from a base address.

fn scatter(self, dst: &mut [Self::Element], indices: S::Vu32)

Stores values to arbitrary addresses in memory based on offsets from a base address.

fn gather_masked(
    src: &[Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>,
    default: Self
) -> Self

fn scatter_masked(
    self,
    dst: &mut [Self::Element],
    indices: S::Vu32,
    mask: Mask<S, Self>
)

fn min(self, other: Self) -> Self

Per-lane, select the minimum value

fn max(self, other: Self) -> Self

Per-lane, select the maximum value

fn conditional_add(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Add self and value only if the corresponding lane in the given mask is true.

fn conditional_sub(
    self,
    value: Self,
    mask: Mask<S, impl SimdCastTo<S, Self>>
) -> Self

Subtracts value from self only if the corresponding lane in the given mask is true.

fn ne(self, other: Self) -> Mask<S, Self>

fn lt(self, other: Self) -> Mask<S, Self>

fn le(self, other: Self) -> Mask<S, Self>

impl SimdVectorBase<AVX2> for f32x8<AVX2>

type Element = f32

fn splat(value: Self::Element) -> Self

Creates a new vector with all lanes set to the given value

unsafe fn undefined() -> Self

Returns a vector containing possibly undefined or uninitialized data

unsafe fn load_aligned_unchecked(ptr: *const Self::Element) -> Self

Loads a vector from the given aligned address.

unsafe fn load_unaligned_unchecked(ptr: *const Self::Element) -> Self

Loads a vector from a given address (does not have to be aligned).

unsafe fn store_aligned_unchecked(self, ptr: *mut Self::Element)

Stores a vector to the given aligned address.

unsafe fn store_unaligned_unchecked(self, ptr: *mut Self::Element)

Stores a vector to a given address (does not have to be aligned).

unsafe fn extract_unchecked(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

unsafe fn replace_unchecked(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

unsafe fn shuffle_unchecked<INDICES: SimdShuffleIndices>(
    self,
    b: Self,
    indices: INDICES
) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

unsafe fn gather_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>
) -> Self

unsafe fn gather_masked_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>,
    mask: Mask<AVX2, Self>,
    default: Self
) -> Self

Like Self::gather, but individual lanes are loaded based on the corresponding lane of the mask. If the mask lane is truthy, the source lane is loaded, otherwise it’s given the lane value from default.

const ELEMENT_SIZE: usize

Size of element type in bytes

const NUM_ELEMENTS: usize

const ALIGNMENT: usize

fn splat_any(value: impl Into<Self::Element>) -> Self

Same as splat, but is more convenient for initializing with data that can be converted into the element type.

fn splat_as<E>(value: E) -> Self where
    Self::Element: CastFrom<E>, 

Splats a value by casting to the element type via value as Element.

fn map_scalar<F>(self, func: F) -> Self where
    F: FnMut(usize, Self::Element) -> Self::Element, 

Maps each lane of the vector to a new vector using a scalar function

fn shuffle<INDICES: SimdShuffleIndices>(self, b: Self, indices: INDICES) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

fn shuffle_dyn(self, b: Self, indices: &[usize]) -> Self

Shuffles between two vectors based on the dynamic indices provided.

unsafe fn shuffle_dyn_unchecked(self, b: Self, indices: &[usize]) -> Self

Like Self::shuffle_dyn, but does not check for valid indices or input length.

fn reverse(self) -> Self

Reverses the elements in the vector

fn alloc(count: usize) -> VectorBuffer<S, Self>

fn extract(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

fn replace(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

fn load_aligned(src: &[Self::Element]) -> Self

Loads a vector from a slice that has an alignment of at least Self::ALIGNMENT

fn load_unaligned(src: &[Self::Element]) -> Self

Loads a vector from a slice

fn store_aligned(self, dst: &mut [Self::Element])

Stores a vector into a slice with an alignment of at least Self::ALIGNMENT

fn store_unaligned(self, dst: &mut [Self::Element])

Stores a vector into a slice.

unsafe fn scatter_unchecked(self, dst: *mut Self::Element, indices: S::Vi32)

unsafe fn scatter_masked_unchecked(
    self,
    base_ptr: *mut Self::Element,
    indices: S::Vi32,
    mask: Mask<S, Self>
)

Like self.scatter(), but individual lanes are stored based on the corresponding lane of the mask. If the mask lane is truthy, the destination lane is written to, otherwise it is a no-op.

impl SimdVectorBase<AVX2> for f64x8<AVX2>

type Element = f64

const ALIGNMENT: usize

fn splat(value: Self::Element) -> Self

Creates a new vector with all lanes set to the given value

unsafe fn undefined() -> Self

Returns a vector containing possibly undefined or uninitialized data

unsafe fn load_aligned_unchecked(src: *const Self::Element) -> Self

Loads a vector from the given aligned address.

unsafe fn load_unaligned_unchecked(src: *const Self::Element) -> Self

Loads a vector from a given address (does not have to be aligned).

unsafe fn store_aligned_unchecked(self, dst: *mut Self::Element)

Stores a vector to the given aligned address.

unsafe fn store_unaligned_unchecked(self, dst: *mut Self::Element)

Stores a vector to a given address (does not have to be aligned).

unsafe fn extract_unchecked(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

unsafe fn replace_unchecked(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

unsafe fn shuffle_unchecked<INDICES: SimdShuffleIndices>(
    self,
    b: Self,
    indices: INDICES
) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

unsafe fn gather_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>
) -> Self

unsafe fn gather_masked_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>,
    mask: Mask<AVX2, Self>,
    default: Self
) -> Self

Like Self::gather, but individual lanes are loaded based on the corresponding lane of the mask. If the mask lane is truthy, the source lane is loaded, otherwise it’s given the lane value from default.

const ELEMENT_SIZE: usize

Size of element type in bytes

const NUM_ELEMENTS: usize

fn splat_any(value: impl Into<Self::Element>) -> Self

Same as splat, but is more convenient for initializing with data that can be converted into the element type.

fn splat_as<E>(value: E) -> Self where
    Self::Element: CastFrom<E>, 

Splats a value by casting to the element type via value as Element.

fn map_scalar<F>(self, func: F) -> Self where
    F: FnMut(usize, Self::Element) -> Self::Element, 

Maps each lane of the vector to a new vector using a scalar function

fn shuffle<INDICES: SimdShuffleIndices>(self, b: Self, indices: INDICES) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

fn shuffle_dyn(self, b: Self, indices: &[usize]) -> Self

Shuffles between two vectors based on the dynamic indices provided.

unsafe fn shuffle_dyn_unchecked(self, b: Self, indices: &[usize]) -> Self

Like Self::shuffle_dyn, but does not check for valid indices or input length.

fn reverse(self) -> Self

Reverses the elements in the vector

fn alloc(count: usize) -> VectorBuffer<S, Self>

fn extract(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

fn replace(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

fn load_aligned(src: &[Self::Element]) -> Self

Loads a vector from a slice that has an alignment of at least Self::ALIGNMENT

fn load_unaligned(src: &[Self::Element]) -> Self

Loads a vector from a slice

fn store_aligned(self, dst: &mut [Self::Element])

Stores a vector into a slice with an alignment of at least Self::ALIGNMENT

fn store_unaligned(self, dst: &mut [Self::Element])

Stores a vector into a slice.

unsafe fn scatter_unchecked(self, dst: *mut Self::Element, indices: S::Vi32)

unsafe fn scatter_masked_unchecked(
    self,
    base_ptr: *mut Self::Element,
    indices: S::Vi32,
    mask: Mask<S, Self>
)

Like self.scatter(), but individual lanes are stored based on the corresponding lane of the mask. If the mask lane is truthy, the destination lane is written to, otherwise it is a no-op.

impl SimdVectorBase<AVX2> for i32x8<AVX2>

type Element = i32

fn splat(value: Self::Element) -> Self

Creates a new vector with all lanes set to the given value

unsafe fn undefined() -> Self

Returns a vector containing possibly undefined or uninitialized data

unsafe fn load_aligned_unchecked(src: *const Self::Element) -> Self

Loads a vector from the given aligned address.

unsafe fn load_unaligned_unchecked(src: *const Self::Element) -> Self

Loads a vector from a given address (does not have to be aligned).

unsafe fn store_aligned_unchecked(self, dst: *mut Self::Element)

Stores a vector to the given aligned address.

unsafe fn store_unaligned_unchecked(self, dst: *mut Self::Element)

Stores a vector to a given address (does not have to be aligned).

unsafe fn extract_unchecked(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

unsafe fn replace_unchecked(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

unsafe fn shuffle_unchecked<INDICES: SimdShuffleIndices>(
    self,
    b: Self,
    indices: INDICES
) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

unsafe fn gather_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>
) -> Self

unsafe fn gather_masked_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>,
    mask: Mask<AVX2, Self>,
    default: Self
) -> Self

Like Self::gather, but individual lanes are loaded based on the corresponding lane of the mask. If the mask lane is truthy, the source lane is loaded, otherwise it’s given the lane value from default.

const ELEMENT_SIZE: usize

Size of element type in bytes

const NUM_ELEMENTS: usize

const ALIGNMENT: usize

fn splat_any(value: impl Into<Self::Element>) -> Self

Same as splat, but is more convenient for initializing with data that can be converted into the element type.

fn splat_as<E>(value: E) -> Self where
    Self::Element: CastFrom<E>, 

Splats a value by casting to the element type via value as Element.

fn map_scalar<F>(self, func: F) -> Self where
    F: FnMut(usize, Self::Element) -> Self::Element, 

Maps each lane of the vector to a new vector using a scalar function

fn shuffle<INDICES: SimdShuffleIndices>(self, b: Self, indices: INDICES) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

fn shuffle_dyn(self, b: Self, indices: &[usize]) -> Self

Shuffles between two vectors based on the dynamic indices provided.

unsafe fn shuffle_dyn_unchecked(self, b: Self, indices: &[usize]) -> Self

Like Self::shuffle_dyn, but does not check for valid indices or input length.

fn reverse(self) -> Self

Reverses the elements in the vector

fn alloc(count: usize) -> VectorBuffer<S, Self>

fn extract(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

fn replace(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

fn load_aligned(src: &[Self::Element]) -> Self

Loads a vector from a slice that has an alignment of at least Self::ALIGNMENT

fn load_unaligned(src: &[Self::Element]) -> Self

Loads a vector from a slice

fn store_aligned(self, dst: &mut [Self::Element])

Stores a vector into a slice with an alignment of at least Self::ALIGNMENT

fn store_unaligned(self, dst: &mut [Self::Element])

Stores a vector into a slice.

unsafe fn scatter_unchecked(self, dst: *mut Self::Element, indices: S::Vi32)

unsafe fn scatter_masked_unchecked(
    self,
    base_ptr: *mut Self::Element,
    indices: S::Vi32,
    mask: Mask<S, Self>
)

Like self.scatter(), but individual lanes are stored based on the corresponding lane of the mask. If the mask lane is truthy, the destination lane is written to, otherwise it is a no-op.

impl SimdVectorBase<AVX2> for i64x8<AVX2>

type Element = i64

fn splat(value: Self::Element) -> Self

Creates a new vector with all lanes set to the given value

unsafe fn undefined() -> Self

Returns a vector containing possibly undefined or uninitialized data

unsafe fn load_aligned_unchecked(ptr: *const Self::Element) -> Self

Loads a vector from the given aligned address.

unsafe fn store_aligned_unchecked(self, ptr: *mut Self::Element)

Stores a vector to the given aligned address.

unsafe fn extract_unchecked(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

unsafe fn replace_unchecked(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

unsafe fn shuffle_unchecked<INDICES: SimdShuffleIndices>(
    self,
    b: Self,
    indices: INDICES
) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

unsafe fn gather_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>
) -> Self

unsafe fn gather_masked_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>,
    mask: Mask<AVX2, Self>,
    default: Self
) -> Self

Like Self::gather, but individual lanes are loaded based on the corresponding lane of the mask. If the mask lane is truthy, the source lane is loaded, otherwise it’s given the lane value from default.

const ELEMENT_SIZE: usize

Size of element type in bytes

const NUM_ELEMENTS: usize

const ALIGNMENT: usize

fn splat_any(value: impl Into<Self::Element>) -> Self

Same as splat, but is more convenient for initializing with data that can be converted into the element type.

fn splat_as<E>(value: E) -> Self where
    Self::Element: CastFrom<E>, 

Splats a value by casting to the element type via value as Element.

fn map_scalar<F>(self, func: F) -> Self where
    F: FnMut(usize, Self::Element) -> Self::Element, 

Maps each lane of the vector to a new vector using a scalar function

fn shuffle<INDICES: SimdShuffleIndices>(self, b: Self, indices: INDICES) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

fn shuffle_dyn(self, b: Self, indices: &[usize]) -> Self

Shuffles between two vectors based on the dynamic indices provided.

unsafe fn shuffle_dyn_unchecked(self, b: Self, indices: &[usize]) -> Self

Like Self::shuffle_dyn, but does not check for valid indices or input length.

fn reverse(self) -> Self

Reverses the elements in the vector

fn alloc(count: usize) -> VectorBuffer<S, Self>

fn extract(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

fn replace(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

fn load_aligned(src: &[Self::Element]) -> Self

Loads a vector from a slice that has an alignment of at least Self::ALIGNMENT

fn load_unaligned(src: &[Self::Element]) -> Self

Loads a vector from a slice

fn store_aligned(self, dst: &mut [Self::Element])

Stores a vector into a slice with an alignment of at least Self::ALIGNMENT

fn store_unaligned(self, dst: &mut [Self::Element])

Stores a vector into a slice.

unsafe fn load_unaligned_unchecked(src: *const Self::Element) -> Self

Loads a vector from a given address (does not have to be aligned).

unsafe fn store_unaligned_unchecked(self, dst: *mut Self::Element)

Stores a vector to a given address (does not have to be aligned).

unsafe fn scatter_unchecked(self, dst: *mut Self::Element, indices: S::Vi32)

unsafe fn scatter_masked_unchecked(
    self,
    base_ptr: *mut Self::Element,
    indices: S::Vi32,
    mask: Mask<S, Self>
)

Like self.scatter(), but individual lanes are stored based on the corresponding lane of the mask. If the mask lane is truthy, the destination lane is written to, otherwise it is a no-op.

impl SimdVectorBase<AVX2> for u32x8<AVX2>

type Element = u32

fn splat(value: Self::Element) -> Self

Creates a new vector with all lanes set to the given value

unsafe fn undefined() -> Self

Returns a vector containing possibly undefined or uninitialized data

unsafe fn load_aligned_unchecked(ptr: *const Self::Element) -> Self

Loads a vector from the given aligned address.

unsafe fn load_unaligned_unchecked(ptr: *const Self::Element) -> Self

Loads a vector from a given address (does not have to be aligned).

unsafe fn store_aligned_unchecked(self, ptr: *mut Self::Element)

Stores a vector to the given aligned address.

unsafe fn store_unaligned_unchecked(self, ptr: *mut Self::Element)

Stores a vector to a given address (does not have to be aligned).

unsafe fn extract_unchecked(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

unsafe fn replace_unchecked(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

unsafe fn shuffle_unchecked<INDICES: SimdShuffleIndices>(
    self,
    b: Self,
    indices: INDICES
) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

unsafe fn gather_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>
) -> Self

unsafe fn gather_masked_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>,
    mask: Mask<AVX2, Self>,
    default: Self
) -> Self

Like Self::gather, but individual lanes are loaded based on the corresponding lane of the mask. If the mask lane is truthy, the source lane is loaded, otherwise it’s given the lane value from default.

const ELEMENT_SIZE: usize

Size of element type in bytes

const NUM_ELEMENTS: usize

const ALIGNMENT: usize

fn splat_any(value: impl Into<Self::Element>) -> Self

Same as splat, but is more convenient for initializing with data that can be converted into the element type.

fn splat_as<E>(value: E) -> Self where
    Self::Element: CastFrom<E>, 

Splats a value by casting to the element type via value as Element.

fn map_scalar<F>(self, func: F) -> Self where
    F: FnMut(usize, Self::Element) -> Self::Element, 

Maps each lane of the vector to a new vector using a scalar function

fn shuffle<INDICES: SimdShuffleIndices>(self, b: Self, indices: INDICES) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

fn shuffle_dyn(self, b: Self, indices: &[usize]) -> Self

Shuffles between two vectors based on the dynamic indices provided.

unsafe fn shuffle_dyn_unchecked(self, b: Self, indices: &[usize]) -> Self

Like Self::shuffle_dyn, but does not check for valid indices or input length.

fn reverse(self) -> Self

Reverses the elements in the vector

fn alloc(count: usize) -> VectorBuffer<S, Self>

fn extract(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

fn replace(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

fn load_aligned(src: &[Self::Element]) -> Self

Loads a vector from a slice that has an alignment of at least Self::ALIGNMENT

fn load_unaligned(src: &[Self::Element]) -> Self

Loads a vector from a slice

fn store_aligned(self, dst: &mut [Self::Element])

Stores a vector into a slice with an alignment of at least Self::ALIGNMENT

fn store_unaligned(self, dst: &mut [Self::Element])

Stores a vector into a slice.

unsafe fn scatter_unchecked(self, dst: *mut Self::Element, indices: S::Vi32)

unsafe fn scatter_masked_unchecked(
    self,
    base_ptr: *mut Self::Element,
    indices: S::Vi32,
    mask: Mask<S, Self>
)

Like self.scatter(), but individual lanes are stored based on the corresponding lane of the mask. If the mask lane is truthy, the destination lane is written to, otherwise it is a no-op.

impl SimdVectorBase<AVX2> for u64x8<AVX2>

type Element = u64

fn splat(value: Self::Element) -> Self

Creates a new vector with all lanes set to the given value

unsafe fn undefined() -> Self

Returns a vector containing possibly undefined or uninitialized data

unsafe fn load_aligned_unchecked(ptr: *const Self::Element) -> Self

Loads a vector from the given aligned address.

unsafe fn store_aligned_unchecked(self, ptr: *mut Self::Element)

Stores a vector to the given aligned address.

unsafe fn extract_unchecked(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

unsafe fn replace_unchecked(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

unsafe fn shuffle_unchecked<INDICES: SimdShuffleIndices>(
    self,
    b: Self,
    indices: INDICES
) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

unsafe fn gather_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>
) -> Self

unsafe fn gather_masked_unchecked(
    base_ptr: *const Self::Element,
    indices: i32x8<AVX2>,
    mask: Mask<AVX2, Self>,
    default: Self
) -> Self

Like Self::gather, but individual lanes are loaded based on the corresponding lane of the mask. If the mask lane is truthy, the source lane is loaded, otherwise it’s given the lane value from default.

const ELEMENT_SIZE: usize

Size of element type in bytes

const NUM_ELEMENTS: usize

const ALIGNMENT: usize

fn splat_any(value: impl Into<Self::Element>) -> Self

Same as splat, but is more convenient for initializing with data that can be converted into the element type.

fn splat_as<E>(value: E) -> Self where
    Self::Element: CastFrom<E>, 

Splats a value by casting to the element type via value as Element.

fn map_scalar<F>(self, func: F) -> Self where
    F: FnMut(usize, Self::Element) -> Self::Element, 

Maps each lane of the vector to a new vector using a scalar function

fn shuffle<INDICES: SimdShuffleIndices>(self, b: Self, indices: INDICES) -> Self

Shuffles between two vectors based on the static indices provided in INDICES

fn shuffle_dyn(self, b: Self, indices: &[usize]) -> Self

Shuffles between two vectors based on the dynamic indices provided.

unsafe fn shuffle_dyn_unchecked(self, b: Self, indices: &[usize]) -> Self

Like Self::shuffle_dyn, but does not check for valid indices or input length.

fn reverse(self) -> Self

Reverses the elements in the vector

fn alloc(count: usize) -> VectorBuffer<S, Self>

fn extract(self, index: usize) -> Self::Element

Extracts an element at the given lane index.

fn replace(self, index: usize, value: Self::Element) -> Self

Returns a new vector with the given value at the given lane index.

fn load_aligned(src: &[Self::Element]) -> Self

Loads a vector from a slice that has an alignment of at least Self::ALIGNMENT

fn load_unaligned(src: &[Self::Element]) -> Self

Loads a vector from a slice

fn store_aligned(self, dst: &mut [Self::Element])

Stores a vector into a slice with an alignment of at least Self::ALIGNMENT

fn store_unaligned(self, dst: &mut [Self::Element])

Stores a vector into a slice.

unsafe fn load_unaligned_unchecked(src: *const Self::Element) -> Self

Loads a vector from a given address (does not have to be aligned).

unsafe fn store_unaligned_unchecked(self, dst: *mut Self::Element)

Stores a vector to a given address (does not have to be aligned).

unsafe fn scatter_unchecked(self, dst: *mut Self::Element, indices: S::Vi32)

unsafe fn scatter_masked_unchecked(
    self,
    base_ptr: *mut Self::Element,
    indices: S::Vi32,
    mask: Mask<S, Self>
)

Like self.scatter(), but individual lanes are stored based on the corresponding lane of the mask. If the mask lane is truthy, the destination lane is written to, otherwise it is a no-op.

impl Copy for AVX2

impl Eq for AVX2

impl StructuralEq for AVX2

impl StructuralPartialEq for AVX2