Struct bit_vec::BitVec [−][src]
pub struct BitVec<B = u32> { /* fields omitted */ }
Expand description
The bitvector type.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::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);
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);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
// reset bitvector to empty
bv.clear();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
Implementations
Creates a BitVec
that holds nbits
elements, setting each element
to bit
.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.len(), 10);
for x in bv.iter() {
assert_eq!(x, false);
}
Constructs a new, empty BitVec
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.
Transforms a byte-vector into a BitVec
. 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
use bit_vec::BitVec;
let bv = BitVec::from_bytes(&[0b10100000, 0b00010010]);
assert!(bv.eq_vec(&[true, false, true, false,
false, false, false, false,
false, false, false, true,
false, false, true, false]));
Iterator over the underlying blocks of data
Exposes the raw block storage of this BitVec
Only really intended for BitSet.
Exposes the raw block storage of this BitVec
Can probably cause unsafety. Only really intended for BitSet.
Retrieves the value at index i
, or None
if the index is out of bounds.
Examples
use bit_vec::BitVec;
let bv = BitVec::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);
Sets all bits to 1.
Examples
use bit_vec::BitVec;
let before = 0b01100000;
let after = 0b11111111;
let mut bv = BitVec::from_bytes(&[before]);
bv.set_all();
assert_eq!(bv, BitVec::from_bytes(&[after]));
Flips all bits.
Examples
use bit_vec::BitVec;
let before = 0b01100000;
let after = 0b10011111;
let mut bv = BitVec::from_bytes(&[before]);
bv.negate();
assert_eq!(bv, BitVec::from_bytes(&[after]));
👎 Deprecated since 0.7.0: Please use the ‘or’ function instead
Please use the ‘or’ function instead
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
use bit_vec::BitVec;
let a = 0b01100100;
let b = 0b01011010;
let res = 0b01111110;
let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);
assert!(a.union(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));
👎 Deprecated since 0.7.0: Please use the ‘and’ function instead
Please use the ‘and’ function instead
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
use bit_vec::BitVec;
let a = 0b01100100;
let b = 0b01011010;
let res = 0b01000000;
let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);
assert!(a.intersect(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));
Calculates the bitwise or
of two bitvectors.
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
use bit_vec::BitVec;
let a = 0b01100100;
let b = 0b01011010;
let res = 0b01111110;
let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);
assert!(a.or(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));
Calculates the bitwise and
of two bitvectors.
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
use bit_vec::BitVec;
let a = 0b01100100;
let b = 0b01011010;
let res = 0b01000000;
let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);
assert!(a.and(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));
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
use bit_vec::BitVec;
let a = 0b01100100;
let b = 0b01011010;
let a_b = 0b00100100; // a - b
let b_a = 0b00011010; // b - a
let mut bva = BitVec::from_bytes(&[a]);
let bvb = BitVec::from_bytes(&[b]);
assert!(bva.difference(&bvb));
assert_eq!(bva, BitVec::from_bytes(&[a_b]));
let bva = BitVec::from_bytes(&[a]);
let mut bvb = BitVec::from_bytes(&[b]);
assert!(bvb.difference(&bva));
assert_eq!(bvb, BitVec::from_bytes(&[b_a]));
Calculates the xor of two bitvectors.
Sets self
to the xor of self
and other
. Both bitvectors must be
the same length. Returns true
if self
changed.
Panics
Panics if the bitvectors are of different length.
Examples
use bit_vec::BitVec;
let a = 0b01100110;
let b = 0b01010100;
let res = 0b00110010;
let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);
assert!(a.xor(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));
Calculates the nand of two bitvectors.
Sets self
to the nand of self
and other
. Both bitvectors must be
the same length. Returns true
if self
changed.
Panics
Panics if the bitvectors are of different length.
Examples
use bit_vec::BitVec;
let a = 0b01100110;
let b = 0b01010100;
let res = 0b10111011;
let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);
assert!(a.nand(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));
Calculates the nor of two bitvectors.
Sets self
to the nor of self
and other
. Both bitvectors must be
the same length. Returns true
if self
changed.
Panics
Panics if the bitvectors are of different length.
Examples
use bit_vec::BitVec;
let a = 0b01100110;
let b = 0b01010100;
let res = 0b10001001;
let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);
assert!(a.nor(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));
Calculates the xnor of two bitvectors.
Sets self
to the xnor of self
and other
. Both bitvectors must be
the same length. Returns true
if self
changed.
Panics
Panics if the bitvectors are of different length.
Examples
use bit_vec::BitVec;
let a = 0b01100110;
let b = 0b01010100;
let res = 0b11001101;
let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);
assert!(a.xnor(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));
Returns true
if all bits are 1.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_elem(5, true);
assert_eq!(bv.all(), true);
bv.set(1, false);
assert_eq!(bv.all(), false);
Returns an iterator over the elements of the vector in order.
Examples
use bit_vec::BitVec;
let bv = BitVec::from_bytes(&[0b01110100, 0b10010010]);
assert_eq!(bv.iter().filter(|x| *x).count(), 7);
Moves all bits from other
into Self
, leaving other
empty.
Examples
use bit_vec::BitVec;
let mut a = BitVec::from_bytes(&[0b10000000]);
let mut b = BitVec::from_bytes(&[0b01100001]);
a.append(&mut b);
assert_eq!(a.len(), 16);
assert_eq!(b.len(), 0);
assert!(a.eq_vec(&[true, false, false, false, false, false, false, false,
false, true, true, false, false, false, false, true]));
Splits the BitVec
into two at the given bit,
retaining the first half in-place and returning the second one.
Panics
Panics if at
is out of bounds.
Examples
use bit_vec::BitVec;
let mut a = BitVec::new();
a.push(true);
a.push(false);
a.push(false);
a.push(true);
let b = a.split_off(2);
assert_eq!(a.len(), 2);
assert_eq!(b.len(), 2);
assert!(a.eq_vec(&[true, false]));
assert!(b.eq_vec(&[false, true]));
Returns true
if all bits are 0.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.none(), true);
bv.set(3, true);
assert_eq!(bv.none(), false);
Returns true
if any bit is 1.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.any(), false);
bv.set(3, true);
assert_eq!(bv.any(), true);
Organises the bits into bytes, such that the first bit in the
BitVec
becomes the high-order bit of the first byte. If the
size of the BitVec
is not a multiple of eight then trailing bits
will be filled-in with false
.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_elem(3, true);
bv.set(1, false);
assert_eq!(bv.to_bytes(), [0b10100000]);
let mut bv = BitVec::from_elem(9, false);
bv.set(2, true);
bv.set(8, true);
assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);
Compares a BitVec
to a slice of bool
s.
Both the BitVec
and slice must have the same length.
Panics
Panics if the BitVec
and slice are of different length.
Examples
use bit_vec::BitVec;
let bv = BitVec::from_bytes(&[0b10100000]);
assert!(bv.eq_vec(&[true, false, true, false,
false, false, false, false]));
Shortens a BitVec
, dropping excess elements.
If len
is greater than the vector’s current length, this has no
effect.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_bytes(&[0b01001011]);
bv.truncate(2);
assert!(bv.eq_vec(&[false, true]));
Reserves capacity for at least additional
more bits to be inserted in the given
BitVec
. The collection may reserve more space to avoid frequent reallocations.
Panics
Panics if the new capacity overflows usize
.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_elem(3, false);
bv.reserve(10);
assert_eq!(bv.len(), 3);
assert!(bv.capacity() >= 13);
Reserves the minimum capacity for exactly additional
more bits to be inserted in the
given BitVec
. 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 usize
.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_elem(3, false);
bv.reserve(10);
assert_eq!(bv.len(), 3);
assert!(bv.capacity() >= 13);
Returns the capacity in bits for this bit vector. Inserting any element less than this amount will not trigger a resizing.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::new();
bv.reserve(10);
assert!(bv.capacity() >= 10);
Removes the last bit from the BitVec, and returns it. Returns None if the BitVec is empty.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::from_bytes(&[0b01001001]);
assert_eq!(bv.pop(), Some(true));
assert_eq!(bv.pop(), Some(false));
assert_eq!(bv.len(), 6);
Pushes a bool
onto the end.
Examples
use bit_vec::BitVec;
let mut bv = BitVec::new();
bv.push(true);
bv.push(false);
assert!(bv.eq_vec(&[true, false]));
Sets the number of bits that this BitVec considers initialized.
Almost certainly can cause bad stuff. Only really intended for BitSet.
Shrinks the capacity of the underlying storage as much as possible.
It will drop down as close as possible to the length but the allocator may still inform the underlying storage that there is space for a few more elements/bits.
Trait Implementations
Extends a collection with the contents of an iterator. Read more
extend_one
)Extends a collection with exactly one element.
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
Creates a value from an iterator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Auto Trait Implementations
impl<B> RefUnwindSafe for BitVec<B> where
B: RefUnwindSafe,
impl<B> UnwindSafe for BitVec<B> where
B: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more