Struct BitMask 

#[repr(transparent)]
pub struct BitMask<const N: usize>(pub u64);

Bit-packed predicate mask for exactly N SIMD lanes.

The inner u64 stores one bit per lane: bit i = lane i is active. Invariant: (self.0 >> N) == 0 (high bits always clear).

N must satisfy N <= 64. Violations are caught by a const assertion in ALL_ACTIVE.

Tuple Fields

0: u64

Implementations

impl<const N: usize> BitMask<N>

pub const ALL_ACTIVE: BitMask<N>

All N lanes active.

Panics (compile-time)

Panics at compile time if N > 64.

pub const NONE_ACTIVE: BitMask<N>

No lanes active.

pub const fn leading_k(k: usize) -> BitMask<N>

First k lanes active, rest inactive. Clamps k to N.

This is a const fn so it can be used in const contexts.

Examples

use hermes_simd_core::mask::BitMask;
assert_eq!(BitMask::<8>::leading_k(5).0, 0b00011111);
assert_eq!(BitMask::<8>::leading_k(0).0, 0);
assert_eq!(BitMask::<8>::leading_k(8).0, 0xFF);

pub fn from_bools(bits: &[bool]) -> BitMask<N>

Build a mask from a bool slice of length N.

Bit i is set if bits[i] is true.

Panics

Panics in debug mode if bits.len() != N.

pub fn popcount(self) -> u32

Number of active (set) lanes.

pub fn is_all_active(self) -> bool

Returns true if all N lanes are active.

pub fn is_none_active(self) -> bool

Returns true if no lanes are active.

pub fn is_lane_active(self, i: usize) -> bool

Returns true if lane i is active.

Panics

Panics in debug mode if i >= N.

pub fn and(self, other: BitMask<N>) -> BitMask<N>

Bitwise AND of two masks.

pub fn or(self, other: BitMask<N>) -> BitMask<N>

Bitwise OR of two masks.

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

where [bool; N]: Sized,

Expand this mask to a [bool; N] array.

Useful for scalar fallbacks and debugging. Not performance-critical.

impl<const N: usize> BitMask<N>

pub unsafe fn to_native_mask<T, Arch>(self) -> <Arch as SimdKernel<T>>::Mask

where T: NumericElement, Arch: SimdKernel<T>,

Convert this BitMask<N> to the native hardware mask type for Arch.

Delegates to SimdKernel::mask_from_bitmask using the inner u64 value. Zero runtime cost: the compiler inlines this into a single instruction on AVX-512 (KMOV), a vector comparison + blend mask on AVX2, or a bool-array copy on scalar backends.

Safety

Processor must support the target feature of Arch.

Example

use hermes_simd_core::mask::BitMask;
use hermes_simd_core::kernel::SimdKernel;
use hermes_simd_intrinsics::Scalar;

let bm = BitMask::<4>::leading_k(3);
// SAFETY: `Scalar` has no target-feature precondition.
let native: <Scalar as SimdKernel<f32>>::Mask =
    unsafe { bm.to_native_mask::<f32, Scalar>() };

assert_eq!(native, [true, true, true, false]);

impl<const N: usize> BitMask<N>

pub fn active_lanes(self) -> BitMaskIter<N>

Convenience method to iterate active lane indices without consuming.

Equivalent to (*self).into_iter() since BitMask<N>: Copy.

Trait Implementations

impl<const N: usize> Archive for BitMask<N>

where u64: Archive,

type Archived = ArchivedBitMask<N>

The archived representation of this type.

type Resolver = BitMaskResolver<N>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <BitMask<N> as Archive>::Resolver, out: Place<<BitMask<N> as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<const N: usize> BitAnd for BitMask<N>

type Output = BitMask<N>

The resulting type after applying the & operator.

fn bitand(self, rhs: BitMask<N>) -> BitMask<N>

Performs the & operation.

impl<const N: usize> BitOr for BitMask<N>

type Output = BitMask<N>

The resulting type after applying the | operator.

fn bitor(self, rhs: BitMask<N>) -> BitMask<N>

Performs the | operation.

impl<const N: usize> Clone for BitMask<N>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Copy for BitMask<N>

impl<const N: usize> Debug for BitMask<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for BitMask<N>

fn default() -> BitMask<N>

Returns the “default value” for a type.

impl<__D, const N: usize> Deserialize<BitMask<N>, __D> for <BitMask<N> as Archive>::Archived

where __D: Fallible + ?Sized, u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<BitMask<N>, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<const N: usize> Eq for BitMask<N>

impl<const N: usize> Hash for BitMask<N>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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> IntoIterator for BitMask<N>

fn into_iter(self) -> BitMaskIter<N>

Iterate over active lane indices in ascending order.

Example

use hermes_simd_core::mask::BitMask;

let mask = BitMask::<8>::from_bools(&[true, false, true, false, true, false, false, false]);
let indices: Vec<usize> = mask.into_iter().collect();

assert_eq!(indices, vec![0, 2, 4]);

type Item = usize

The type of the elements being iterated over.

type IntoIter = BitMaskIter<N>

Which kind of iterator are we turning this into?

impl<const N: usize> Not for BitMask<N>

type Output = BitMask<N>

The resulting type after applying the ! operator.

fn not(self) -> BitMask<N>

Performs the unary ! operation.

impl<const N: usize> PartialEq for BitMask<N>

fn eq(&self, other: &BitMask<N>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<__S, const N: usize> Serialize<__S> for BitMask<N>

where __S: Fallible + ?Sized, u64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<BitMask<N> as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<const N: usize> StructuralPartialEq for BitMask<N>