Struct bit_array::BitArray

pub struct BitArray<B: BitsIn, NBits: Unsigned + NonZero> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B> {
    // some fields omitted
}

The bitarray type.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U10;

let mut bv = BitArray::<u32, U10>::from_elem(false);

// insert all primes less than 10
bv.set(2, true);
bv.set(3, true);
bv.set(5, true);
bv.set(7, true);
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

// flip all values in bitarray, producing non-primes less than 10
bv.negate();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

// reset bitarray to empty
bv.clear();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

Methods

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

fn new() -> Self

Creates an empty BitArray.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::new();

fn from_elem(bit: bool) -> Self

Creates a BitArray, setting each element to bit.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U10;

let mut bv = BitArray::<u32, U10>::from_elem(false);
assert_eq!(bv.len(), 10);
for x in bv.iter() {
    assert_eq!(x, false);
}

fn from_bytes(bytes: &[u8]) -> Self

Transforms a byte-array into a BitArray. Each byte becomes eight bits, with the most significant bits of each byte coming first. Each bit becomes true if equal to 1 or false if equal to 0.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let bv = BitArray::<u32, U8>::from_bytes(&[0b10100000, 0b00010010]);
assert!(bv.eq_vec(&[true, false, true, false,
                    false, false, false, false,
                    false, false, false, true,
                    false, false, true, false]));

fn from_fn<F>(f: F) -> Self where F: FnMut(usize) -> bool

Creates a BitArray of the specified length where the value at each index is f(index).

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U5;

let bv = BitArray::<u32, U5>::from_fn(|i| { i % 2 == 0 });
assert!(bv.eq_vec(&[true, false, true, false, true]));

fn blocks(&self) -> Blocks<B>

Iterator over the underlying blocks of data

fn storage(&self) -> &[B]

Exposes the raw block storage of this BitArray

Only really intended for BitSet.

unsafe fn storage_mut(&mut self) -> &mut [B]

Exposes the raw block storage of this BitArray

Can probably cause unsafety. Only really intended for BitSet.

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

Retrieves the value at index i, or None if the index is out of bounds.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let bv = BitArray::<u32, U8>::from_bytes(&[0b01100000]);
assert_eq!(bv.get(0), Some(false));
assert_eq!(bv.get(1), Some(true));
assert_eq!(bv.get(100), None);

// Can also use array indexing
assert_eq!(bv[1], true);

fn set(&mut self, i: usize, x: bool)

Sets the value of a bit at an index i.

Panics

Panics if i is out of bounds.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(false);
bv.set(3, true);
assert_eq!(bv[3], true);

fn set_all(&mut self)

Sets all bits to 1.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let before = 0b01100000;
let after  = 0b11111111;

let mut bv = BitArray::<u32, U8>::from_bytes(&[before]);
bv.set_all();
assert_eq!(bv, BitArray::<u32, U8>::from_bytes(&[after]));

fn negate(&mut self)

Flips all bits.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let before = 0b01100000;
let after  = 0b10011111;

let mut bv = BitArray::<u32, U8>::from_bytes(&[before]);
bv.negate();
assert_eq!(bv, BitArray::<u32, U8>::from_bytes(&[after]));

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

Calculates the union of two bitarrays. This acts like the bitwise or function.

Sets self to the union of self and other. Both bitarrays must be the same length. Returns true if self changed.

Panics

Panics if the bitarrays are of different lengths.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01111110;

let mut a = BitArray::<u32, U8>::from_bytes(&[a]);
let b = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(a.union(&b));
assert_eq!(a, BitArray::<u32, U8>::from_bytes(&[res]));

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

Calculates the intersection of two bitarrays. This acts like the bitwise and function.

Sets self to the intersection of self and other. Both bitarrays must be the same length. Returns true if self changed.

Panics

Panics if the bitarrays are of different lengths.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01000000;

let mut a = BitArray::<u32, U8>::from_bytes(&[a]);
let b = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(a.intersect(&b));
assert_eq!(a, BitArray::<u32, U8>::from_bytes(&[res]));

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

