Struct mask64x8 

#[repr(C, align(64))]
pub struct mask64x8<S: Simd> {
    pub(crate) val: S::mask64x8,
    pub simd: S,
}

A SIMD mask of 8 64-bit elements.

When created from a comparison operation, and as it should be used in a Self::select operation, each element will be all ones if it’s “true”, and all zeroes if it’s “false”.

Fields

val: S::mask64x8

simd: S

Trait Implementations

impl<S: Simd> BitAnd<i64> for mask64x8<S>

type Output = mask64x8<S>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<S: Simd> BitAnd<mask64x8<S>> for i64

type Output = mask64x8<S>

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Compute the logical AND of two masks.

type Output = mask64x8<S>

The resulting type after applying the & operator.

impl<S: Simd> BitAndAssign<i64> for mask64x8<S>

fn bitand_assign(&mut self, rhs: i64)

Performs the &= operation.

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

fn bitand_assign(&mut self, rhs: Self)

Compute the logical AND of two masks.

impl<S: Simd> BitOr<i64> for mask64x8<S>

type Output = mask64x8<S>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<S: Simd> BitOr<mask64x8<S>> for i64

type Output = mask64x8<S>

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Compute the logical OR of two masks.

type Output = mask64x8<S>

The resulting type after applying the | operator.

impl<S: Simd> BitOrAssign<i64> for mask64x8<S>

fn bitor_assign(&mut self, rhs: i64)

Performs the |= operation.

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

fn bitor_assign(&mut self, rhs: Self)

Compute the logical OR of two masks.

impl<S: Simd> BitXor<i64> for mask64x8<S>

type Output = mask64x8<S>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<S: Simd> BitXor<mask64x8<S>> for i64

type Output = mask64x8<S>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Compute the logical XOR of two masks.

type Output = mask64x8<S>

The resulting type after applying the ^ operator.

impl<S: Simd> BitXorAssign<i64> for mask64x8<S>

fn bitxor_assign(&mut self, rhs: i64)

Performs the ^= operation.

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

fn bitxor_assign(&mut self, rhs: Self)

Compute the logical XOR of two masks.

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

type Bytes = u8x64<S>

fn to_bytes(self) -> Self::Bytes

Convert this type to an array of bytes.

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

Create an instance of this type from an array of bytes.

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

Bitcast directly from this type to another one of the same size.

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

where S::mask64x8: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

type Target = [i64; 8]

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

impl<S: Simd> From<mask64x8<S>> for [i64; 8]

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

Converts to this type from the input type.

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

type Output = i64

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

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

fn not(self) -> Self::Output

Compute the logical NOT of the mask.

type Output = mask64x8<S>

The resulting type after applying the ! operator.

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

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

For each element of this mask, select the first operand if the element is all ones, and select the second operand if the element is all zeroes.

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

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

For each element of this mask, select the first operand if the element is all ones, and select the second operand if the element is all zeroes.

impl<S: Simd> SimdBase<S> for mask64x8<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 = i64

The type of this vector’s elements.

type Mask = mask64x8<S>

A SIMD vector mask with the same number of elements.

type Block = mask64x2<S>

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

type Array = [i64; 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) -> &[i64]

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

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

Create a SIMD vector from a slice.

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

Store a SIMD vector into a slice.

fn splat(simd: S, val: i64) -> 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) -> i64) -> 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.

impl<S: Simd> SimdFrom<[i64; 8], S> for mask64x8<S>

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

impl<S: Simd> SimdFrom<i64, S> for mask64x8<S>

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

impl<S: Simd> SimdMask<S> for mask64x8<S>

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

Compare two vectors element-wise for equality.

fn any_true(self) -> bool

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

fn all_true(self) -> bool

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

fn any_false(self) -> bool

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

fn all_false(self) -> bool

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

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

type Split = mask64x4<S>

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

Split this vector into left and right halves.

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

where S::mask64x8: Copy,