Struct compacts_bits::Vec32

pub struct Vec32 { /* fields omitted */ }

Map of Vec16(internal).

Methods

impl Vec32

fn count_ones(&self) -> u64

fn count_zeros(&self) -> u64

fn mem_size(&self) -> u64

fn optimize(&mut self)

Optimize innternal data representaions.

impl Vec32

fn new() -> Self

fn clear(&mut self)

Clear contents.

Examples

use compacts_bits::Vec32;

let mut bits = Vec32::new();
bits.insert(0);
assert!(bits.count_ones() == 1);
bits.clear();
assert!(bits.count_ones() == 0);

fn contains(&self, x: u32) -> bool

Return true if the value exists.

Examples

use compacts_bits::Vec32;

let mut bits = Vec32::new();
assert_eq!(bits.count_zeros(), 1 << 32);
bits.insert(1);
assert!(!bits.contains(0));
assert!(bits.contains(1));
assert!(!bits.contains(2));
assert_eq!(bits.count_ones(), 1);

fn insert(&mut self, x: u32) -> bool

Return true if the value doesn't exists and inserted successfuly.

Examples

use compacts_bits::Vec32;
let mut bits = Vec32::new();
assert!(bits.insert(3));
assert!(!bits.insert(3));
assert!(bits.contains(3));
assert_eq!(bits.count_ones(), 1);

fn remove(&mut self, x: u32) -> bool

Return true if the value exists and removed successfuly.

Examples

use compacts_bits::Vec32;
let mut bits = Vec32::new();
assert!(bits.insert(3));
assert!(bits.remove(3));
assert!(!bits.contains(3));
assert_eq!(bits.count_ones(), 0);

fn iter<'r>(&'r self) -> impl Iterator<Item = u32> + 'r

impl Vec32

fn stats<'a>(&'a self) -> impl Iterator<Item = Stats> + 'a

Trait Implementations

impl Intersection<Vec32> for Vec32

type Output = Vec32

fn intersection(self, that: Vec32) -> Self::Output

impl<'r> Intersection<&'r Vec32> for Vec32

type Output = Vec32

fn intersection(self, that: &Vec32) -> Self::Output

impl<'r1, 'r2> Intersection<&'r2 Vec32> for &'r1 Vec32

type Output = Vec32

fn intersection(self, that: &Vec32) -> Self::Output

impl Union<Vec32> for Vec32

type Output = Vec32

fn union(self, that: Vec32) -> Self::Output

impl<'r> Union<&'r Vec32> for Vec32

type Output = Vec32

fn union(self, that: &Vec32) -> Self::Output

impl<'r1, 'r2> Union<&'r2 Vec32> for &'r1 Vec32

type Output = Vec32

fn union(self, that: &Vec32) -> Self::Output

impl Difference<Vec32> for Vec32

type Output = Vec32

fn difference(self, that: Vec32) -> Self::Output

impl<'r> Difference<&'r Vec32> for Vec32

type Output = Vec32

fn difference(self, that: &Vec32) -> Self::Output

impl<'r1, 'r2> Difference<&'r2 Vec32> for &'r1 Vec32

type Output = Vec32

fn difference(self, that: &Vec32) -> Self::Output

impl SymmetricDifference<Vec32> for Vec32

type Output = Vec32

fn symmetric_difference(self, that: Vec32) -> Self::Output

impl<'r> SymmetricDifference<&'r Vec32> for Vec32

type Output = Vec32

fn symmetric_difference(self, that: &Vec32) -> Self::Output

impl<'r1, 'r2> SymmetricDifference<&'r2 Vec32> for &'r1 Vec32

type Output = Vec32

fn symmetric_difference(self, that: &Vec32) -> Self::Output

impl<'r> IntersectionWith<&'r Vec32> for Vec32

fn intersection_with(&mut self, that: &'r Vec32)

impl<'r> UnionWith<&'r Vec32> for Vec32

fn union_with(&mut self, that: &'r Vec32)

impl<'r> DifferenceWith<&'r Vec32> for Vec32

fn difference_with(&mut self, that: &'r Vec32)

impl<'r> SymmetricDifferenceWith<&'r Vec32> for Vec32

fn symmetric_difference_with(&mut self, that: &'r Vec32)

impl Default for Vec32

fn default() -> Vec32

Returns the "default value" for a type.

impl Debug for Vec32

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

Formats the value using the given formatter.

impl Clone for Vec32

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Index<u32> for Vec32

type Output = bool

The returned type after indexing

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

The method for the indexing (container[index]) operation

impl Rank<u32> for Vec32

type Weight = u64

Hamming Weight or Population Count.

const SIZE: Self::Weight

SIZE: Self::Weight = 1 << 32

fn rank1(&self, i: u32) -> Self::Weight

Returns occurences of non-zero bit in 0...i. It's equivalent to i+1 - self.rank0(i).

fn rank0(&self, i: u32) -> Self::Weight

Returns occurences of zero bit in 0...i. It's equivalent to i+1 - self.rank1(i).

impl Select1<u32> for Vec32

fn select1(&self, c: u32) -> Option<u32>

Returns the position of 'c+1'th appearance of non-zero bit.

impl Select0<u32> for Vec32

fn select0(&self, c: u32) -> Option<u32>

Returns the position of 'c+1'th appearance of non-zero bit.