Calculates the difference between two bitarrays.

Sets each element of self to the value of that element minus the element of other at the same index. Both bitarrays must be the same length. Returns true if self changed.

Panics

Panics if the bitarrays are of different length.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let a   = 0b01100100;
let b   = 0b01011010;
let a_b = 0b00100100; // a - b
let b_a = 0b00011010; // b - a

let mut bva = BitArray::<u32, U8>::from_bytes(&[a]);
let bvb = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(bva.difference(&bvb));
assert_eq!(bva, BitArray::<u32, U8>::from_bytes(&[a_b]));

let bva = BitArray::<u32, U8>::from_bytes(&[a]);
let mut bvb = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(bvb.difference(&bva));
assert_eq!(bvb, BitArray::<u32, U8>::from_bytes(&[b_a]));

fn all(&self) -> bool

Returns true if all bits are 1.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(true);
assert_eq!(bv.all(), true);

bv.set(1, false);
assert_eq!(bv.all(), false);

fn iter(&self) -> Iter<B, NBits>

Returns an iterator over the elements of the array in order.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U16;

let bv = BitArray::<u32, U16>::from_bytes(&[0b01110100, 0b10010010]);
assert_eq!(bv.iter().filter(|x| *x).count(), 7);

fn none(&self) -> bool

Returns true if all bits are 0.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(false);
assert_eq!(bv.none(), true);

bv.set(3, true);
assert_eq!(bv.none(), false);

fn any(&self) -> bool

Returns true if any bit is 1.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(false);
assert_eq!(bv.any(), false);

bv.set(3, true);
assert_eq!(bv.any(), true);

fn to_bytes(&self) -> Vec<u8>

Organises the bits into bytes, such that the first bit in the BitArray becomes the high-order bit of the first byte. If the size of the BitArray is not a multiple of eight then trailing bits will be filled-in with false.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::{U3, U9};

let mut bv = BitArray::<u32, U3>::from_elem(true);
bv.set(1, false);

assert_eq!(bv.to_bytes(), [0b10100000]);

let mut bv = BitArray::<u32, U9>::from_elem(false);
bv.set(2, true);
bv.set(8, true);

assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);

fn eq_vec(&self, v: &[bool]) -> bool

Compares a BitArray to a slice of bools. Both the BitArray and slice must have the same length.

Panics

Panics if the BitArray and slice are of different length.

Examples

extern crate typenum;
use bit_array::BitArray;
use typenum::U8;

let bv = BitArray::<u32, U8>::from_bytes(&[0b10100000]);

assert!(bv.eq_vec(&[true, false, true, false,
                    false, false, false, false]));

fn len(&self) -> usize

Returns the total number of bits in this array

fn clear(&mut self)

Clears all bits in this array.

Trait Implementations

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Index<usize> for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

type Output = bool

The returned type after indexing

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

The method for the indexing (Foo[Bar]) operation

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Default for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

fn default() -> Self

Returns the "default value" for a type.

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> FromIterator<bool> for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

fn from_iter<I: IntoIterator<Item=bool>>(iter: I) -> Self

Creates a value from an iterator.

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Clone for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> PartialOrd for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Ord for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Debug for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

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

Formats the value using the given formatter.

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Hash for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> PartialEq for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

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

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Eq for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

impl<'a, B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> IntoIterator for &'a BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

type Item = bool

The type of the elements being iterated over.

type IntoIter = Iter<'a, B, NBits>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, B, NBits>

Creates an iterator from a value.

impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> IntoIterator for BitArray<B, NBits> where NBits: Add<B::Output>, NBits::Output: Sub<B1>, NBits::Output::Output: Div<B::Output>, NBits::Output::Output::Output: ArrayLength<B>

type Item = bool

The type of the elements being iterated over.

type IntoIter = IntoIter<B, NBits>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<B, NBits>

Creates an iterator from a value.