Struct BitMask 

pub struct BitMask<const N: usize, A: Sealed = Current>(pub <Const<N> as SupportedLaneCount>::BitMaskType, _)
where
    Const<N>: SupportedLaneCount;

A lane-wise mask represented as a bit-mask.

The representation for this type is the smallest unsigned integer capable of holding N bits.

Tuple Fields

0: <Const<N> as SupportedLaneCount>::BitMaskType

Implementations

impl<const N: usize, A> BitMask<N, A>

where Const<N>: SupportedLaneCount, A: Sealed,

pub fn as_scalar(self) -> BitMask<N, Scalar>

pub fn as_current(self) -> BitMask<N, Current>

pub fn as_arch<B>(self, arch: B) -> BitMask<N, B>

where B: Sealed,

Trait Implementations

impl<const N: usize, A: Clone + Sealed> Clone for BitMask<N, A>

where Const<N>: SupportedLaneCount,

fn clone(&self) -> BitMask<N, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, A: Debug + Sealed> Debug for BitMask<N, A>

where Const<N>: SupportedLaneCount,

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

Formats the value using the given formatter.

impl From<BitMask<1>> for u8

fn from(value: BitMask<1>) -> Self

Converts to this type from the input type.

impl From<BitMask<16>> for u16

fn from(value: BitMask<16>) -> Self

Converts to this type from the input type.

impl From<BitMask<16, V3>> for mask8x16

fn from(mask: BitMask<16, V3>) -> Self

Converts to this type from the input type.

impl From<BitMask<2>> for u8

fn from(value: BitMask<2>) -> Self

Converts to this type from the input type.

impl From<BitMask<2, V3>> for mask64x2

fn from(mask: BitMask<2, V3>) -> Self

Converts to this type from the input type.

impl From<BitMask<32>> for u32

fn from(value: BitMask<32>) -> Self

Converts to this type from the input type.

impl From<BitMask<32, V3>> for mask8x32

fn from(mask: BitMask<32, V3>) -> Self

Converts to this type from the input type.

impl From<BitMask<4>> for u8

fn from(value: BitMask<4>) -> Self

Converts to this type from the input type.

impl From<BitMask<4, V3>> for mask32x4

fn from(mask: BitMask<4, V3>) -> Self

Converts to this type from the input type.

impl From<BitMask<4, V3>> for mask64x4

fn from(mask: BitMask<4, V3>) -> Self

Converts to this type from the input type.

impl From<BitMask<64>> for u64

fn from(value: BitMask<64>) -> Self

Converts to this type from the input type.

impl From<BitMask<8>> for u8

fn from(value: BitMask<8>) -> Self

Converts to this type from the input type.

impl From<BitMask<8, V3>> for mask32x8

fn from(mask: BitMask<8, V3>) -> Self

Converts to this type from the input type.

impl From<mask32x4> for BitMask<4, V3>

fn from(mask: mask32x4) -> Self

Converts to this type from the input type.

impl From<mask32x8> for BitMask<8, V3>

fn from(mask: mask32x8) -> Self

Converts to this type from the input type.

impl From<mask64x2> for BitMask<2, V3>

fn from(mask: mask64x2) -> Self

Converts to this type from the input type.

impl From<mask64x4> for BitMask<4, V3>

fn from(mask: mask64x4) -> Self

Converts to this type from the input type.

impl From<mask8x16> for BitMask<16, V3>

fn from(mask: mask8x16) -> Self

Converts to this type from the input type.

impl From<mask8x32> for BitMask<32, V3>

fn from(mask: mask8x32) -> Self

Converts to this type from the input type.

impl<A: Sealed> FromInt<u16, A> for BitMask<16, A>

const NARROWING: bool = false

Will the conversion only sample from the lower-order bits of the provided integer.

fn from_int(arch: A, value: u16) -> Self

Turn an integer into an instance of Self.

impl<A: Sealed> FromInt<u32, A> for BitMask<32, A>

const NARROWING: bool = false

