Struct croaring::bitset::Bitset

#[repr(transparent)]
pub struct Bitset { /* private fields */ }

A dense bitset

Implementations

impl Bitset

pub const fn as_slice(&self) -> &[u64]

Access the raw underlying slice

pub fn as_mut_slice(&mut self) -> &mut [u64]

Access the raw underlying slice

pub const fn new() -> Self

Create a new bitset

Does not allocate

Examples

use croaring::Bitset;
let bitset = Bitset::new();
assert_eq!(bitset.capacity(), 0);
assert_eq!(bitset.size_in_bits(), 0);

pub fn with_size(size: usize) -> Self

Create a new bitset of the specified size

Examples

use croaring::Bitset;
let bitset = Bitset::with_size(100);
// Actual size/capacity may be rounded up
assert!(bitset.capacity() >= 100);
assert!(bitset.size_in_bits() >= 100);

pub const fn capacity(&self) -> usize

Capacity in bits

pub fn fill(&mut self, value: bool)

Set all bits to zero

Examples

use croaring::Bitset;
let mut bitset = Bitset::with_size(64);
bitset.fill(true);
assert!(bitset.get(1));
assert!(bitset.get(63));
// Bitset size stays the same
assert!(!bitset.get(64));
bitset.fill(false);
assert!(!bitset.get(1));
assert!(!bitset.get(63));
assert!(!bitset.get(64));

pub const fn size_in_bytes(&self) -> usize

How many bytes of memory the backend buffer uses

pub const fn size_in_bits(&self) -> usize

How many bits can be accessed

pub const fn size_in_words(&self) -> usize

How many 64-bit words of memory the backend buffer uses

pub fn resize_words(&mut self, new_array_size: usize, value: bool)

Resize the bitset to contain new_array_size 64-bit words

New bits are set to value

Examples

use croaring::Bitset;
let mut bitset = Bitset::new();
bitset.resize_words(1, false);
bitset.resize_words(2, true);
assert_eq!(bitset.iter().collect::<Vec<_>>(), (64..128).collect::<Vec<_>>());

pub fn shrink_to_fit(&mut self)

Attempts to recover unused memory by shrinking capacity to fit the highest set bit

Examples

use croaring::Bitset;
let mut bitset = Bitset::new();
bitset.set(63);
bitset.set(1000);
assert!(bitset.size_in_bits() > 1000);
bitset.set_to_value(1000, false);
bitset.shrink_to_fit();
// The next highest bit is at index 63
assert_eq!(bitset.size_in_bits(), 64);

pub fn set(&mut self, i: usize)

Set the ith bit

Will resize the bitset if needed, any other newly added bits will be initialized to zero

Examples

use croaring::Bitset;
let mut bitset = Bitset::new();
bitset.set(1);
bitset.set(2);
bitset.set(100);
assert_eq!(bitset.iter().collect::<Vec<_>>(), vec![1, 2, 100]);

pub fn set_to_value(&mut self, i: usize, value: bool)

Set the ith bit to value

Will resize the bitset if needed, any other newly added bits will be initialized to zero

Examples

use croaring::Bitset;
let mut bitset = Bitset::new();
bitset.set_to_value(1, true);
bitset.set_to_value(2, true);
bitset.set_to_value(100, true);
bitset.set_to_value(1, false);
assert_eq!(bitset.iter().collect::<Vec<_>>(), vec![2, 100]);

pub const fn get(&self, i: usize) -> bool

Get the value of the ith bit

If the bit is out of bounds, returns false

Examples

use croaring::Bitset;
let mut bitset = Bitset::new();
bitset.set(1);
bitset.set(2);
assert!(bitset.get(1));
assert!(bitset.get(2));
assert!(!bitset.get(3));

pub fn count(&self) -> usize

Count of number of set bits

Examples

use croaring::Bitset;
let mut bitset: Bitset = [1, 2, 3, 100].into_iter().collect();
assert_eq!(bitset.count(), 4);

pub fn minimum(&self) -> usize

Index of the first set bit, or zero if the bitset has no set bits

Examples

use croaring::Bitset;
let mut bitset = Bitset::new();
// minimum returns 0 if the bitset is empty
assert_eq!(bitset.minimum(), 0);
bitset.set(100);
assert_eq!(bitset.minimum(), 100);

pub fn maximum(&self) -> usize

Index of the last set bit, or zero if the bitset has no set bits

Examples

use croaring::Bitset;
let mut bitset = Bitset::new();
// maximum returns 0 if the bitset is empty
assert_eq!(bitset.maximum(), 0);
bitset.set(100);
assert_eq!(bitset.maximum(), 100);
bitset.set(1000);
assert_eq!(bitset.maximum(), 1000);

pub fn union_count(&self, other: &Self) -> usize

The size of the hypothetical union of self and other

Examples

