Struct bitvector_simd::BitVector

pub struct BitVector { /* fields omitted */ }

Representation of a BitVector

see the module’s document for examples and details.

Implementations

impl BitVector

pub fn zeros(nbits: usize) -> Self

Create a empty bitvector with nbits initial elements. Example:

use bitvector_simd::BitVector;

let bitvector = BitVector::zeros(10);
assert_eq!(bitvector.capacity(), 10);

pub fn ones(nbits: usize) -> Self

Create a bitvector containing all 0 .. nbits elements.

pub fn from_bool_iterator<I: Iterator<Item = bool>>(i: I) -> Self

Create a bitvector from an Iterator of bool.

Example:

use bitvector_simd::BitVector;

let bitvector = BitVector::from_bool_iterator((0..10).map(|x| x % 2 == 0));
assert_eq!(bitvector.capacity(), 10);
assert_eq!(<BitVector as Into<Vec<bool>>>::into(bitvector), vec![true, false, true, false, true, false, true, false, true, false]);

let bitvector = BitVector::from_bool_iterator((0..1000).map(|x| x < 50));
assert_eq!(bitvector.capacity(), 1000);
assert_eq!(bitvector.get(49), Some(true));
assert_eq!(bitvector.get(50), Some(false));
assert_eq!(bitvector.get(999), Some(false));
assert_eq!(<BitVector as Into<Vec<bool>>>::into(bitvector), (0..1000).map(|x| x<50).collect::<Vec<bool>>());

pub fn from_slice(slice: &[usize]) -> Self

Initialize from a set of integers.

Example:

use bitvector_simd::BitVector;

let bitvector = BitVector::from_slice(&[0,5,9]);
assert_eq!(<BitVector as Into<Vec<bool>>>::into(bitvector), vec![true, false, false, false, false, true, false, false, false, true]);

pub fn capacity(&self) -> usize

Max number of elements that this bitvector can have.

To get the number of elements, use count

pub fn shrink_to(&mut self, length: usize)

Shrink the vector to length. All elements between [length .. self.capacity()] will be removed. Panic if given length larger than current length. Example:

use bitvector_simd::BitVector;

let mut bitvector = BitVector::ones(100);
assert_eq!(bitvector.capacity(), 100);
bitvector.shrink_to(10);
assert_eq!(bitvector.capacity(), 10);
// Now only contains [0 ..= 9]
assert_eq!(bitvector.get(9), Some(true));
assert_eq!(bitvector.get(10), None);

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

Remove or add index to the set. If index > self.capacity, the bitvector will be expanded to index. Example:

use bitvector_simd::BitVector;

let mut bitvector = BitVector::zeros(10);
assert_eq!(bitvector.capacity(), 10);
bitvector.set(15, true);  
// now 15 has been added to the set, its total capacity is 16.
assert_eq!(bitvector.capacity(), 16);
assert_eq!(bitvector.get(15), Some(true));
assert_eq!(bitvector.get(14), Some(false));

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

Check if index exists in current set.

• If exists, return Some(true)
• If index < current.capacity and element doesn’t exist, return Some(false).
• If index >= current.capacity, return None.

Examlpe:

use bitvector_simd::BitVector;

let bitvector : BitVector = (0 .. 15).map(|x| x%3 == 0).into();
assert_eq!(bitvector.get(3), Some(true));
assert_eq!(bitvector.get(5), Some(false));
assert_eq!(bitvector.get(14), Some(false));
assert_eq!(bitvector.get(15), None);

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

Directly return a bool instead of an Option

• If exists, return true.
• If doesn’t exist, return false.
• If index >= current.capacity, panic.

Examlpe:

use bitvector_simd::BitVector;

let bitvector : BitVector = (0 .. 15).map(|x| x%3 == 0).into();
assert_eq!(bitvector.get_unchecked(3), true);
assert_eq!(bitvector.get_unchecked(5), false);
assert_eq!(bitvector.get_unchecked(14), false);

pub fn and(self, other: Self) -> Self

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

pub fn or(self, other: Self) -> Self

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

