Struct collections::BitvExperimental [-]  [+] [src]

pub struct Bitv {
    // some fields omitted
}

The bitvector type.

Examples

extern crate collections; fn main() { use collections::Bitv; let mut bv = Bitv::from_elem(10, 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.to_string()); println!("total bits set to true: {}", bv.iter().filter(|x| *x).count()); // flip all values in bitvector, producing non-primes less than 10 bv.negate(); println!("{}", bv.to_string()); println!("total bits set to true: {}", bv.iter().filter(|x| *x).count()); // reset bitvector to empty bv.clear(); println!("{}", bv.to_string()); println!("total bits set to true: {}", bv.iter().filter(|x| *x).count()); }
use collections::Bitv;

let mut bv = Bitv::from_elem(10, 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.to_string());
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

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

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

Methods

impl Bitv

fn new() -> Bitv

Creates an empty Bitv.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::new(); }
use std::collections::Bitv;
let mut bv = Bitv::new();

fn from_elem(nbits: uint, bit: bool) -> Bitv

Creates a Bitv that holds nbits elements, setting each element to bit.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_elem(10u, false); assert_eq!(bv.len(), 10u); for x in bv.iter() { assert_eq!(x, false); } }
use std::collections::Bitv;

let mut bv = Bitv::from_elem(10u, false);
assert_eq!(bv.len(), 10u);
for x in bv.iter() {
    assert_eq!(x, false);
}

fn with_capacity(nbits: uint) -> Bitv

Constructs a new, empty Bitv with the specified capacity.

The bitvector will be able to hold at least capacity bits without reallocating. If capacity is 0, it will not allocate.

It is important to note that this function does not specify the length of the returned bitvector, but only the capacity.

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

Transforms a byte-vector into a Bitv. 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 collections; fn main() { use std::collections::Bitv; let bv = Bitv::from_bytes(&[0b10100000, 0b00010010]); assert!(bv.eq_vec(&[true, false, true, false, false, false, false, false, false, false, false, true, false, false, true, false])); }
use std::collections::Bitv;

let bv = Bitv::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>(len: uint, f: F) -> Bitv where F: FnMut(uint) -> bool

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

Examples

extern crate collections; fn main() { use std::collections::Bitv; let bv = Bitv::from_fn(5, |i| { i % 2 == 0 }); assert!(bv.eq_vec(&[true, false, true, false, true])); }
use std::collections::Bitv;

let bv = Bitv::from_fn(5, |i| { i % 2 == 0 });
assert!(bv.eq_vec(&[true, false, true, false, true]));

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

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

Examples

extern crate collections; fn main() { use std::collections::Bitv; let bv = Bitv::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); }
use std::collections::Bitv;

let bv = Bitv::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: uint, x: bool)

Sets the value of a bit at an index i.

Panics

Panics if i is out of bounds.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_elem(5, false); bv.set(3, true); assert_eq!(bv[3], true); }
use std::collections::Bitv;

let mut bv = Bitv::from_elem(5, false);
bv.set(3, true);
assert_eq!(bv[3], true);

fn set_all(&mut self)

Sets all bits to 1.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let before = 0b01100000; let after = 0b11111111; let mut bv = Bitv::from_bytes(&[before]); bv.set_all(); assert_eq!(bv, Bitv::from_bytes(&[after])); }
use std::collections::Bitv;

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

let mut bv = Bitv::from_bytes(&[before]);
bv.set_all();
assert_eq!(bv, Bitv::from_bytes(&[after]));

fn negate(&mut self)

Flips all bits.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let before = 0b01100000; let after = 0b10011111; let mut bv = Bitv::from_bytes(&[before]); bv.negate(); assert_eq!(bv, Bitv::from_bytes(&[after])); }
use std::collections::Bitv;

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

let mut bv = Bitv::from_bytes(&[before]);
bv.negate();
assert_eq!(bv, Bitv::from_bytes(&[after]));

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

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

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

Panics

Panics if the bitvectors are of different lengths.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let a = 0b01100100; let b = 0b01011010; let res = 0b01111110; let mut a = Bitv::from_bytes(&[a]); let b = Bitv::from_bytes(&[b]); assert!(a.union(&b)); assert_eq!(a, Bitv::from_bytes(&[res])); }
use std::collections::Bitv;

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