use croaring::Bitset;
let mut bitset1: Bitset = [1, 2, 3, 100].into_iter().collect();
let bitset2: Bitset = [2, 3, 4, 5].into_iter().collect();
assert_eq!(bitset1.union_count(&bitset2), 6);
bitset1 |= &bitset2;
assert_eq!(bitset1.count(), 6);

pub fn intersection_count(&self, other: &Self) -> usize

The size of the hypothetical intersection of self and other

Examples

use croaring::Bitset;
let mut bitset1: Bitset = [1, 2, 3, 100].into_iter().collect();
let bitset2: Bitset = [2, 3, 4, 5].into_iter().collect();
assert_eq!(bitset1.intersection_count(&bitset2), 2);
bitset1 &= &bitset2;
assert_eq!(bitset1.count(), 2);

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

Return true if self and other contain no common elements

Examples

use croaring::Bitset;
let bitset1: Bitset = [1, 2, 3, 100].into_iter().collect();
let bitset2: Bitset = [2, 3, 4, 5].into_iter().collect();
assert!(!bitset1.is_disjoint(&bitset2));
let bitset3: Bitset = [4, 5, 6, 7].into_iter().collect();
assert!(bitset1.is_disjoint(&bitset3));

Empty bitsets are always disjoint

use croaring::Bitset;
let bitset1 = Bitset::new();
let bitset2 = Bitset::new();
assert!(bitset1.is_disjoint(&bitset2));

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

Return true if self and other contain at least one common element

Examples

use croaring::Bitset;
let bitset1: Bitset = [1, 2, 3, 100].into_iter().collect();
let bitset2: Bitset = [2, 3, 4, 5].into_iter().collect();
assert!(bitset1.has_intersect(&bitset2));
let bitset3: Bitset = [4, 5, 6, 7].into_iter().collect();
assert!(!bitset1.has_intersect(&bitset3));

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

Return true if self is a superset of other

Examples

use croaring::Bitset;
let bitset1: Bitset = [1, 2, 3, 100].into_iter().collect();
let bitset2: Bitset = [2, 3].into_iter().collect();
assert!(bitset1.is_superset(&bitset2));
let bitset3: Bitset = [4, 5, 6, 7].into_iter().collect();
assert!(!bitset1.is_superset(&bitset3));

pub fn difference_count(&self, other: &Self) -> usize

The size of the hypothetical difference of self and other

Examples

use croaring::Bitset;
let mut bitset1: Bitset = [1, 2, 3, 100].into_iter().collect();
let bitset2: Bitset = [2, 3, 4, 5].into_iter().collect();
assert_eq!(bitset1.difference_count(&bitset2), 2);
bitset1 -= &bitset2;
assert_eq!(bitset1.count(), 2);

pub fn symmetric_difference_count(&self, other: &Self) -> usize

The size of the hypothetical symmetric difference (xor) of self and other

Examples

use croaring::Bitset;
let mut bitset1: Bitset = [1, 2, 3, 100].into_iter().collect();
let bitset2: Bitset = [2, 3, 4, 5].into_iter().collect();
assert_eq!(bitset1.symmetric_difference_count(&bitset2), 4);
bitset1 ^= &bitset2;
assert_eq!(bitset1.count(), 4);

pub fn as_raw(&self) -> &bitset_t

Expose the raw CRoaring bitset

This allows calling raw CRoaring functions on the bitset.

pub fn as_raw_mut(&mut self) -> &mut bitset_t

Expose the raw CRoaring bitset mutably

This allows calling raw CRoaring functions on the bitset.

impl Bitset

pub const fn iter(&self) -> BitsetIterator<'_>

Returns an iterator over the set bits in the bitset

Trait Implementations

impl BitAndAssign<&Bitset> for Bitset

fn bitand_assign(&mut self, rhs: &Bitset)

Performs the &= operation.

impl BitOrAssign<&Bitset> for Bitset

fn bitor_assign(&mut self, rhs: &Bitset)

Performs the |= operation.

impl BitXorAssign<&Bitset> for Bitset

fn bitxor_assign(&mut self, rhs: &Bitset)

Performs the ^= operation.

impl Clone for Bitset

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Bitset

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

Formats the value using the given formatter.

impl Default for Bitset

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Bitset

fn drop(&mut self)

Executes the destructor for this type.

impl Extend<usize> for Bitset

fn extend<T: IntoIterator<Item = usize>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<usize> for Bitset

fn from_iter<T: IntoIterator<Item = usize>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> IntoIterator for &'a Bitset

type Item = usize

The type of the elements being iterated over.

type IntoIter = BitsetIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl ShlAssign<usize> for Bitset

fn shl_assign(&mut self, shift: usize)

Performs the <<= operation.

impl ShrAssign<usize> for Bitset

fn shr_assign(&mut self, shift: usize)

Performs the >>= operation.

impl SubAssign<&Bitset> for Bitset

fn sub_assign(&mut self, rhs: &Bitset)

Performs the -= operation.

impl Send for Bitset

impl Sync for Bitset