Will the conversion only sample from the lower-order bits of the provided integer.

fn from_int(arch: A, value: u32) -> Self

Turn an integer into an instance of Self.

impl<A: Sealed> FromInt<u64, A> for BitMask<64, A>

const NARROWING: bool = false

Will the conversion only sample from the lower-order bits of the provided integer.

fn from_int(arch: A, value: u64) -> Self

Turn an integer into an instance of Self.

impl<A: Sealed> FromInt<u8, A> for BitMask<1, A>

const NARROWING: bool = true

Will the conversion only sample from the lower-order bits of the provided integer.

fn from_int(arch: A, value: u8) -> Self

Turn an integer into an instance of Self.

impl<A: Sealed> FromInt<u8, A> for BitMask<2, A>

const NARROWING: bool = true

Will the conversion only sample from the lower-order bits of the provided integer.

fn from_int(arch: A, value: u8) -> Self

Turn an integer into an instance of Self.

impl<A: Sealed> FromInt<u8, A> for BitMask<4, A>

const NARROWING: bool = true

Will the conversion only sample from the lower-order bits of the provided integer.

fn from_int(arch: A, value: u8) -> Self

Turn an integer into an instance of Self.

impl<A: Sealed> FromInt<u8, A> for BitMask<8, A>

const NARROWING: bool = false

Will the conversion only sample from the lower-order bits of the provided integer.

fn from_int(arch: A, value: u8) -> Self

Turn an integer into an instance of Self.

impl<const N: usize, A: PartialEq + Sealed> PartialEq for BitMask<N, A>

where Const<N>: SupportedLaneCount,

fn eq(&self, other: &BitMask<N, A>) -> 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<A: Sealed> SIMDMask for BitMask<1, A>

const ISBITS: bool = true

Whether or not this mask implementation is a bit mask.

const LANES: usize = 1

The number of lanes in the bitmask.

type Arch = A

The architecture type this struct belongs to.

type Underlying = u8

The type of the underlying intrinsic.

type BitMask = BitMask<1, A>

The bitmask associated with the logical mask.

fn arch(self) -> A

Return the architecture object associated with this vector.

fn to_underlying(self) -> Self::Underlying

Retrieve the underlying type. This will always be an unsigned integer of the minimum width required to contain LANES bits.

fn from_underlying(arch: A, value: Self::Underlying) -> Self

Construct the mask from the underlying type.

fn keep_first(arch: A, i: usize) -> Self

Efficiently construct a new mask with the first i bits set and the remainder set to zero.

fn get_unchecked(&self, i: usize) -> bool

Return true if lane i is set and false otherwise.

fn first(&self) -> Option<usize>

Return the first set index in the mask or None if no entries are set.

fn from_fn<F>(arch: A, f: F) -> Self

where F: FnMut(usize) -> bool,

Construct a mask based on the result of invoking f once each element in the range 0..Self::LANES in order.

fn any(self) -> bool

Return true if any lane in the mask is set. Otherwise, return `false.

fn all(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

fn count(self) -> usize

Return the number of lanes that evaluate to true.

fn bitmask(self) -> Self::BitMask

Return the associated BitMask for this Mask.

fn get(&self, i: usize) -> Option<bool>

Return true if lane i is set and false otherwise. Returns an empty Option if the index i is out-of-bounds.

fn none(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

impl<A: Sealed> SIMDMask for BitMask<16, A>

const ISBITS: bool = true

Whether or not this mask implementation is a bit mask.

const LANES: usize = 16

The number of lanes in the bitmask.

type Arch = A

The architecture type this struct belongs to.

type Underlying = u16

The type of the underlying intrinsic.

type BitMask = BitMask<16, A>

The bitmask associated with the logical mask.

fn arch(self) -> A

Return the architecture object associated with this vector.

fn to_underlying(self) -> Self::Underlying

Retrieve the underlying type. This will always be an unsigned integer of the minimum width required to contain LANES bits.

fn from_underlying(arch: A, value: Self::Underlying) -> Self

Construct the mask from the underlying type.

fn keep_first(arch: A, i: usize) -> Self

Efficiently construct a new mask with the first i bits set and the remainder set to zero.

fn get_unchecked(&self, i: usize) -> bool

Return true if lane i is set and false otherwise.

fn first(&self) -> Option<usize>

Return the first set index in the mask or None if no entries are set.

fn from_fn<F>(arch: A, f: F) -> Self

where F: FnMut(usize) -> bool,

Construct a mask based on the result of invoking f once each element in the range 0..Self::LANES in order.

fn any(self) -> bool

Return true if any lane in the mask is set. Otherwise, return `false.

