Struct mask8x32 

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

A SIMD mask of 32 8-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::mask8x32

simd: S

Trait Implementations

impl<S: Simd> BitAnd<i8> for mask8x32<S>

type Output = mask8x32<S>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<S: Simd> BitAnd<mask8x32<S>> for i8

type Output = mask8x32<S>

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Compute the logical AND of two masks.

type Output = mask8x32<S>

The resulting type after applying the & operator.

impl<S: Simd> BitAndAssign<i8> for mask8x32<S>

fn bitand_assign(&mut self, rhs: i8)

Performs the &= operation.

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

fn bitand_assign(&mut self, rhs: Self)

Compute the logical AND of two masks.

impl<S: Simd> BitOr<i8> for mask8x32<S>

type Output = mask8x32<S>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<S: Simd> BitOr<mask8x32<S>> for i8

type Output = mask8x32<S>

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Compute the logical OR of two masks.

type Output = mask8x32<S>

The resulting type after applying the | operator.

impl<S: Simd> BitOrAssign<i8> for mask8x32<S>

fn bitor_assign(&mut self, rhs: i8)

Performs the |= operation.

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

fn bitor_assign(&mut self, rhs: Self)

Compute the logical OR of two masks.

impl<S: Simd> BitXor<i8> for mask8x32<S>

type Output = mask8x32<S>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<S: Simd> BitXor<mask8x32<S>> for i8

type Output = mask8x32<S>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Compute the logical XOR of two masks.

type Output = mask8x32<S>

The resulting type after applying the ^ operator.

impl<S: Simd> BitXorAssign<i8> for mask8x32<S>

fn bitxor_assign(&mut self, rhs: i8)

Performs the ^= operation.

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

fn bitxor_assign(&mut self, rhs: Self)

Compute the logical XOR of two masks.

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

type Bytes = u8x32<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 mask8x32<S>

where S::mask8x32: Clone,

fn clone(&self) -> mask8x32<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 mask8x32<S>

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

Formats the value using the given formatter.

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

type Target = [i8; 32]

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

impl<S: Simd> From<mask8x32<S>> for [i8; 32]

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

Converts to this type from the input type.

impl<S: Simd> From<mask8x32<S>> for __m256i

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

Converts to this type from the input type.

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

type Output = i8

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

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

fn not(self) -> Self::Output

Compute the logical NOT of the mask.

type Output = mask8x32<S>

The resulting type after applying the ! operator.

impl<S: Simd> Select<i8x32<S>> for mask8x32<S>

fn select(self, if_true: i8x32<S>, if_false: i8x32<S>) -> i8x32<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<mask8x32<S>> for mask8x32<S>

fn select(self, if_true: mask8x32<S>, if_false: mask8x32<S>) -> mask8x32<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<u8x32<S>> for mask8x32<S>

fn select(self, if_true: u8x32<S>, if_false: u8x32<S>) -> u8x32<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 mask8x32<S>

const N: usize = 32

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 = i8

The type of this vector’s elements.

type Mask = mask8x32<S>

A SIMD vector mask with the same number of elements.

type Block = mask8x16<S>

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

type Array = [i8; 32]

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) -> &[i8]

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

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

Create a SIMD vector from a slice.

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

Store a SIMD vector into a slice.

fn splat(simd: S, val: i8) -> 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) -> i8) -> 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> SimdCombine<S> for mask8x32<S>

type Combined = mask8x64<S>

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

Concatenate two vectors into a new one that’s twice as long.

impl<S: Simd> SimdFrom<[i8; 32], S> for mask8x32<S>

fn simd_from(simd: S, val: [i8; 32]) -> Self

impl<S: Simd> SimdFrom<__m256i, S> for mask8x32<S>

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

impl<S: Simd> SimdFrom<i8, S> for mask8x32<S>

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

impl<S: Simd> SimdMask<S> for mask8x32<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 mask8x32<S>

type Split = mask8x16<S>

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

Split this vector into left and right halves.

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

where S::mask8x32: Copy,