pub fn xor(self, other: Self) -> Self

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

pub fn difference(self, other: Self) -> Self

difference operation

A.difference(B) calculates A\B, e.g.

A = [1,2,3], B = [2,4,5]
A\B = [1,3]

also notice that

A.difference(B) | B.difference(A) == A ^ B

Example:

use bitvector_simd::BitVector;
 
let bitvector: BitVector = (0 .. 5_000).map(|x| x % 2 == 0).into();
let bitvector2 : BitVector = (0 .. 5_000).map(|x| x % 3 == 0).into();
assert_eq!(bitvector.difference_cloned(&bitvector2) | bitvector2.difference_cloned(&bitvector), bitvector.xor_cloned(&bitvector2));
let bitvector3 : BitVector = (0 .. 5_000).map(|x| x % 2 == 0 && x % 3 != 0).into();
assert_eq!(bitvector.difference(bitvector2), bitvector3);

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

pub fn inverse(self) -> Self

inverse every bits in the vector.

If your bitvector have capacity 1_000 and contains [1,5], after inverse it will contains 0, 2..=4, 6..=999

pub fn count(&self) -> usize

Count the number of elements existing in this bitvector.

Example:

use bitvector_simd::BitVector;
 
let bitvector: BitVector = (0..10_000).map(|x| x%2==0).into();
assert_eq!(bitvector.count(), 5000);

let bitvector: BitVector = (0..30_000).map(|x| x%3==0).into();
assert_eq!(bitvector.count(), 10_000);

pub fn any(&self) -> bool

return true if contains at least 1 element

pub fn all(&self) -> bool

return true if contains self.capacity elements

pub fn none(&self) -> bool

return true if set is empty

pub fn is_empty(&self) -> bool

Return true if set is empty. Totally the same with self.none()

pub fn into_bools(self) -> Vec<bool>

Consume self and generate a Vec<bool> with length == self.capacity().

Example:

use bitvector_simd::BitVector;

let bitvector = BitVector::from_bool_iterator((0..10).map(|i| i % 3 == 0));
let bool_vec = bitvector.into_bools();
assert_eq!(bool_vec, vec![true, false, false, true, false, false, true, false, false, true])

pub fn into_usizes(self) -> Vec<usize>

Consume self and geterate a Vec<usize> which only contains the number exists in this set.

Example:

use bitvector_simd::BitVector;

let bitvector = BitVector::from_bool_iterator((0..10).map(|i| i%3 == 0));
let usize_vec = bitvector.into_usizes();
assert_eq!(usize_vec, vec![0,3,6,9]);

pub fn eq_left(&self, other: &Self, bits: usize) -> bool

Only compare the first bits instead of the whole bitvector.

Require self and other are both no shorter than bits.

Example:

use bitvector_simd::BitVector;
 
let bitvector = BitVector::from_slice(&[1,3,5,7]);
let bitvector2 = BitVector::from_slice(&[1,3,5,9,10,15]);
// compare first 6 bits (0..=5)
assert!(bitvector.eq_left(&bitvector2, 6));
// compare first 8 bits (0..=7)
assert!(!bitvector.eq_left(&bitvector2, 8));
// any bits > 8 call panic.

Trait Implementations

impl BitAnd<BitVector> for BitVector

type Output = Self

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitOr<BitVector> for BitVector

type Output = Self

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitXor<BitVector> for BitVector

type Output = Self

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl Clone for BitVector

fn clone(&self) -> BitVector

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BitVector

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

Formats the value using the given formatter.

impl Display for BitVector

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

Formats the value using the given formatter.

impl From<BitVector> for Vec<bool>

fn from(v: BitVector) -> Self

Performs the conversion.

impl From<BitVector> for Vec<usize>

fn from(v: BitVector) -> Self

Performs the conversion.

impl<I: Iterator<Item = bool>> From<I> for BitVector

fn from(i: I) -> Self

Performs the conversion.

impl Index<usize> for BitVector

type Output = bool

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Not for BitVector

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq<BitVector> for BitVector

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.