Struct thermite::backends::avx2::i64x8

#[repr(transparent)]
pub struct i64x8<S: Simd> { /* fields omitted */ }

Trait Implementations

impl Add<i64x8<AVX2>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<<i64x8<AVX2> as SimdVectorBase<AVX2>>::Element> for i64x8<AVX2>

fn add_assign(&mut self, rhs: <Self as SimdVectorBase<AVX2>>::Element)

Performs the += operation.

impl AddAssign<i64x8<AVX2>> for i64x8<AVX2>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl BitAnd<i64x8<AVX2>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign<<i64x8<AVX2> as SimdVectorBase<AVX2>>::Element> for i64x8<AVX2>

fn bitand_assign(&mut self, rhs: <Self as SimdVectorBase<AVX2>>::Element)

Performs the &= operation.

impl BitAndAssign<i64x8<AVX2>> for i64x8<AVX2>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<i64x8<AVX2>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<<i64x8<AVX2> as SimdVectorBase<AVX2>>::Element> for i64x8<AVX2>

fn bitor_assign(&mut self, rhs: <Self as SimdVectorBase<AVX2>>::Element)

Performs the |= operation.

impl BitOrAssign<i64x8<AVX2>> for i64x8<AVX2>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor<i64x8<AVX2>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign<<i64x8<AVX2> as SimdVectorBase<AVX2>>::Element> for i64x8<AVX2>

fn bitxor_assign(&mut self, rhs: <Self as SimdVectorBase<AVX2>>::Element)

Performs the ^= operation.

impl BitXorAssign<i64x8<AVX2>> for i64x8<AVX2>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<S: Clone + Simd> Clone for i64x8<S>

fn clone(&self) -> i64x8<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Simd> Debug for i64x8<S> where
    Self: SimdVectorBase<S>, 

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

Formats the value using the given formatter.

impl<S: Simd> Default for i64x8<S>

fn default() -> Self

Returns the “default value” for a type.

impl Div<BranchfreeDivider<i64>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: BranchfreeDivider<i64>) -> Self

Performs the / operation.

impl Div<Divider<i64>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Divider<i64>) -> Self

Performs the / operation.

impl Div<i64x8<AVX2>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<<i64x8<AVX2> as SimdVectorBase<AVX2>>::Element> for i64x8<AVX2>

fn div_assign(&mut self, rhs: <Self as SimdVectorBase<AVX2>>::Element)

Performs the /= operation.

impl DivAssign<i64x8<AVX2>> for i64x8<AVX2>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl Mul<i64x8<AVX2>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<<i64x8<AVX2> as SimdVectorBase<AVX2>>::Element> for i64x8<AVX2>

fn mul_assign(&mut self, rhs: <Self as SimdVectorBase<AVX2>>::Element)

Performs the *= operation.

impl MulAssign<i64x8<AVX2>> for i64x8<AVX2>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for i64x8<AVX2>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Not for i64x8<AVX2>

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl PartialEq<i64x8<AVX2>> for i64x8<AVX2>

fn eq(&self, other: &Self) -> 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 Rem<i64x8<AVX2>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the % operator.

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

Performs the % operation.

impl RemAssign<<i64x8<AVX2> as SimdVectorBase<AVX2>>::Element> for i64x8<AVX2>

fn rem_assign(&mut self, rhs: <Self as SimdVectorBase<AVX2>>::Element)

Performs the %= operation.

impl RemAssign<i64x8<AVX2>> for i64x8<AVX2>

fn rem_assign(&mut self, rhs: 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<u32> for i64x8<AVX2>

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self

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<u32> for i64x8<AVX2>

fn shl_assign(&mut self, rhs: u32)

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<u32> for i64x8<AVX2>

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self

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<u32> for i64x8<AVX2>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

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 SimdFromBits<AVX2, u64x8<AVX2>> for i64x8<AVX2>

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

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, 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, 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, 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 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, 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 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 SimdIntoBits<AVX2, u64x8<AVX2>> for i64x8<AVX2>

fn into_bits(self) -> u64x8<AVX2>

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 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 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 Sub<i64x8<AVX2>> for i64x8<AVX2>

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<<i64x8<AVX2> as SimdVectorBase<AVX2>>::Element> for i64x8<AVX2>

fn sub_assign(&mut self, rhs: <Self as SimdVectorBase<AVX2>>::Element)

Performs the -= operation.

impl SubAssign<i64x8<AVX2>> for i64x8<AVX2>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<S: Copy + Simd> Copy for i64x8<S>

impl Eq for i64x8<AVX2>