Struct bitvec_simd::BitVecSimd

pub struct BitVecSimd<T: BitContainer<E, L>, E: BitContainerElement, const L: usize> { /* fields omitted */ }

Representation of a BitVec

see the module’s document for examples and details.

Implementations

impl<T, E, const L: usize> BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

pub fn zeros(nbits: usize) -> Self

Create an empty bitvec with nbits initial elements. Example:

use bitvec_simd::BitVec;

let bitvec = BitVec::zeros(10);
assert_eq!(bitvec.len(), 10);

pub fn ones(nbits: usize) -> Self

Create a bitvec containing all 0 .. nbits elements. Example:

use bitvec_simd::BitVec;

let bitvec = BitVec::ones(10);
assert_eq!(bitvec.len(), 10);

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

Create a bitvec from an Iterator of bool.

Example:

use bitvec_simd::BitVec;

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

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

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

Initialize from a set of integers.

Example:

use bitvec_simd::BitVec;

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

pub fn from_slice_raw(slice: &[E]) -> Self

Initialize from a raw E slice.

Example:

use bitvec_simd::BitVec;

let bitvec = BitVec::from_slice_raw(&[3]);
assert_eq!(bitvec.get(0), Some(true));
assert_eq!(bitvec.get(1), Some(true));

pub fn len(&self) -> usize

Length of this bitvec.

To get the number of elements, use count_ones

Example:

use bitvec_simd::BitVec;

let bitvec = BitVec::ones(3);
assert_eq!(bitvec.len(), 3);

pub fn resize(&mut self, nbits: usize)

Resize this bitvec to new length in-place. If new length is greater than current length, 0 will be filled.

Example:

use bitvec_simd::BitVec;

let mut bitvec = BitVec::ones(3);
bitvec.resize(5);
assert_eq!(bitvec.len(), 5);
bitvec.resize(2);
assert_eq!(bitvec.len(), 2);

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

Shink this bitvec to new length in-place. Panics if new length is greater than original.

Example:

use bitvec_simd::BitVec;

let mut bitvec = BitVec::ones(3);
bitvec.shrink_to(2);
assert_eq!(bitvec.len(), 2);

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

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

use bitvec_simd::BitVec;

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

pub fn set_all_false(&mut self)

Set all items in bitvec to false

pub fn set_all_true(&mut self)

Set all items in bitvec to true

pub fn set_all(&mut self, flag: bool)

Set all items in bitvec to flag

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

Check if index exists in current set.

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

Examlpe:

use bitvec_simd::BitVec;

let bitvec : BitVec = (0 .. 15).map(|x| x%3 == 0).into();
assert_eq!(bitvec.get(3), Some(true));
assert_eq!(bitvec.get(5), Some(false));
assert_eq!(bitvec.get(14), Some(false));
assert_eq!(bitvec.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.len, panic.

Examlpe:

use bitvec_simd::BitVec;

let bitvec : BitVec = (0 .. 15).map(|x| x%3 == 0).into();
assert_eq!(bitvec.get_unchecked(3), true);
assert_eq!(bitvec.get_unchecked(5), false);
assert_eq!(bitvec.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 bitvec_simd::BitVec;

let bitvec: BitVec = (0 .. 5_000).map(|x| x % 2 == 0).into();
let bitvec2 : BitVec = (0 .. 5_000).map(|x| x % 3 == 0).into();
assert_eq!(bitvec.difference_cloned(&bitvec2) | bitvec2.difference_cloned(&bitvec), bitvec.xor_cloned(&bitvec2));
let bitvec3 : BitVec = (0 .. 5_000).map(|x| x % 2 == 0 && x % 3 != 0).into();
assert_eq!(bitvec.difference(bitvec2), bitvec3);

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

pub fn inverse(self) -> Self

inverse every bits in the vector.

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

pub fn count_ones(&self) -> usize

Count the number of elements existing in this bitvec.

Example:

use bitvec_simd::BitVec;

let bitvec: BitVec = (0..10_000).map(|x| x%2==0).into();
assert_eq!(bitvec.count_ones(), 5000);

let bitvec: BitVec = (0..30_000).map(|x| x%3==0).into();
assert_eq!(bitvec.count_ones(), 10_000);

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

Count the number of elements existing in this bitvec, before the specified index. Panics if index is invalid.

Example:

use bitvec_simd::BitVec;

let bitvec: BitVec = (0..10_000).map(|x| x%2==0).into();
assert_eq!(bitvec.count_ones_before(5000), 2500);

let bitvec: BitVec = (0..30_000).map(|x| x%3==0).into();
assert_eq!(bitvec.count_ones_before(10000), 3334);

pub fn leading_zeros(&self) -> usize

Count the number of leading zeros in this bitvec.

Example:

use bitvec_simd::BitVec;

let mut bitvec = BitVec::zeros(10);
bitvec.set(3, true);
assert_eq!(bitvec.leading_zeros(), 6);

pub fn any(&self) -> bool

return true if contains at least 1 element

pub fn all(&self) -> bool

return true if contains self.len 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.len().

Example:

use bitvec_simd::BitVec;

let bitvec = BitVec::from_bool_iterator((0..10).map(|i| i % 3 == 0));
let bool_vec = bitvec.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 bitvec_simd::BitVec;

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

Trait Implementations

impl<T, E, const L: usize> BitAnd<BitVecSimd<T, E, L>> for BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

type Output = Self

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, E, const L: usize> BitOr<BitVecSimd<T, E, L>> for BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

type Output = Self

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, E, const L: usize> BitXor<BitVecSimd<T, E, L>> for BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

type Output = Self

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T: Clone + BitContainer<E, L>, E: Clone + BitContainerElement, const L: usize> Clone for BitVecSimd<T, E, L>

fn clone(&self) -> BitVecSimd<T, E, L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + BitContainer<E, L>, E: Debug + BitContainerElement, const L: usize> Debug for BitVecSimd<T, E, L>

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

Formats the value using the given formatter.

impl<T, E, const L: usize> Display for BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

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

Formats the value using the given formatter.

impl<T, E, const L: usize> From<BitVecSimd<T, E, L>> for Vec<bool> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

fn from(v: BitVecSimd<T, E, L>) -> Self

Performs the conversion.

impl<T, E, const L: usize> From<BitVecSimd<T, E, L>> for Vec<usize> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

fn from(v: BitVecSimd<T, E, L>) -> Self

Performs the conversion.

impl<T, E, I: Iterator<Item = bool>, const L: usize> From<I> for BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

fn from(i: I) -> Self

Performs the conversion.

impl<T, E, const L: usize> Index<usize> for BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

type Output = bool

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, E, const L: usize> Not for BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, E, const L: usize> PartialEq<BitVecSimd<T, E, L>> for BitVecSimd<T, E, L> where
    T: Not<Output = T> + BitAnd<Output = T> + BitOr<Output = T> + BitXor<Output = T> + Shl<u32> + Shr<u32> + Add<Output = T> + Sub<Output = T> + Eq + Sized + Copy + Clone + From<E> + From<[E; L]> + BitContainer<E, L>,
    E: Not<Output = E> + BitAnd<Output = E> + BitOr<Output = E> + BitOrAssign + BitXor<Output = E> + Shl<u32, Output = E> + Shr<u32, Output = E> + BitAndAssign + Add<Output = E> + Sub<Output = E> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement, 

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 !=.