#[repr(transparent)]pub struct Mask<T, const LANES: usize>(_)
 where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount;Expand description
A SIMD vector mask for LANES elements of width specified by Element.
The layout of this type is unspecified.
Implementations
sourceimpl<T, const LANES: usize> Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourcepub fn from_array(array: [bool; LANES]) -> Self
 
pub fn from_array(array: [bool; LANES]) -> Self
Converts an array of bools to a SIMD mask.
sourcepub unsafe fn from_int_unchecked(value: Simd<T, LANES>) -> Self
 
pub unsafe fn from_int_unchecked(value: Simd<T, LANES>) -> Self
Converts a vector of integers to a mask, where 0 represents false and -1
represents true.
Safety
All lanes must be either 0 or -1.
sourcepub fn from_int(value: Simd<T, LANES>) -> Self
 
pub fn from_int(value: Simd<T, LANES>) -> Self
Converts a vector of integers to a mask, where 0 represents false and -1
represents true.
Panics
Panics if any lane is not 0 or -1.
sourcepub fn to_int(self) -> Simd<T, LANES>
 
pub fn to_int(self) -> Simd<T, LANES>
Converts the mask to a vector of integers, where 0 represents false and -1
represents true.
sourcepub unsafe fn test_unchecked(&self, lane: usize) -> bool
 
pub unsafe fn test_unchecked(&self, lane: usize) -> bool
sourcepub fn test(&self, lane: usize) -> bool
 
pub fn test(&self, lane: usize) -> bool
Tests the value of the specified lane.
Panics
Panics if lane is greater than or equal to the number of lanes in the vector.
sourcepub unsafe fn set_unchecked(&mut self, lane: usize, value: bool)
 
pub unsafe fn set_unchecked(&mut self, lane: usize, value: bool)
sourcepub fn set(&mut self, lane: usize, value: bool)
 
pub fn set(&mut self, lane: usize, value: bool)
Sets the value of the specified lane.
Panics
Panics if lane is greater than or equal to the number of lanes in the vector.
sourceimpl<T, const LANES: usize> Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourcepub fn select<U>(
    self, 
    true_values: Simd<U, LANES>, 
    false_values: Simd<U, LANES>
) -> Simd<U, LANES> where
    U: SimdElement<Mask = T>, 
 
pub fn select<U>(
    self, 
    true_values: Simd<U, LANES>, 
    false_values: Simd<U, LANES>
) -> Simd<U, LANES> where
    U: SimdElement<Mask = T>, 
Choose lanes from two vectors.
For each lane in the mask, choose the corresponding lane from true_values if
that lane mask is true, and false_values if that lane mask is false.
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let mask = Mask::from_array([true, false, false, true]);
let c = mask.select(a, b);
assert_eq!(c.to_array(), [0, 5, 6, 3]);sourcepub fn select_mask(self, true_values: Self, false_values: Self) -> Self
 
pub fn select_mask(self, true_values: Self, false_values: Self) -> Self
Choose lanes from two masks.
For each lane in the mask, choose the corresponding lane from true_values if
that lane mask is true, and false_values if that lane mask is false.
let a = Mask::<i32, 4>::from_array([true, true, false, false]);
let b = Mask::<i32, 4>::from_array([false, false, true, true]);
let mask = Mask::<i32, 4>::from_array([true, false, false, true]);
let c = mask.select_mask(a, b);
assert_eq!(c.to_array(), [true, false, true, false]);Trait Implementations
sourceimpl<T, const LANES: usize> BitAnd<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitAnd<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitAnd<Mask<T, LANES>> for bool where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitAnd<Mask<T, LANES>> for bool where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitAnd<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitAnd<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitAndAssign<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitAndAssign<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourcefn bitand_assign(&mut self, rhs: Self)
 
fn bitand_assign(&mut self, rhs: Self)
Performs the &= operation. Read more
sourceimpl<T, const LANES: usize> BitAndAssign<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitAndAssign<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourcefn bitand_assign(&mut self, rhs: bool)
 
fn bitand_assign(&mut self, rhs: bool)
Performs the &= operation. Read more
sourceimpl<T, const LANES: usize> BitOr<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitOr<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitOr<Mask<T, LANES>> for bool where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitOr<Mask<T, LANES>> for bool where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitOr<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitOr<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitOrAssign<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitOrAssign<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourcefn bitor_assign(&mut self, rhs: Self)
 
fn bitor_assign(&mut self, rhs: Self)
Performs the |= operation. Read more
sourceimpl<T, const LANES: usize> BitOrAssign<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitOrAssign<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourcefn bitor_assign(&mut self, rhs: bool)
 
fn bitor_assign(&mut self, rhs: bool)
Performs the |= operation. Read more
sourceimpl<T, const LANES: usize> BitXor<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitXor<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitXor<Mask<T, LANES>> for bool where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitXor<Mask<T, LANES>> for bool where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitXor<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitXor<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> BitXorAssign<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitXorAssign<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourcefn bitxor_assign(&mut self, rhs: Self)
 
fn bitxor_assign(&mut self, rhs: Self)
Performs the ^= operation. Read more
sourceimpl<T, const LANES: usize> BitXorAssign<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> BitXorAssign<bool> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourcefn bitxor_assign(&mut self, rhs: bool)
 
fn bitxor_assign(&mut self, rhs: bool)
Performs the ^= operation. Read more
sourceimpl<T, const LANES: usize> Clone for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> Clone for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> Debug for Mask<T, LANES> where
    T: MaskElement + Debug,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> Debug for Mask<T, LANES> where
    T: MaskElement + Debug,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> Default for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> Default for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> From<[bool; LANES]> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> From<[bool; LANES]> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES] where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES] where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i16, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i16, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i32, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i32, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i64, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i64, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i64, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i64, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i64, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i64, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i64, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i64, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i8, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i8, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i8, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i8, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i8, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i8, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<i8, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<i8, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> Not for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> Not for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> PartialEq<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement + PartialEq,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> PartialEq<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement + PartialEq,
    LaneCount<LANES>: SupportedLaneCount, 
sourceimpl<T, const LANES: usize> PartialOrd<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement + PartialOrd,
    LaneCount<LANES>: SupportedLaneCount, 
 
impl<T, const LANES: usize> PartialOrd<Mask<T, LANES>> for Mask<T, LANES> where
    T: MaskElement + PartialOrd,
    LaneCount<LANES>: SupportedLaneCount, 
sourcefn partial_cmp(&self, other: &Self) -> Option<Ordering>
 
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
 
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
 
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
impl<T, const LANES: usize> Copy for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 
Auto Trait Implementations
impl<T, const LANES: usize> RefUnwindSafe for Mask<T, LANES> where
    T: RefUnwindSafe, 
impl<T, const LANES: usize> Send for Mask<T, LANES> where
    T: Send, 
impl<T, const LANES: usize> Sync for Mask<T, LANES> where
    T: Sync, 
impl<T, const LANES: usize> Unpin for Mask<T, LANES> where
    T: Unpin, 
impl<T, const LANES: usize> UnwindSafe for Mask<T, LANES> where
    T: UnwindSafe, 
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
    T: ?Sized, 
 
impl<T> BorrowMut<T> for T where
    T: ?Sized, 
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more