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.
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.
11 use std
::iter
::FromIterator
;
13 /// A very simple BitVector type.
14 #[derive(Clone, Debug, PartialEq)]
15 pub struct BitVector
{
21 pub fn new(num_bits
: usize) -> BitVector
{
22 let num_words
= u64s(num_bits
);
23 BitVector { data: vec![0; num_words] }
27 pub fn clear(&mut self) {
28 for p
in &mut self.data
{
33 pub fn count(&self) -> usize {
34 self.data
.iter().map(|e
| e
.count_ones() as usize).sum()
38 pub fn contains(&self, bit
: usize) -> bool
{
39 let (word
, mask
) = word_mask(bit
);
40 (self.data
[word
] & mask
) != 0
43 /// Returns true if the bit has changed.
45 pub fn insert(&mut self, bit
: usize) -> bool
{
46 let (word
, mask
) = word_mask(bit
);
47 let data
= &mut self.data
[word
];
49 let new_value
= value
| mask
;
55 pub fn insert_all(&mut self, all
: &BitVector
) -> bool
{
56 assert
!(self.data
.len() == all
.data
.len());
57 let mut changed
= false;
58 for (i
, j
) in self.data
.iter_mut().zip(&all
.data
) {
69 pub fn grow(&mut self, num_bits
: usize) {
70 let num_words
= u64s(num_bits
);
71 if self.data
.len() < num_words
{
72 self.data
.resize(num_words
, 0)
76 /// Iterates over indexes of set bits in a sorted order
78 pub fn iter
<'a
>(&'a
self) -> BitVectorIter
<'a
> {
80 iter
: self.data
.iter(),
87 pub struct BitVectorIter
<'a
> {
88 iter
: ::std
::slice
::Iter
<'a
, u64>,
93 impl<'a
> Iterator
for BitVectorIter
<'a
> {
95 fn next(&mut self) -> Option
<usize> {
96 while self.current
== 0 {
97 self.current
= if let Some(&i
) = self.iter
.next() {
102 self.idx
= u64s(self.idx
) * 64;
109 let offset
= self.current
.trailing_zeros() as usize;
110 self.current
>>= offset
;
111 self.current
>>= 1; // shift otherwise overflows for 0b1000_0000_…_0000
112 self.idx
+= offset
+ 1;
113 return Some(self.idx
- 1);
117 impl FromIterator
<bool
> for BitVector
{
118 fn from_iter
<I
>(iter
: I
) -> BitVector
where I
: IntoIterator
<Item
=bool
> {
119 let iter
= iter
.into_iter();
120 let (len
, _
) = iter
.size_hint();
121 // Make the minimum length for the bitvector 64 bits since that's
122 // the smallest non-zero size anyway.
123 let len
= if len
< 64 { 64 }
else { len }
;
124 let mut bv
= BitVector
::new(len
);
125 for (idx
, val
) in iter
.enumerate() {
138 /// A "bit matrix" is basically a matrix of booleans represented as
139 /// one gigantic bitvector. In other words, it is as if you have
140 /// `rows` bitvectors, each of length `columns`.
142 pub struct BitMatrix
{
148 // Create a new `rows x columns` matrix, initially empty.
149 pub fn new(rows
: usize, columns
: usize) -> BitMatrix
{
150 // For every element, we need one bit for every other
151 // element. Round up to an even number of u64s.
152 let u64s_per_row
= u64s(columns
);
155 vector
: vec
![0; rows
* u64s_per_row
],
159 /// The range of bits for a given row.
160 fn range(&self, row
: usize) -> (usize, usize) {
161 let u64s_per_row
= u64s(self.columns
);
162 let start
= row
* u64s_per_row
;
163 (start
, start
+ u64s_per_row
)
166 pub fn add(&mut self, source
: usize, target
: usize) -> bool
{
167 let (start
, _
) = self.range(source
);
168 let (word
, mask
) = word_mask(target
);
169 let vector
= &mut self.vector
[..];
170 let v1
= vector
[start
+ word
];
172 vector
[start
+ word
] = v2
;
176 /// Do the bits from `source` contain `target`?
178 /// Put another way, if the matrix represents (transitive)
179 /// reachability, can `source` reach `target`?
180 pub fn contains(&self, source
: usize, target
: usize) -> bool
{
181 let (start
, _
) = self.range(source
);
182 let (word
, mask
) = word_mask(target
);
183 (self.vector
[start
+ word
] & mask
) != 0
186 /// Returns those indices that are reachable from both `a` and
187 /// `b`. This is an O(n) operation where `n` is the number of
188 /// elements (somewhat independent from the actual size of the
189 /// intersection, in particular).
190 pub fn intersection(&self, a
: usize, b
: usize) -> Vec
<usize> {
191 let (a_start
, a_end
) = self.range(a
);
192 let (b_start
, b_end
) = self.range(b
);
193 let mut result
= Vec
::with_capacity(self.columns
);
194 for (base
, (i
, j
)) in (a_start
..a_end
).zip(b_start
..b_end
).enumerate() {
195 let mut v
= self.vector
[i
] & self.vector
[j
];
201 result
.push(base
* 64 + bit
);
209 /// Add the bits from `read` to the bits from `write`,
210 /// return true if anything changed.
212 /// This is used when computing transitive reachability because if
213 /// you have an edge `write -> read`, because in that case
214 /// `write` can reach everything that `read` can (and
215 /// potentially more).
216 pub fn merge(&mut self, read
: usize, write
: usize) -> bool
{
217 let (read_start
, read_end
) = self.range(read
);
218 let (write_start
, write_end
) = self.range(write
);
219 let vector
= &mut self.vector
[..];
220 let mut changed
= false;
221 for (read_index
, write_index
) in (read_start
..read_end
).zip(write_start
..write_end
) {
222 let v1
= vector
[write_index
];
223 let v2
= v1
| vector
[read_index
];
224 vector
[write_index
] = v2
;
225 changed
= changed
| (v1
!= v2
);
230 pub fn iter
<'a
>(&'a
self, row
: usize) -> BitVectorIter
<'a
> {
231 let (start
, end
) = self.range(row
);
233 iter
: self.vector
[start
..end
].iter(),
241 fn u64s(elements
: usize) -> usize {
246 fn word_mask(index
: usize) -> (usize, u64) {
247 let word
= index
/ 64;
248 let mask
= 1 << (index
% 64);
253 fn bitvec_iter_works() {
254 let mut bitvec
= BitVector
::new(100);
264 assert_eq
!(bitvec
.iter().collect
::<Vec
<_
>>(),
265 [1, 10, 19, 62, 63, 64, 65, 66, 99]);
270 fn bitvec_iter_works_2() {
271 let mut bitvec
= BitVector
::new(319);
277 assert_eq
!(bitvec
.iter().collect
::<Vec
<_
>>(), [0, 127, 191, 255, 319]);
281 fn union_two_vecs() {
282 let mut vec1
= BitVector
::new(65);
283 let mut vec2
= BitVector
::new(65);
284 assert
!(vec1
.insert(3));
285 assert
!(!vec1
.insert(3));
286 assert
!(vec2
.insert(5));
287 assert
!(vec2
.insert(64));
288 assert
!(vec1
.insert_all(&vec2
));
289 assert
!(!vec1
.insert_all(&vec2
));
290 assert
!(vec1
.contains(3));
291 assert
!(!vec1
.contains(4));
292 assert
!(vec1
.contains(5));
293 assert
!(!vec1
.contains(63));
294 assert
!(vec1
.contains(64));
299 let mut vec1
= BitVector
::new(65);
300 for index
in 0 .. 65 {
301 assert
!(vec1
.insert(index
));
302 assert
!(!vec1
.insert(index
));
306 // Check if the bits set before growing are still set
307 for index
in 0 .. 65 {
308 assert
!(vec1
.contains(index
));
311 // Check if the new bits are all un-set
312 for index
in 65 .. 128 {
313 assert
!(!vec1
.contains(index
));
316 // Check that we can set all new bits without running out of bounds
317 for index
in 65 .. 128 {
318 assert
!(vec1
.insert(index
));
319 assert
!(!vec1
.insert(index
));
324 fn matrix_intersection() {
325 let mut vec1
= BitMatrix
::new(200, 200);
327 // (*) Elements reachable from both 2 and 65.
331 vec1
.add(2, 10); // (*)
332 vec1
.add(2, 64); // (*)
335 vec1
.add(2, 160); // (*)
341 vec1
.add(65, 10); // (*)
342 vec1
.add(65, 64); // (*)
345 vec1
.add(65, 160); // (*)
347 let intersection
= vec1
.intersection(2, 64);
348 assert
!(intersection
.is_empty());
350 let intersection
= vec1
.intersection(2, 65);
351 assert_eq
!(intersection
, &[10, 64, 160]);
356 let mut matrix
= BitMatrix
::new(64, 100);
364 let mut iter
= expected
.iter();
365 for i
in matrix
.iter(2) {
366 let j
= *iter
.next().unwrap();
369 assert
!(iter
.next().is_none());
371 let expected
= [22, 75];
372 let mut iter
= expected
.iter();
373 for i
in matrix
.iter(3) {
374 let j
= *iter
.next().unwrap();
377 assert
!(iter
.next().is_none());
380 let mut iter
= expected
.iter();
381 for i
in matrix
.iter(4) {
382 let j
= *iter
.next().unwrap();
385 assert
!(iter
.next().is_none());
387 let expected
= [22, 75];
388 let mut iter
= expected
.iter();
389 for i
in matrix
.iter(5) {
390 let j
= *iter
.next().unwrap();
393 assert
!(iter
.next().is_none());