let mut a = Bitv::from_bytes(&[a]);
let b = Bitv::from_bytes(&[b]);

assert!(a.union(&b));
assert_eq!(a, Bitv::from_bytes(&[res]));

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

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

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

Panics

Panics if the bitvectors are of different lengths.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let a = 0b01100100; let b = 0b01011010; let res = 0b01000000; let mut a = Bitv::from_bytes(&[a]); let b = Bitv::from_bytes(&[b]); assert!(a.intersect(&b)); assert_eq!(a, Bitv::from_bytes(&[res])); }
use std::collections::Bitv;

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

let mut a = Bitv::from_bytes(&[a]);
let b = Bitv::from_bytes(&[b]);

assert!(a.intersect(&b));
assert_eq!(a, Bitv::from_bytes(&[res]));

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

Calculates the difference between two bitvectors.

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

Panics

Panics if the bitvectors are of different length.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let a = 0b01100100; let b = 0b01011010; let a_b = 0b00100100; // a - b let b_a = 0b00011010; // b - a let mut bva = Bitv::from_bytes(&[a]); let bvb = Bitv::from_bytes(&[b]); assert!(bva.difference(&bvb)); assert_eq!(bva, Bitv::from_bytes(&[a_b])); let bva = Bitv::from_bytes(&[a]); let mut bvb = Bitv::from_bytes(&[b]); assert!(bvb.difference(&bva)); assert_eq!(bvb, Bitv::from_bytes(&[b_a])); }
use std::collections::Bitv;

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

let mut bva = Bitv::from_bytes(&[a]);
let bvb = Bitv::from_bytes(&[b]);

assert!(bva.difference(&bvb));
assert_eq!(bva, Bitv::from_bytes(&[a_b]));

let bva = Bitv::from_bytes(&[a]);
let mut bvb = Bitv::from_bytes(&[b]);

assert!(bvb.difference(&bva));
assert_eq!(bvb, Bitv::from_bytes(&[b_a]));

fn all(&self) -> bool

Returns true if all bits are 1.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_elem(5, true); assert_eq!(bv.all(), true); bv.set(1, false); assert_eq!(bv.all(), false); }
use std::collections::Bitv;

let mut bv = Bitv::from_elem(5, true);
assert_eq!(bv.all(), true);

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

fn iter<'a>(&'a self) -> Bits<'a>

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

Examples

extern crate collections; fn main() { use std::collections::Bitv; let bv = Bitv::from_bytes(&[0b01110100, 0b10010010]); assert_eq!(bv.iter().filter(|x| *x).count(), 7); }
use std::collections::Bitv;

let bv = Bitv::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 collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_elem(10, false); assert_eq!(bv.none(), true); bv.set(3, true); assert_eq!(bv.none(), false); }
use std::collections::Bitv;

let mut bv = Bitv::from_elem(10, 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 collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_elem(10, false); assert_eq!(bv.any(), false); bv.set(3, true); assert_eq!(bv.any(), true); }
use std::collections::Bitv;

let mut bv = Bitv::from_elem(10, 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 Bitv becomes the high-order bit of the first byte. If the size of the Bitv is not a multiple of eight then trailing bits will be filled-in with false.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_elem(3, true); bv.set(1, false); assert_eq!(bv.to_bytes(), vec!(0b10100000)); let mut bv = Bitv::from_elem(9, false); bv.set(2, true); bv.set(8, true); assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000)); }
use std::collections::Bitv;

let mut bv = Bitv::from_elem(3, true);
bv.set(1, false);

assert_eq!(bv.to_bytes(), vec!(0b10100000));

let mut bv = Bitv::from_elem(9, false);
bv.set(2, true);
bv.set(8, true);

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

fn to_bools(&self) -> Vec<bool>

Deprecated: Use iter().collect().

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

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

Panics

Panics if the Bitv and slice are of different length.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let bv = Bitv::from_bytes(&[0b10100000]); assert!(bv.eq_vec(&[true, false, true, false, false, false, false, false])); }
use std::collections::Bitv;

let bv = Bitv::from_bytes(&[0b10100000]);

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

