Struct u64x8 

pub struct u64x8<S: Simd> {
    pub simd: S,
    /* private fields */
}

A SIMD vector of 8 u64 elements.

You may construct this vector type using the Self::splat, Self::from_slice, Self::simd_from, Self::from_fn, and Self::block_splat methods.

fn construct_simd<S: Simd>(simd: S) {
    // From a single scalar value:
    let a = u64x8::splat(simd, 1);
    let b = u64x8::simd_from(simd, 1);

    // From a slice:
    let c = u64x8::from_slice(simd, &[1, 2, 3, 4, 5, 6, 7, 8]);

    // From an array:
    let d = u64x8::simd_from(simd, [1, 2, 3, 4, 5, 6, 7, 8]);

    // From an element-wise function:
    let e = u64x8::from_fn(simd, |i| i as u64);
    // From `Self::Block`:
    let f = u64x8::block_splat(u64x2::simd_from(simd, [1, 2]));
}

Fields

simd: S

Trait Implementations

impl<S: Simd> Add for u64x8<S>

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

Add two vectors element-wise, wrapping on overflow.

type Output = u64x8<S>

The resulting type after applying the + operator.

impl<S: Simd> Add<u64> for u64x8<S>

type Output = u64x8<S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S: Simd> Add<u64x8<S>> for u64

type Output = u64x8<S>

The resulting type after applying the + operator.

fn add(self, rhs: u64x8<S>) -> Self::Output

Performs the + operation.

impl<S: Simd> AddAssign for u64x8<S>

fn add_assign(&mut self, rhs: Self)

Add two vectors element-wise, wrapping on overflow.

impl<S: Simd> AddAssign<u64> for u64x8<S>

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<S: Simd> BitAnd for u64x8<S>

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

Compute the bitwise AND of two vectors.

type Output = u64x8<S>

The resulting type after applying the & operator.

impl<S: Simd> BitAnd<u64> for u64x8<S>

type Output = u64x8<S>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<S: Simd> BitAnd<u64x8<S>> for u64

type Output = u64x8<S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u64x8<S>) -> Self::Output

Performs the & operation.

impl<S: Simd> BitAndAssign for u64x8<S>

fn bitand_assign(&mut self, rhs: Self)

Compute the bitwise AND of two vectors.

impl<S: Simd> BitAndAssign<u64> for u64x8<S>

fn bitand_assign(&mut self, rhs: u64)

Performs the &= operation.

impl<S: Simd> BitOr for u64x8<S>

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

Compute the bitwise OR of two vectors.

type Output = u64x8<S>

The resulting type after applying the | operator.

impl<S: Simd> BitOr<u64> for u64x8<S>

type Output = u64x8<S>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<S: Simd> BitOr<u64x8<S>> for u64

type Output = u64x8<S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u64x8<S>) -> Self::Output

Performs the | operation.

impl<S: Simd> BitOrAssign for u64x8<S>

fn bitor_assign(&mut self, rhs: Self)

Compute the bitwise OR of two vectors.

impl<S: Simd> BitOrAssign<u64> for u64x8<S>

fn bitor_assign(&mut self, rhs: u64)

Performs the |= operation.

impl<S: Simd> BitXor for u64x8<S>

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

Compute the bitwise XOR of two vectors.

type Output = u64x8<S>

The resulting type after applying the ^ operator.

impl<S: Simd> BitXor<u64> for u64x8<S>

type Output = u64x8<S>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<S: Simd> BitXor<u64x8<S>> for u64

type Output = u64x8<S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64x8<S>) -> Self::Output

Performs the ^ operation.

impl<S: Simd> BitXorAssign for u64x8<S>

fn bitxor_assign(&mut self, rhs: Self)

Compute the bitwise XOR of two vectors.

impl<S: Simd> BitXorAssign<u64> for u64x8<S>

fn bitxor_assign(&mut self, rhs: u64)

Performs the ^= operation.

