Struct bitvec_simd::BitVecSimd

source · [−]

#[repr(C)]
pub struct BitVecSimd<A, const L: usize> where
    A: Array + Index<usize>,
    <A as Array>::Item: Not<Output = <A as Array>::Item> + BitAnd<Output = <A as Array>::Item> + BitOr<Output = <A as Array>::Item> + BitXor<Output = <A as Array>::Item> + Shl<u32> + Shr<u32> + Add<Output = <A as Array>::Item> + Sub<Output = <A as Array>::Item> + Eq + Sized + Copy + Clone + Debug + From<<<A as Array>::Item as BitContainer<L>>::Element> + From<[<<A as Array>::Item as BitContainer<L>>::Element; L]> + BitContainer<L>,
    <<A as Array>::Item as BitContainer<L>>::Element: Not<Output = <<A as Array>::Item as BitContainer<L>>::Element> + BitAnd<Output = <<A as Array>::Item as BitContainer<L>>::Element> + BitOr<Output = <<A as Array>::Item as BitContainer<L>>::Element> + BitOrAssign + BitXor<Output = <<A as Array>::Item as BitContainer<L>>::Element> + Shl<u32, Output = <<A as Array>::Item as BitContainer<L>>::Element> + Shr<u32, Output = <<A as Array>::Item as BitContainer<L>>::Element> + BitAndAssign + Add<Output = <<A as Array>::Item as BitContainer<L>>::Element> + Sub<Output = <<A as Array>::Item as BitContainer<L>>::Element> + PartialEq + Sized + Copy + Clone + Binary + BitContainerElement,  { /* private fields */ }

Expand description

Representation of a BitVec

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>>());

source

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]);

source

pub fn from_slice_copy(
slice: &[<<A as Array>::Item as BitContainer<L>>::Element ],
nbits: usize
) -> Self

Initialize from a E slice. Data will be copied from the slice.

Example:

use bitvec_simd::BitVec;

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

source

pub unsafe fn from_raw_copy(
 ptr: *const <<A as Array>::Item as BitContainer<L>>::Element,
 buffer_len: usize,
 nbits: usize
) -> Self

Initialize from a raw buffer. Data will be copied from the buffer which [ptr] points to. The buffer can be released after initialization.

Safety

If any of the following conditions are violated, the result is Undefined Behavior:

ptr should be valid and point to an [allocated object] with length >= buffer_len
ptr.offset(buffer_len - 1), in bytes, cannot overflow an isize.
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum, in bytes must fit in a usize.

source

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);

source

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

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

Example:

use bitvec_simd::BitVec;

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

source

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);

source

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));

source

pub fn set_all_false(&mut self)

Set all items in bitvec to false

source

pub fn set_all_true(&mut self)

Set all items in bitvec to true

source

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

Set all items in bitvec to flag

source

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);

source

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);

source

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);

source

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

source

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

source

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);

source

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);

source

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 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]);

The resulting type after applying the | operator.

The resulting type after applying the ^ operator.

source

fn eq(&self, other: &BitVecSimd<A, L>) -> bool

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

1.0.0 · source

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

This method tests for !=.

Auto Trait Implementations

impl<A, const L: usize> RefUnwindSafe for BitVecSimd<A, L> where
A: RefUnwindSafe,
<A as Array>::Item: RefUnwindSafe,

impl<A, const L: usize> Send for BitVecSimd<A, L> where
<A as Array>::Item: Send,

impl<A, const L: usize> Sync for BitVecSimd<A, L> where
A: Sync,

impl<A, const L: usize> Unpin for BitVecSimd<A, L> where
A: Unpin,

pub fn into(self) -> U

Performs the conversion.

source

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

pub fn clone_into(&self, target: &mut T)

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

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T> ToString for T where
T: Display + ?Sized,

source

pub default fn to_string(&self) -> String

Converts the given value to a String. Read more

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct bitvec_simd::BitVecSimd

Implementations

pub fn zeros(nbits: usize) -> Self

pub fn ones(nbits: usize) -> Self

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

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

pub fn from_slice_copy( slice: &[<<A as Array>::Item as BitContainer<L>>::Element], nbits: usize) -> Self

pub unsafe fn from_raw_copy( ptr: *const <<A as Array>::Item as BitContainer<L>>::Element, buffer_len: usize, nbits: usize) -> Self

Safety

pub fn len(&self) -> usize

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

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

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

pub fn set_all_false(&mut self)

pub fn set_all_true(&mut self)

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

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

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

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

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

pub fn and_inplace(&mut self, other: &Self)

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

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

pub fn or_inplace(&mut self, other: &Self)

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

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

pub fn xor_inplace(&mut self, other: &Self)

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

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

pub fn inverse(&self) -> Self

pub fn count_ones(&self) -> usize

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

pub fn leading_zeros(&self) -> usize

pub fn any(&self) -> bool

pub fn all(&self) -> bool

pub fn none(&self) -> bool

pub fn is_empty(&self) -> bool

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

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

Trait Implementations

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

fn bitand(self, rhs: &BitVecSimd<A, L>) -> Self::Output

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

fn bitand(self, rhs: &mut BitVecSimd<A, L>) -> Self::Output

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

fn bitand(self, rhs: BitVecSimd<A, L>) -> Self::Output

type Output = BitVecSimd<A, L>

fn bitand(self, rhs: BitVecSimd<A, L>) -> Self::Output

fn bitand_assign(&mut self, rhs: &BitVecSimd<A, L>)

fn bitand_assign(&mut self, rhs: &mut BitVecSimd<A, L>)

fn bitand_assign(&mut self, rhs: Self)

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

fn bitor(self, rhs: &BitVecSimd<A, L>) -> Self::Output

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

fn bitor(self, rhs: &mut BitVecSimd<A, L>) -> Self::Output

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

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

type Output = BitVecSimd<A, L>

fn bitor(self, rhs: BitVecSimd<A, L>) -> Self::Output

type Output = BitVecSimd<A, L>

fn bitor(self, rhs: BitVecSimd<A, L>) -> Self::Output

fn bitor_assign(&mut self, rhs: &BitVecSimd<A, L>)

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

pub fn from_slice_copy(
slice: &[<<A as Array>::Item as BitContainer<L>>::Element ],
nbits: usize
) -> Self

pub unsafe fn from_raw_copy(
ptr: *const <<A as Array>::Item as BitContainer<L>>::Element,
buffer_len: usize,
nbits: usize
) -> Self