fn all(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

fn count(self) -> usize

Return the number of lanes that evaluate to true.

fn bitmask(self) -> Self::BitMask

Return the associated BitMask for this Mask.

fn get(&self, i: usize) -> Option<bool>

Return true if lane i is set and false otherwise. Returns an empty Option if the index i is out-of-bounds.

fn none(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

impl<A: Sealed> SIMDMask for BitMask<2, A>

const ISBITS: bool = true

Whether or not this mask implementation is a bit mask.

const LANES: usize = 2

The number of lanes in the bitmask.

type Arch = A

The architecture type this struct belongs to.

type Underlying = u8

The type of the underlying intrinsic.

type BitMask = BitMask<2, A>

The bitmask associated with the logical mask.

fn arch(self) -> A

Return the architecture object associated with this vector.

fn to_underlying(self) -> Self::Underlying

Retrieve the underlying type. This will always be an unsigned integer of the minimum width required to contain LANES bits.

fn from_underlying(arch: A, value: Self::Underlying) -> Self

Construct the mask from the underlying type.

fn keep_first(arch: A, i: usize) -> Self

Efficiently construct a new mask with the first i bits set and the remainder set to zero.

fn get_unchecked(&self, i: usize) -> bool

Return true if lane i is set and false otherwise.

fn first(&self) -> Option<usize>

Return the first set index in the mask or None if no entries are set.

fn from_fn<F>(arch: A, f: F) -> Self

where F: FnMut(usize) -> bool,

Construct a mask based on the result of invoking f once each element in the range 0..Self::LANES in order.

fn any(self) -> bool

Return true if any lane in the mask is set. Otherwise, return `false.

fn all(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

fn count(self) -> usize

Return the number of lanes that evaluate to true.

fn bitmask(self) -> Self::BitMask

Return the associated BitMask for this Mask.

fn get(&self, i: usize) -> Option<bool>

Return true if lane i is set and false otherwise. Returns an empty Option if the index i is out-of-bounds.

fn none(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

impl<A: Sealed> SIMDMask for BitMask<32, A>

const ISBITS: bool = true

Whether or not this mask implementation is a bit mask.

const LANES: usize = 32

The number of lanes in the bitmask.

type Arch = A

The architecture type this struct belongs to.

type Underlying = u32

The type of the underlying intrinsic.

type BitMask = BitMask<32, A>

The bitmask associated with the logical mask.

fn arch(self) -> A

Return the architecture object associated with this vector.

fn to_underlying(self) -> Self::Underlying

Retrieve the underlying type. This will always be an unsigned integer of the minimum width required to contain LANES bits.

fn from_underlying(arch: A, value: Self::Underlying) -> Self

Construct the mask from the underlying type.

fn keep_first(arch: A, i: usize) -> Self

Efficiently construct a new mask with the first i bits set and the remainder set to zero.

fn get_unchecked(&self, i: usize) -> bool

Return true if lane i is set and false otherwise.

fn first(&self) -> Option<usize>

Return the first set index in the mask or None if no entries are set.

fn from_fn<F>(arch: A, f: F) -> Self

where F: FnMut(usize) -> bool,

Construct a mask based on the result of invoking f once each element in the range 0..Self::LANES in order.

fn any(self) -> bool

Return true if any lane in the mask is set. Otherwise, return `false.

fn all(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

fn count(self) -> usize

Return the number of lanes that evaluate to true.

fn bitmask(self) -> Self::BitMask

Return the associated BitMask for this Mask.

fn get(&self, i: usize) -> Option<bool>

Return true if lane i is set and false otherwise. Returns an empty Option if the index i is out-of-bounds.

fn none(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

impl<A: Sealed> SIMDMask for BitMask<4, A>

const ISBITS: bool = true

Whether or not this mask implementation is a bit mask.

const LANES: usize = 4

The number of lanes in the bitmask.

type Arch = A

The architecture type this struct belongs to.

type Underlying = u8

The type of the underlying intrinsic.

type BitMask = BitMask<4, A>

The bitmask associated with the logical mask.

fn arch(self) -> A

Return the architecture object associated with this vector.

fn to_underlying(self) -> Self::Underlying

Retrieve the underlying type. This will always be an unsigned integer of the minimum width required to contain LANES bits.

fn from_underlying(arch: A, value: Self::Underlying) -> Self

Construct the mask from the underlying type.

fn keep_first(arch: A, i: usize) -> Self

Efficiently construct a new mask with the first i bits set and the remainder set to zero.

fn get_unchecked(&self, i: usize) -> bool

Return true if lane i is set and false otherwise.

fn first(&self) -> Option<usize>

Return the first set index in the mask or None if no entries are set.

fn from_fn<F>(arch: A, f: F) -> Self

where F: FnMut(usize) -> bool,

Construct a mask based on the result of invoking f once each element in the range 0..Self::LANES in order.

fn any(self) -> bool

Return true if any lane in the mask is set. Otherwise, return `false.

fn all(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

fn count(self) -> usize

Return the number of lanes that evaluate to true.

fn bitmask(self) -> Self::BitMask

Return the associated BitMask for this Mask.

fn get(&self, i: usize) -> Option<bool>

Return true if lane i is set and false otherwise. Returns an empty Option if the index i is out-of-bounds.

fn none(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

impl<A: Sealed> SIMDMask for BitMask<64, A>

const ISBITS: bool = true

Whether or not this mask implementation is a bit mask.

const LANES: usize = 64

The number of lanes in the bitmask.

type Arch = A

The architecture type this struct belongs to.

type Underlying = u64

The type of the underlying intrinsic.

type BitMask = BitMask<64, A>

The bitmask associated with the logical mask.

fn arch(self) -> A

Return the architecture object associated with this vector.

fn to_underlying(self) -> Self::Underlying

Retrieve the underlying type. This will always be an unsigned integer of the minimum width required to contain LANES bits.

fn from_underlying(arch: A, value: Self::Underlying) -> Self

Construct the mask from the underlying type.

fn keep_first(arch: A, i: usize) -> Self

Efficiently construct a new mask with the first i bits set and the remainder set to zero.

fn get_unchecked(&self, i: usize) -> bool

Return true if lane i is set and false otherwise.

fn first(&self) -> Option<usize>

Return the first set index in the mask or None if no entries are set.

fn from_fn<F>(arch: A, f: F) -> Self

where F: FnMut(usize) -> bool,

Construct a mask based on the result of invoking f once each element in the range 0..Self::LANES in order.

fn any(self) -> bool

Return true if any lane in the mask is set. Otherwise, return `false.

fn all(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

fn count(self) -> usize

Return the number of lanes that evaluate to true.

fn bitmask(self) -> Self::BitMask

Return the associated BitMask for this Mask.

fn get(&self, i: usize) -> Option<bool>

Return true if lane i is set and false otherwise. Returns an empty Option if the index i is out-of-bounds.

fn none(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

impl<A: Sealed> SIMDMask for BitMask<8, A>

const ISBITS: bool = true

Whether or not this mask implementation is a bit mask.

const LANES: usize = 8

The number of lanes in the bitmask.

type Arch = A

The architecture type this struct belongs to.

type Underlying = u8

The type of the underlying intrinsic.

type BitMask = BitMask<8, A>

The bitmask associated with the logical mask.

fn arch(self) -> A

Return the architecture object associated with this vector.

fn to_underlying(self) -> Self::Underlying

Retrieve the underlying type. This will always be an unsigned integer of the minimum width required to contain LANES bits.

fn from_underlying(arch: A, value: Self::Underlying) -> Self

Construct the mask from the underlying type.

fn keep_first(arch: A, i: usize) -> Self

Efficiently construct a new mask with the first i bits set and the remainder set to zero.

fn get_unchecked(&self, i: usize) -> bool

Return true if lane i is set and false otherwise.

fn first(&self) -> Option<usize>

Return the first set index in the mask or None if no entries are set.

fn from_fn<F>(arch: A, f: F) -> Self

where F: FnMut(usize) -> bool,

Construct a mask based on the result of invoking f once each element in the range 0..Self::LANES in order.

fn any(self) -> bool

Return true if any lane in the mask is set. Otherwise, return `false.

fn all(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

fn count(self) -> usize

Return the number of lanes that evaluate to true.

fn bitmask(self) -> Self::BitMask

Return the associated BitMask for this Mask.

fn get(&self, i: usize) -> Option<bool>

Return true if lane i is set and false otherwise. Returns an empty Option if the index i is out-of-bounds.

fn none(self) -> bool

Return true if all lanes in the mask are set. Otherwise, return false.

impl<T, const N: usize, A> SIMDSelect<Emulated<T, N, A>> for BitMask<N, A>

where T: Copy, A: Sealed, Const<N>: SupportedLaneCount, BitMask<N, A>: SIMDMask<Arch = A>, Emulated<T, N, A>: SIMDVector<Mask = BitMask<N, A>>,

fn select(self, x: Emulated<T, N, A>, y: Emulated<T, N, A>) -> Emulated<T, N, A>

impl SIMDSelect<f32x16> for BitMask<16, V4>

fn select(self, x: f32x16, y: f32x16) -> f32x16

impl SIMDSelect<f32x4> for BitMask<4, V4>

fn select(self, x: f32x4, y: f32x4) -> f32x4

impl SIMDSelect<f32x8> for BitMask<8, V4>

fn select(self, x: f32x8, y: f32x8) -> f32x8

impl SIMDSelect<i32x16> for BitMask<16, V4>

fn select(self, x: i32x16, y: i32x16) -> i32x16

impl SIMDSelect<i32x8> for BitMask<8, V4>

fn select(self, x: i32x8, y: i32x8) -> i32x8

impl SIMDSelect<u32x16> for BitMask<16, V4>

fn select(self, x: u32x16, y: u32x16) -> u32x16

impl SIMDSelect<u32x4> for BitMask<4, V4>

fn select(self, x: u32x4, y: u32x4) -> u32x4

impl SIMDSelect<u32x8> for BitMask<8, V4>

fn select(self, x: u32x8, y: u32x8) -> u32x8

impl<A: Sealed> SplitJoin for BitMask<16, A>

type Halved = BitMask<8, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A: Sealed> SplitJoin for BitMask<2, A>

type Halved = BitMask<1, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A: Sealed> SplitJoin for BitMask<32, A>

type Halved = BitMask<16, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A: Sealed> SplitJoin for BitMask<4, A>

type Halved = BitMask<2, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A: Sealed> SplitJoin for BitMask<64, A>

type Halved = BitMask<32, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A: Sealed> SplitJoin for BitMask<8, A>

type Halved = BitMask<4, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<const N: usize, A: Copy + Sealed> Copy for BitMask<N, A>

where Const<N>: SupportedLaneCount,

impl<const N: usize, A: Eq + Sealed> Eq for BitMask<N, A>

where Const<N>: SupportedLaneCount,

impl<const N: usize, A: Sealed> StructuralPartialEq for BitMask<N, A>

where Const<N>: SupportedLaneCount,