impl<S: Simd> Bytes for u64x8<S>

type Bytes = u8x64<S>

The same-width SIMD vector of u8 lanes used as the byte representation.

fn to_bytes(self) -> Self::Bytes

Reinterpret this vector as a same-width vector of u8 lanes.

fn from_bytes(value: Self::Bytes) -> Self

Reinterpret a same-width vector of u8 lanes as this vector type.

fn bitcast<U: Bytes<Bytes = Self::Bytes>>(self) -> U

Bitcast directly to another SIMD vector with the same byte representation. This is effectively a safe transmute for SIMD types.

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

where S::u64x8: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where S::u64x8: Copy,

impl<S: Simd + Debug> Debug for u64x8<S>

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

Formats the value using the given formatter.

impl<S: Simd> Deref for u64x8<S>

type Target = [u64; 8]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S: Simd> DerefMut for u64x8<S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<S: Simd> From<u64x8<S>> for __m512i

Available on x86 or x86-64 only.

fn from(value: u64x8<S>) -> Self

Converts to this type from the input type.

impl<S: Simd> From<u64x8<S>> for [u64; 8]

fn from(value: u64x8<S>) -> Self

Converts to this type from the input type.

impl<S: Simd> Index<usize> for u64x8<S>

type Output = u64

The returned type after indexing.

