src/librustc_data_structures/bitvec.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use std::iter::FromIterator;
  12
  13 /// A very simple BitVector type.
  14 #[derive(Clone, Debug, PartialEq)]
  15 pub struct BitVector {
  16     data: Vec<u64>,
  17 }
  18
  19 impl BitVector {
  20     #[inline]
  21     pub fn new(num_bits: usize) -> BitVector {
  22         let num_words = u64s(num_bits);
  23         BitVector { data: vec![0; num_words] }
  24     }
  25
  26     #[inline]
  27     pub fn clear(&mut self) {
  28         for p in &mut self.data {
  29             *p = 0;
  30         }
  31     }
  32
  33     #[inline]
  34     pub fn contains(&self, bit: usize) -> bool {
  35         let (word, mask) = word_mask(bit);
  36         (self.data[word] & mask) != 0
  37     }
  38
  39     /// Returns true if the bit has changed.
  40     #[inline]
  41     pub fn insert(&mut self, bit: usize) -> bool {
  42         let (word, mask) = word_mask(bit);
  43         let data = &mut self.data[word];
  44         let value = *data;
  45         let new_value = value | mask;
  46         *data = new_value;
  47         new_value != value
  48     }
  49
  50     #[inline]
  51     pub fn insert_all(&mut self, all: &BitVector) -> bool {
  52         assert!(self.data.len() == all.data.len());
  53         let mut changed = false;
  54         for (i, j) in self.data.iter_mut().zip(&all.data) {
  55             let value = *i;
  56             *i = value | *j;
  57             if value != *i {
  58                 changed = true;
  59             }
  60         }
  61         changed
  62     }
  63
  64     #[inline]
  65     pub fn grow(&mut self, num_bits: usize) {
  66         let num_words = u64s(num_bits);
  67         if self.data.len() < num_words {
  68             self.data.resize(num_words, 0)
  69         }
  70     }
  71
  72     /// Iterates over indexes of set bits in a sorted order
  73     #[inline]
  74     pub fn iter<'a>(&'a self) -> BitVectorIter<'a> {
  75         BitVectorIter {
  76             iter: self.data.iter(),
  77             current: 0,
  78             idx: 0,
  79         }
  80     }
  81 }
  82
  83 pub struct BitVectorIter<'a> {
  84     iter: ::std::slice::Iter<'a, u64>,
  85     current: u64,
  86     idx: usize,
  87 }
  88
  89 impl<'a> Iterator for BitVectorIter<'a> {
  90     type Item = usize;
  91     fn next(&mut self) -> Option<usize> {
  92         while self.current == 0 {
  93             self.current = if let Some(&i) = self.iter.next() {
  94                 if i == 0 {
  95                     self.idx += 64;
  96                     continue;
  97                 } else {
  98                     self.idx = u64s(self.idx) * 64;
  99                     i
 100                 }
 101             } else {
 102                 return None;
 103             }
 104         }
 105         let offset = self.current.trailing_zeros() as usize;
 106         self.current >>= offset;
 107         self.current >>= 1; // shift otherwise overflows for 0b1000_0000_…_0000
 108         self.idx += offset + 1;
 109         return Some(self.idx - 1);
 110     }
 111 }
 112
 113 impl FromIterator<bool> for BitVector {
 114     fn from_iter<I>(iter: I) -> BitVector where I: IntoIterator<Item=bool> {
 115         let iter = iter.into_iter();
 116         let (len, _) = iter.size_hint();
 117         // Make the minimum length for the bitvector 64 bits since that's
 118         // the smallest non-zero size anyway.
 119         let len = if len < 64 { 64 } else { len };
 120         let mut bv = BitVector::new(len);
 121         for (idx, val) in iter.enumerate() {
 122             if idx > len {
 123                 bv.grow(idx);
 124             }
 125             if val {
 126                 bv.insert(idx);
 127             }
 128         }
 129
 130         bv
 131     }
 132 }
 133
 134 /// A "bit matrix" is basically a matrix of booleans represented as
 135 /// one gigantic bitvector. In other words, it is as if you have
 136 /// `rows` bitvectors, each of length `columns`.
 137 #[derive(Clone)]
 138 pub struct BitMatrix {
 139     columns: usize,
 140     vector: Vec<u64>,
 141 }
 142
 143 impl BitMatrix {
 144     // Create a new `rows x columns` matrix, initially empty.
 145     pub fn new(rows: usize, columns: usize) -> BitMatrix {
 146         // For every element, we need one bit for every other
 147         // element. Round up to an even number of u64s.
 148         let u64s_per_row = u64s(columns);
 149         BitMatrix {
 150             columns: columns,
 151             vector: vec![0; rows * u64s_per_row],
 152         }
 153     }
 154
 155     /// The range of bits for a given row.
 156     fn range(&self, row: usize) -> (usize, usize) {
 157         let u64s_per_row = u64s(self.columns);
 158         let start = row * u64s_per_row;
 159         (start, start + u64s_per_row)
 160     }
 161
 162     pub fn add(&mut self, source: usize, target: usize) -> bool {
 163         let (start, _) = self.range(source);
 164         let (word, mask) = word_mask(target);
 165         let mut vector = &mut self.vector[..];
 166         let v1 = vector[start + word];
 167         let v2 = v1 | mask;
 168         vector[start + word] = v2;
 169         v1 != v2
 170     }
 171
 172     /// Do the bits from `source` contain `target`?
 173     ///
 174     /// Put another way, if the matrix represents (transitive)
 175     /// reachability, can `source` reach `target`?
 176     pub fn contains(&self, source: usize, target: usize) -> bool {
 177         let (start, _) = self.range(source);
 178         let (word, mask) = word_mask(target);
 179         (self.vector[start + word] & mask) != 0
 180     }
 181
 182     /// Returns those indices that are reachable from both `a` and
 183     /// `b`. This is an O(n) operation where `n` is the number of
 184     /// elements (somewhat independent from the actual size of the
 185     /// intersection, in particular).
 186     pub fn intersection(&self, a: usize, b: usize) -> Vec<usize> {
 187         let (a_start, a_end) = self.range(a);
 188         let (b_start, b_end) = self.range(b);
 189         let mut result = Vec::with_capacity(self.columns);
 190         for (base, (i, j)) in (a_start..a_end).zip(b_start..b_end).enumerate() {
 191             let mut v = self.vector[i] & self.vector[j];
 192             for bit in 0..64 {
 193                 if v == 0 {
 194                     break;
 195                 }
 196                 if v & 0x1 != 0 {
 197                     result.push(base * 64 + bit);
 198                 }
 199                 v >>= 1;
 200             }
 201         }
 202         result
 203     }
 204
 205     /// Add the bits from `read` to the bits from `write`,
 206     /// return true if anything changed.
 207     ///
 208     /// This is used when computing transitive reachability because if
 209     /// you have an edge `write -> read`, because in that case
 210     /// `write` can reach everything that `read` can (and
 211     /// potentially more).
 212     pub fn merge(&mut self, read: usize, write: usize) -> bool {
 213         let (read_start, read_end) = self.range(read);
 214         let (write_start, write_end) = self.range(write);
 215         let vector = &mut self.vector[..];
 216         let mut changed = false;
 217         for (read_index, write_index) in (read_start..read_end).zip(write_start..write_end) {
 218             let v1 = vector[write_index];
 219             let v2 = v1 | vector[read_index];
 220             vector[write_index] = v2;
 221             changed = changed | (v1 != v2);
 222         }
 223         changed
 224     }
 225
 226     pub fn iter<'a>(&'a self, row: usize) -> BitVectorIter<'a> {
 227         let (start, end) = self.range(row);
 228         BitVectorIter {
 229             iter: self.vector[start..end].iter(),
 230             current: 0,
 231             idx: 0,
 232         }
 233     }
 234 }
 235
 236 #[inline]
 237 fn u64s(elements: usize) -> usize {
 238     (elements + 63) / 64
 239 }
 240
 241 #[inline]
 242 fn word_mask(index: usize) -> (usize, u64) {
 243     let word = index / 64;
 244     let mask = 1 << (index % 64);
 245     (word, mask)
 246 }
 247
 248 #[test]
 249 fn bitvec_iter_works() {
 250     let mut bitvec = BitVector::new(100);
 251     bitvec.insert(1);
 252     bitvec.insert(10);
 253     bitvec.insert(19);
 254     bitvec.insert(62);
 255     bitvec.insert(63);
 256     bitvec.insert(64);
 257     bitvec.insert(65);
 258     bitvec.insert(66);
 259     bitvec.insert(99);
 260     assert_eq!(bitvec.iter().collect::<Vec<_>>(),
 261                [1, 10, 19, 62, 63, 64, 65, 66, 99]);
 262 }
 263
 264
 265 #[test]
 266 fn bitvec_iter_works_2() {
 267     let mut bitvec = BitVector::new(319);
 268     bitvec.insert(0);
 269     bitvec.insert(127);
 270     bitvec.insert(191);
 271     bitvec.insert(255);
 272     bitvec.insert(319);
 273     assert_eq!(bitvec.iter().collect::<Vec<_>>(), [0, 127, 191, 255, 319]);
 274 }
 275
 276 #[test]
 277 fn union_two_vecs() {
 278     let mut vec1 = BitVector::new(65);
 279     let mut vec2 = BitVector::new(65);
 280     assert!(vec1.insert(3));
 281     assert!(!vec1.insert(3));
 282     assert!(vec2.insert(5));
 283     assert!(vec2.insert(64));
 284     assert!(vec1.insert_all(&vec2));
 285     assert!(!vec1.insert_all(&vec2));
 286     assert!(vec1.contains(3));
 287     assert!(!vec1.contains(4));
 288     assert!(vec1.contains(5));
 289     assert!(!vec1.contains(63));
 290     assert!(vec1.contains(64));
 291 }
 292
 293 #[test]
 294 fn grow() {
 295     let mut vec1 = BitVector::new(65);
 296     for index in 0 .. 65 {
 297         assert!(vec1.insert(index));
 298         assert!(!vec1.insert(index));
 299     }
 300     vec1.grow(128);
 301
 302     // Check if the bits set before growing are still set
 303     for index in 0 .. 65 {
 304         assert!(vec1.contains(index));
 305     }
 306
 307     // Check if the new bits are all un-set
 308     for index in 65 .. 128 {
 309         assert!(!vec1.contains(index));
 310     }
 311
 312     // Check that we can set all new bits without running out of bounds
 313     for index in 65 .. 128 {
 314         assert!(vec1.insert(index));
 315         assert!(!vec1.insert(index));
 316     }
 317 }
 318
 319 #[test]
 320 fn matrix_intersection() {
 321     let mut vec1 = BitMatrix::new(200, 200);
 322
 323     // (*) Elements reachable from both 2 and 65.
 324
 325     vec1.add(2, 3);
 326     vec1.add(2, 6);
 327     vec1.add(2, 10); // (*)
 328     vec1.add(2, 64); // (*)
 329     vec1.add(2, 65);
 330     vec1.add(2, 130);
 331     vec1.add(2, 160); // (*)
 332
 333     vec1.add(64, 133);
 334
 335     vec1.add(65, 2);
 336     vec1.add(65, 8);
 337     vec1.add(65, 10); // (*)
 338     vec1.add(65, 64); // (*)
 339     vec1.add(65, 68);
 340     vec1.add(65, 133);
 341     vec1.add(65, 160); // (*)
 342
 343     let intersection = vec1.intersection(2, 64);
 344     assert!(intersection.is_empty());
 345
 346     let intersection = vec1.intersection(2, 65);
 347     assert_eq!(intersection, &[10, 64, 160]);
 348 }
 349
 350 #[test]
 351 fn matrix_iter() {
 352     let mut matrix = BitMatrix::new(64, 100);
 353     matrix.add(3, 22);
 354     matrix.add(3, 75);
 355     matrix.add(2, 99);
 356     matrix.add(4, 0);
 357     matrix.merge(3, 5);
 358
 359     let expected = [99];
 360     let mut iter = expected.iter();
 361     for i in matrix.iter(2) {
 362         let j = *iter.next().unwrap();
 363         assert_eq!(i, j);
 364     }
 365     assert!(iter.next().is_none());
 366
 367     let expected = [22, 75];
 368     let mut iter = expected.iter();
 369     for i in matrix.iter(3) {
 370         let j = *iter.next().unwrap();
 371         assert_eq!(i, j);
 372     }
 373     assert!(iter.next().is_none());
 374
 375     let expected = [0];
 376     let mut iter = expected.iter();
 377     for i in matrix.iter(4) {
 378         let j = *iter.next().unwrap();
 379         assert_eq!(i, j);
 380     }
 381     assert!(iter.next().is_none());
 382
 383     let expected = [22, 75];
 384     let mut iter = expected.iter();
 385     for i in matrix.iter(5) {
 386         let j = *iter.next().unwrap();
 387         assert_eq!(i, j);
 388     }
 389     assert!(iter.next().is_none());
 390 }