Struct Mask 

pub struct Mask<const N: usize, T, A: Alignment>(/* private fields */)
where
    Length<N>: SupportedLength,
    T: Scalar;

A generic vector mask.

Mask is the generic form of:

• Mask2<T>
• Mask3<T>
• Mask4<T>
• Mask2U<T>
• Mask3U<T>
• Mask4U<T>

Mask is generic over:

• N: Length (2, 3, or 4)
• T: Scalar type (see Scalar)
• A: Alignment (see Alignment)

To initialize masks, use the functions Mask2::new, Mask3::new, Mask4::new. To initialize a mask of an unknown length, use Mask::from_array.

Guarantees

Mask<N, T, A> doesn’t have a stable representation, but does guarantee certain properties.

Mask<N, T, A> bytes are initialized and zeroable.

Masks of scalar types with the same Scalar::Repr are guaranteed to have compatible memory layouts, even if Repr = (). They are guaranteed to have the same size, element positions, and alignment.

Types containing compatible Mask types are not guaranteed to have the same memory layout. For example, even though Mask2<bool> and Mask2<u8> have the same memory layout, Option<Mask2<bool>> and Option<Mask2<u8>> may not.

Implementations

impl<const N: usize, T, A: Alignment> Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

pub fn from_array(array: [bool; N]) -> Self

Creates a mask from an array.

The preferable way to create masks is using the functions Mask2::new, Mask3::new, Mask4::new.

Mask::from_array should only be used when the length of the mask is unknown or when directly converting from an array.

pub fn splat(value: bool) -> Self

Creates a mask with all components set to the given value.

pub fn from_fn<F>(f: F) -> Self

where F: FnMut(usize) -> bool,

Creates a mask by calling function f for each component index.

Equivalent to (f(0), f(1), f(2), ...).

pub fn to_alignment<A2: Alignment>(self) -> Mask<N, T, A2>

Converts the mask to the specified alignment.

See Alignment for more information.

pub fn align(self) -> Mask<N, T, Aligned>

Converts the mask to Aligned alignment.

See Alignment for more information.

pub fn unalign(self) -> Mask<N, T, Unaligned>

Converts the mask to Unaligned alignment.

See Alignment for more information.

pub fn to_array(self) -> [bool; N]

Converts the mask to an array.

pub fn all(self) -> bool

Returns true if all of the mask’s components are true.

pub fn any(self) -> bool

Returns true if any of the mask’s components are true.

pub fn select( self, if_true: Vector<N, T, A>, if_false: Vector<N, T, A>, ) -> Vector<N, T, A>

Selects between the components of if_true and if_false based on the values of the mask.

pub fn iter(self) -> IntoIter<bool, N>

Returns an iterator over the mask’s components.

pub fn get(self, index: usize) -> bool

Returns the component at the given index.

Panics

Panics if the index is out of bounds.

pub fn set(&mut self, index: usize, value: bool)

Sets the component at the given index.

Panics

Panics if the index is out of bounds.

pub const fn to_repr<T2>(self) -> Mask<N, T2, A>

where T2: Scalar<Repr = T::Repr>,

Reinterprets the bits of the mask to a different scalar type.

The two scalar types must have compatible memory layouts. This is enforced via trait bounds in this function’s signature.

This function is used to make SIMD optimizations in implementations of Scalar.

impl<T, A: Alignment> Mask<2, T, A>

where T: Scalar,

pub fn new(x: bool, y: bool) -> Self

Creates a 2-component mask.

impl<T, A: Alignment> Mask<3, T, A>

where T: Scalar,

pub fn new(x: bool, y: bool, z: bool) -> Self

Creates a 3-component mask.

impl<T, A: Alignment> Mask<4, T, A>

where T: Scalar,

pub fn new(x: bool, y: bool, z: bool, w: bool) -> Self

Creates a 4-component mask.

Trait Implementations

impl<const N: usize, T, A: Alignment> BitAnd<bool> for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Output = Mask<N, T, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<const N: usize, T, A: Alignment> BitAnd for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Output = Mask<N, T, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<const N: usize, T, A: Alignment> BitAndAssign<bool> for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn bitand_assign(&mut self, rhs: bool)

Performs the &= operation.

impl<const N: usize, T, A: Alignment> BitAndAssign for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const N: usize, T, A: Alignment> BitOr<bool> for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Output = Mask<N, T, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<const N: usize, T, A: Alignment> BitOr for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Output = Mask<N, T, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<const N: usize, T, A: Alignment> BitOrAssign<bool> for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn bitor_assign(&mut self, rhs: bool)

Performs the |= operation.

impl<const N: usize, T, A: Alignment> BitOrAssign for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const N: usize, T, A: Alignment> BitXor<bool> for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Output = Mask<N, T, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const N: usize, T, A: Alignment> BitXor for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Output = Mask<N, T, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const N: usize, T, A: Alignment> BitXorAssign<bool> for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn bitxor_assign(&mut self, rhs: bool)

Performs the ^= operation.

impl<const N: usize, T, A: Alignment> BitXorAssign for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const N: usize, T, A: Alignment> Clone for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, T, A: Alignment> Debug for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

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

Formats the value using the given formatter.

impl<const N: usize, T, A: Alignment> Default for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize, T, A: Alignment> Display for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

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

Formats the value using the given formatter.

impl<const N: usize, T, A: Alignment> Hash for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize, T, A: Alignment> IntoIterator for &Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Item = bool

The type of the elements being iterated over.

type IntoIter = IntoIter<bool, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const N: usize, T, A: Alignment> IntoIterator for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Item = bool

The type of the elements being iterated over.

type IntoIter = IntoIter<bool, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const N: usize, T, A: Alignment> Not for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Output = Mask<N, T, A>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const N: usize, T, A: Alignment> PartialEq for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize, T, A: Alignment> Copy for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

impl<const N: usize, T, A: Alignment> Eq for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

impl<const N: usize, T, A: Alignment> RefUnwindSafe for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

impl<const N: usize, T, A: Alignment> Send for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

impl<const N: usize, T, A: Alignment> Sync for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

impl<const N: usize, T, A: Alignment> Unpin for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

impl<const N: usize, T, A: Alignment> UnwindSafe for Mask<N, T, A>

where Length<N>: SupportedLength, T: Scalar,