fn index(&self, i: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<S: Simd> IndexMut<usize> for u64x8<S>

fn index_mut(&mut self, i: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<S: Simd> Mul for u64x8<S>

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

Multiply two vectors element-wise, wrapping on overflow.

type Output = u64x8<S>

The resulting type after applying the * operator.

impl<S: Simd> Mul<u64> for u64x8<S>

type Output = u64x8<S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S: Simd> Mul<u64x8<S>> for u64

type Output = u64x8<S>

The resulting type after applying the * operator.

fn mul(self, rhs: u64x8<S>) -> Self::Output

Performs the * operation.

impl<S: Simd> MulAssign for u64x8<S>

fn mul_assign(&mut self, rhs: Self)

Multiply two vectors element-wise, wrapping on overflow.

impl<S: Simd> MulAssign<u64> for u64x8<S>

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<S: Simd> Not for u64x8<S>

fn not(self) -> Self::Output

Compute the bitwise NOT of the vector.

type Output = u64x8<S>

The resulting type after applying the ! operator.

impl<S: Simd> Select<u64x8<S>> for mask64x8<S>

fn select(self, if_true: u64x8<S>, if_false: u64x8<S>) -> u64x8<S>

For each logical lane of this mask, select the first operand if the lane is true, and select the second operand if the lane is false.

impl<S: Simd> Shl for u64x8<S>

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

Shift each element left by the given number of bits.

Bits shifted out of the left side are discarded, and zeros are shifted in on the right.

When shifting out of bounds (e.g. shifting a 32-bit value by 32 or more), the result is implementation-defined and may vary by platform.

This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.

type Output = u64x8<S>

The resulting type after applying the << operator.

impl<S: Simd> Shl<u32> for u64x8<S>

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

Shift each element left by the given number of bits.

Bits shifted out of the left side are discarded, and zeros are shifted in on the right.

When shifting out of bounds (e.g. shifting a 32-bit value by 32 or more), the result is implementation-defined and may vary by platform.

type Output = u64x8<S>

The resulting type after applying the << operator.

impl<S: Simd> ShlAssign for u64x8<S>

fn shl_assign(&mut self, rhs: Self)

Shift each element left by the given number of bits.

Bits shifted out of the left side are discarded, and zeros are shifted in on the right.

When shifting out of bounds (e.g. shifting a 32-bit value by 32 or more), the result is implementation-defined and may vary by platform.

This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.

impl<S: Simd> ShlAssign<u32> for u64x8<S>

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<S: Simd> Shr for u64x8<S>

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

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

For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.

When shifting out of bounds (e.g. shifting a 32-bit value by 32 or more), the result is implementation-defined and may vary by platform.

This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.

type Output = u64x8<S>

The resulting type after applying the >> operator.

impl<S: Simd> Shr<u32> for u64x8<S>

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

Shift each element right by the given number of bits.

For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.

When shifting out of bounds (e.g. shifting a 32-bit value by 32 or more), the result is implementation-defined and may vary by platform.

type Output = u64x8<S>

The resulting type after applying the >> operator.

impl<S: Simd> ShrAssign for u64x8<S>

fn shr_assign(&mut self, rhs: Self)

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

For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.

When shifting out of bounds (e.g. shifting a 32-bit value by 32 or more), the result is implementation-defined and may vary by platform.

This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.

impl<S: Simd> ShrAssign<u32> for u64x8<S>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<S: Simd> SimdBase<S> for u64x8<S>

const N: usize = 8

This vector type’s lane count. This is useful when you’re working with a native-width vector (e.g. Simd::f32s) and want to process data in native-width chunks.

type Element = u64

The type of this vector’s elements.

type ByteVector = u8x64<S>

The same-width SIMD vector of u8 lanes used as the byte representation.

type Mask = mask64x8<S>

A SIMD vector mask with the same number of logical lanes.

type Block = u64x2<S>

A 128-bit SIMD vector of the same scalar type.

type Array = [u64; 8]

The array type that this vector type corresponds to, which will always be [Self::Element; Self::N]. It has the same layout as this vector type, but likely has a lower alignment.

fn witness(&self) -> S

Get the Simd implementation associated with this type.

fn as_slice(&self) -> &[u64]

fn as_mut_slice(&mut self) -> &mut [u64]

fn from_slice(simd: S, slice: &[u64]) -> Self

Create a SIMD vector from a slice.

fn store_slice(&self, slice: &mut [u64])

Store a SIMD vector into a slice.

fn splat(simd: S, val: u64) -> Self

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

fn block_splat(block: Self::Block) -> Self

Create a SIMD vector from a 128-bit vector of the same scalar type, repeated.

fn from_fn(simd: S, f: impl FnMut(usize) -> u64) -> Self

Create a SIMD vector where each element is produced by calling f with that element’s lane index (from 0 to SimdBase::N - 1).

fn slide<const SHIFT: usize>(self, rhs: impl SimdInto<Self, S>) -> Self

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

fn slide_within_blocks<const SHIFT: usize>( self, rhs: impl SimdInto<Self, S>, ) -> Self

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

fn swizzle_dyn_within_blocks( self, indices: impl SimdInto<Self::Bytes, S>, ) -> Self

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

fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self

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

fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self

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

fn max(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise maximum of two vectors.

fn min(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise minimum of two vectors.

fn max_precise(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise maximum of two vectors.

fn min_precise(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise minimum of two vectors.

fn simd_eq(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for equality.

fn simd_lt(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for less than.

fn simd_le(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

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

fn simd_ge(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

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

fn simd_gt(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for greater than.

fn zip_low(self, rhs: impl SimdInto<Self, S>) -> Self

Interleave the lower half elements of two vectors.

fn zip_high(self, rhs: impl SimdInto<Self, S>) -> Self

Interleave the upper half elements of two vectors.

fn unzip_low(self, rhs: impl SimdInto<Self, S>) -> Self

Extract even-indexed elements from two vectors.

fn unzip_high(self, rhs: impl SimdInto<Self, S>) -> Self

Extract odd-indexed elements from two vectors.

fn interleave(self, rhs: impl SimdInto<Self, S>) -> (Self, Self)

Interleave two vectors.

fn deinterleave(self, rhs: impl SimdInto<Self, S>) -> (Self, Self)

Deinterleave two vectors.

fn load_array(simd: S, val: Self::Array) -> Self

Create a SIMD vector from its corresponding lane array.

fn load_array_ref(simd: S, val: &Self::Array) -> Self

Create a SIMD vector from a reference to its corresponding lane array.

fn as_array(self) -> Self::Array

Convert this SIMD vector to its corresponding lane array.

fn as_array_ref(&self) -> &Self::Array

Project this SIMD vector reference to its corresponding lane array reference.

fn as_array_mut(&mut self) -> &mut Self::Array

Project this mutable SIMD vector reference to its corresponding mutable lane array reference.

fn store_array(self, dest: &mut Self::Array)

Store this SIMD vector into its corresponding lane array.

fn rotate_elements_left<const OFFSET: usize>(self) -> Self

Rotate the vector elements to the left by OFFSET.

fn rotate_elements_right<const OFFSET: usize>(self) -> Self

Rotate the vector elements to the right by OFFSET.

fn shift_elements_left<const OFFSET: usize>( self, padding: Self::Element, ) -> Self

Shift the vector elements to the left by OFFSET, filling in with padding from the right.

fn shift_elements_right<const OFFSET: usize>( self, padding: Self::Element, ) -> Self

Shift the vector elements to the right by OFFSET, filling in with padding from the left.

impl<S: Simd> SimdCvtFloat<u64x8<S>> for f64x8<S>

fn float_from(x: u64x8<S>) -> Self

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

Values that cannot be exactly represented are rounded to the nearest representable value.

impl<S: Simd> SimdCvtTruncate<f64x8<S>> for u64x8<S>

fn truncate_from(x: f64x8<S>) -> Self

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

Out-of-range values or NaN will produce implementation-defined results.

fn truncate_from_precise(x: f64x8<S>) -> Self

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

Out-of-range values are saturated to the closest in-range value. NaN becomes 0.

impl<S: Simd> SimdFrom<[u64; 8], S> for u64x8<S>

fn simd_from(simd: S, val: [u64; 8]) -> Self

impl<S: Simd> SimdFrom<__m512i, S> for u64x8<S>

Available on x86 or x86-64 only.

fn simd_from(simd: S, arch: __m512i) -> Self

impl<S: Simd> SimdFrom<u64, S> for u64x8<S>

fn simd_from(simd: S, value: u64) -> Self

impl<S: Simd> SimdInt<S> for u64x8<S>

fn to_float<T: SimdCvtFloat<Self>>(self) -> T

Convert this integer type to a floating-point type. This is a convenience method that delegates to SimdCvtFloat::float_from, and can only be called if there actually exists a target type of the same bit width (f32 or f64).

impl<S: Simd> SimdNarrow<S> for u64x8<S>

type Narrowed = u32x16<S>

The same-width vector type with lanes half as wide.

fn narrow(self, high: Self) -> Self::Narrowed

Narrow every lane.

fn saturating_narrow(self, high: Self) -> Self::Narrowed

Narrow with saturation for integers. Floats behave identically to narrow.

fn relaxed_narrow(self, high: Self) -> Self::Narrowed

Narrow using the cheapest operation for the active SIMD backend, assuming no overflow.

impl<S: Simd> SimdSplit<S> for u64x8<S>

type Split = u64x4<S>

fn split(self) -> (Self::Split, Self::Split)

Split this vector into left and right halves.

impl<S: Simd> Sub for u64x8<S>

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

Subtract two vectors element-wise, wrapping on overflow.

type Output = u64x8<S>

The resulting type after applying the - operator.

impl<S: Simd> Sub<u64> for u64x8<S>

type Output = u64x8<S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S: Simd> Sub<u64x8<S>> for u64

type Output = u64x8<S>

The resulting type after applying the - operator.

fn sub(self, rhs: u64x8<S>) -> Self::Output

Performs the - operation.

impl<S: Simd> SubAssign for u64x8<S>

fn sub_assign(&mut self, rhs: Self)

Subtract two vectors element-wise, wrapping on overflow.

impl<S: Simd> SubAssign<u64> for u64x8<S>

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.