fn truncate(&mut self, len: uint)

Shortens a Bitv, dropping excess elements.

If len is greater than the vector's current length, this has no effect.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_bytes(&[0b01001011]); bv.truncate(2); assert!(bv.eq_vec(&[false, true])); }
use std::collections::Bitv;

let mut bv = Bitv::from_bytes(&[0b01001011]);
bv.truncate(2);
assert!(bv.eq_vec(&[false, true]));

fn reserve(&mut self, additional: uint)

Reserves capacity for at least additional more bits to be inserted in the given Bitv. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new capacity overflows uint.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_elem(3, false); bv.reserve(10); assert_eq!(bv.len(), 3); assert!(bv.capacity() >= 13); }
use std::collections::Bitv;

let mut bv = Bitv::from_elem(3, false);
bv.reserve(10);
assert_eq!(bv.len(), 3);
assert!(bv.capacity() >= 13);

fn reserve_exact(&mut self, additional: uint)

Reserves the minimum capacity for exactly additional more bits to be inserted in the given Bitv. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity overflows uint.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_elem(3, false); bv.reserve(10); assert_eq!(bv.len(), 3); assert!(bv.capacity() >= 13); }
use std::collections::Bitv;

let mut bv = Bitv::from_elem(3, false);
bv.reserve(10);
assert_eq!(bv.len(), 3);
assert!(bv.capacity() >= 13);

fn capacity(&self) -> uint

Returns the capacity in bits for this bit vector. Inserting any element less than this amount will not trigger a resizing.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::new(); bv.reserve(10); assert!(bv.capacity() >= 10); }
use std::collections::Bitv;

let mut bv = Bitv::new();
bv.reserve(10);
assert!(bv.capacity() >= 10);

fn grow(&mut self, n: uint, value: bool)

Grows the Bitv in-place, adding n copies of value to the Bitv.

Panics

Panics if the new len overflows a uint.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_bytes(&[0b01001011]); bv.grow(2, true); assert_eq!(bv.len(), 10); assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000)); }
use std::collections::Bitv;

let mut bv = Bitv::from_bytes(&[0b01001011]);
bv.grow(2, true);
assert_eq!(bv.len(), 10);
assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000));

fn pop(&mut self) -> Option<bool>

Removes the last bit from the Bitv, and returns it. Returns None if the Bitv is empty.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::from_bytes(&[0b01001001]); assert_eq!(bv.pop(), Some(true)); assert_eq!(bv.pop(), Some(false)); assert_eq!(bv.len(), 6); }
use std::collections::Bitv;

let mut bv = Bitv::from_bytes(&[0b01001001]);
assert_eq!(bv.pop(), Some(true));
assert_eq!(bv.pop(), Some(false));
assert_eq!(bv.len(), 6);

fn push(&mut self, elem: bool)

Pushes a bool onto the end.

Examples

extern crate collections; fn main() { use std::collections::Bitv; let mut bv = Bitv::new(); bv.push(true); bv.push(false); assert!(bv.eq_vec(&[true, false])); }
use std::collections::Bitv;

let mut bv = Bitv::new();
bv.push(true);
bv.push(false);
assert!(bv.eq_vec(&[true, false]));

fn len(&self) -> uint

Return the total number of bits in this vector

fn is_empty(&self) -> bool

Returns true if there are no bits in this vector

fn clear(&mut self)

Clears all bits in this vector.

Trait Implementations

impl Index<uint, bool> for Bitv

fn index<'a>(&'a self, i: &uint) -> &'a bool

impl Default for Bitv

fn default() -> Bitv

impl FromIterator<bool> for Bitv

fn from_iter<I: Iterator<bool>>(iterator: I) -> Bitv

impl Extend<bool> for Bitv

fn extend<I: Iterator<bool>>(&mut self, iterator: I)

impl Clone for Bitv

fn clone(&self) -> Bitv

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

impl PartialOrd for Bitv

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

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

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

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

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

impl Ord for Bitv

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

impl Show for Bitv

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

impl<S: Writer> Hash<S> for Bitv

fn hash(&self, state: &mut S)

impl PartialEq for Bitv

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

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

impl Eq for Bitv