---

yaml
---
r: 27930
b: refs/heads/try
c: f533276
h: refs/heads/master
v: v3

Author: bblum

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
-refs/heads/try: 69d66a702ef5162d804c148f0c3f4038f67020cd
+refs/heads/try: f5332769d58c5e8d9fee36a7e1f8faa4f5c1b861
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df

branches/try/src/libstd/bitv.rs

@@ -19,42 +19,37 @@ export to_str;
 export eq_vec;
 export methods;
 
-/// a mask that has a 1 for each defined bit in a small_bitv, assuming n bits
-#[inline(always)]
-fn small_mask(nbits: uint) -> u32 {
-    (1 << nbits) - 1
-}
-
 struct small_bitv {
-    /// only the lowest nbits of this value are used. the rest is undefined.
     let mut bits: u32;
     new(bits: u32) { self.bits = bits; }
     priv {
         #[inline(always)]
-        fn bits_op(right_bits: u32, nbits: uint, f: fn(u32, u32) -> u32)
-                                                                     -> bool {
-            let mask = small_mask(nbits);
+        fn bits_op(right_bits: u32, f: fn(u32, u32) -> u32) -> bool {
             let old_b: u32 = self.bits;
             let new_b = f(old_b, right_bits);
             self.bits = new_b;
-            mask & old_b != mask & new_b
+            old_b != new_b
         }
     }
     #[inline(always)]
-    fn union(s: &small_bitv, nbits: uint) -> bool {
-        self.bits_op(s.bits, nbits, |u1, u2| u1 | u2)
+    fn union(s: &small_bitv) -> bool {
+        self.bits_op(s.bits, |u1, u2| { u1 | u2 })
     }
     #[inline(always)]
-    fn intersect(s: &small_bitv, nbits: uint) -> bool {
-        self.bits_op(s.bits, nbits, |u1, u2| u1 & u2)
+    fn intersect(s: &small_bitv) -> bool {
+        self.bits_op(s.bits, |u1, u2| { u1 & u2 })
     }
     #[inline(always)]
-    fn become(s: &small_bitv, nbits: uint) -> bool {
-        self.bits_op(s.bits, nbits, |_u1, u2| u2)
+    fn become(s: &small_bitv) -> bool {
+        let old = self.bits;
+        self.bits = s.bits;
+        old != self.bits
     }
     #[inline(always)]
-    fn difference(s: &small_bitv, nbits: uint) -> bool {
-        self.bits_op(s.bits, nbits, |u1, u2| u1 ^ u2)
+    fn difference(s: &small_bitv) -> bool {
+        let old = self.bits;
+        self.bits &= !s.bits;
+        old != self.bits
     }
     #[inline(always)]
     pure fn get(i: uint) -> bool {
@@ -66,70 +61,42 @@ struct small_bitv {
             self.bits |= 1<<i;
         }
         else {
-            self.bits &= !(1<<i as u32);
+            self.bits &= !(i as u32);
         }
     }
     #[inline(always)]
-    fn equals(b: &small_bitv, nbits: uint) -> bool {
-        let mask = small_mask(nbits);
-        mask & self.bits == mask & b.bits
-    }
+    fn equals(b: &small_bitv) -> bool { self.bits == b.bits }
     #[inline(always)]
     fn clear() { self.bits = 0; }
     #[inline(always)]
     fn set_all() { self.bits = !0; }
     #[inline(always)]
-    fn is_true(nbits: uint) -> bool {
-        small_mask(nbits) & !self.bits == 0
-    }
+    fn is_true() -> bool { self.bits == !0 }
     #[inline(always)]
-    fn is_false(nbits: uint) -> bool {
-        small_mask(nbits) & self.bits == 0
-    }
+    fn is_false() -> bool { self.bits == 0 }
     #[inline(always)]
     fn invert() { self.bits = !self.bits; }
 }
 
-/**
- * a mask that has a 1 for each defined bit in the nth element of a big_bitv,
- * assuming n bits.
- */
-#[inline(always)]
-fn big_mask(nbits: uint, elem: uint) -> uint {
-    let rmd = nbits % uint_bits;
-    let nelems = nbits/uint_bits + if rmd == 0 {0} else {1};
-
-    if elem < nelems - 1 || rmd == 0 {
-        !0
-    } else {
-        (1 << rmd) - 1
-    }
-}
-
 struct big_bitv {
-    // only mut b/c of clone and lack of other constructor
+// only mut b/c of clone and lack of other constructor
     let mut storage: ~[mut uint];
     new(-storage: ~[mut uint]) {
         self.storage <- storage;
     }
     priv {
         #[inline(always)]
-        fn process(b: &big_bitv, nbits: uint, op: fn(uint, uint) -> uint)
-                                                                     -> bool {
+        fn process(b: &big_bitv, op: fn(uint, uint) -> uint) -> bool {
             let len = b.storage.len();
             assert (self.storage.len() == len);
             let mut changed = false;
             do uint::range(0, len) |i| {
-                let mask = big_mask(nbits, i);
-                let w0 = self.storage[i] & mask;
-                let w1 = b.storage[i] & mask;
-                let w = op(w0, w1) & mask;
-                if w0 != w unchecked {
-                    changed = true;
-                    self.storage[i] = w;
-                }
+                let w0 = self.storage[i];
+                let w1 = b.storage[i];
+                let w = op(w0, w1);
+                if w0 != w unchecked { changed = true; self.storage[i] = w; };
                 true
-            }
+            };
             changed
         }
     }
@@ -145,21 +112,15 @@ struct big_bitv {
     #[inline(always)]
     fn invert() { for self.each_storage() |w| { w = !w } }
     #[inline(always)]
-    fn union(b: &big_bitv, nbits: uint) -> bool {
-        self.process(b, nbits, lor)
-    }
+    fn union(b: &big_bitv)     -> bool { self.process(b, lor) }
     #[inline(always)]
-    fn intersect(b: &big_bitv, nbits: uint) -> bool {
-        self.process(b, nbits, land)
-    }
+    fn intersect(b: &big_bitv) -> bool { self.process(b, land) }
     #[inline(always)]
-    fn become(b: &big_bitv, nbits: uint) -> bool {
-        self.process(b, nbits, right)
-    }
+    fn become(b: &big_bitv)    -> bool { self.process(b, right) }
     #[inline(always)]
-    fn difference(b: &big_bitv, nbits: uint) -> bool {
+    fn difference(b: &big_bitv) -> bool {
         self.invert();
-        let b = self.intersect(b, nbits);
+        let b = self.intersect(b);
         self.invert();
         b
     }
@@ -179,13 +140,10 @@ struct big_bitv {
                  else { self.storage[w] & !flag };
     }
     #[inline(always)]
-    fn equals(b: &big_bitv, nbits: uint) -> bool {
+    fn equals(b: &big_bitv) -> bool {
         let len = b.storage.len();
         for uint::iterate(0, len) |i| {
-            let mask = big_mask(nbits, i);
-            if mask & self.storage[i] != mask & b.storage[i] {
-                return false;
-            }
+            if self.storage[i] != b.storage[i] { return false; }
         }
     }
 }
@@ -205,10 +163,8 @@ struct bitv {
           self.rep = small(~small_bitv(if init {!0} else {0}));
         }
         else {
-          let nelems = nbits/uint_bits +
-                       if nbits % uint_bits == 0 {0} else {1};
-          let elem = if init {!0} else {0};
-          let s = to_mut(from_elem(nelems, elem));
+          let s = to_mut(from_elem(nbits / uint_bits + 1,
+                                        if init {!0} else {0}));
           self.rep = big(~big_bitv(s));
         };
     }
@@ -226,20 +182,20 @@ struct bitv {
             match self.rep {
               small(s) => match other.rep {
                 small(s1) => match op {
-                  union      => s.union(s1,      self.nbits),
-                  intersect  => s.intersect(s1,  self.nbits),
-                  assign     => s.become(s1,     self.nbits),
-                  difference => s.difference(s1, self.nbits)
+                  union      => s.union(s1),
+                  intersect  => s.intersect(s1),
+                  assign     => s.become(s1),
+                  difference => s.difference(s1)
                 },
                 big(s1) => self.die()
               },
               big(s) => match other.rep {
                 small(_) => self.die(),
                 big(s1) => match op {
-                  union      => s.union(s1,      self.nbits),
-                  intersect  => s.intersect(s1,  self.nbits),
-                  assign     => s.become(s1,     self.nbits),
-                  difference => s.difference(s1, self.nbits)
+                  union      => s.union(s1),
+                  intersect  => s.intersect(s1),
+                  assign     => s.become(s1),
+                  difference => s.difference(s1)
                 }
               }
             }
@@ -324,11 +280,11 @@ struct bitv {
       if self.nbits != v1.nbits { return false; }
       match self.rep {
         small(b) => match v1.rep {
-          small(b1) => b.equals(b1, self.nbits),
+          small(b1) => b.equals(b1),
           _ => false
         },
         big(s) => match v1.rep {
-          big(s1) => s.equals(s1, self.nbits),
+          big(s1) => s.equals(s1),
           small(_) => return false
         }
       }
@@ -374,7 +330,7 @@ struct bitv {
     #[inline(always)]
     fn is_true() -> bool {
       match self.rep {
-        small(b) => b.is_true(self.nbits),
+        small(b) => b.is_true(),
         _ => {
           for self.each() |i| { if !i { return false; } }
           true
@@ -395,7 +351,7 @@ struct bitv {
 
     fn is_false() -> bool {
       match self.rep {
-        small(b) => b.is_false(self.nbits),
+        small(b) => b.is_false(),
         big(_) => {
           for self.each() |i| { if i { return false; } }
           true
@@ -500,14 +456,6 @@ mod tests {
         assert act.eq_vec(~[1u]);
     }
 
-    #[test]
-    fn test_2_elements() {
-        let b = bitv::bitv(2, false);
-        b.set(0, true);
-        b.set(1, false);
-        assert b.to_str() == ~"10";
-    }
-
     #[test]
     fn test_10_elements() {
         let mut act;
@@ -784,33 +732,6 @@ mod tests {
         let v1 = bitv(110u, false);
         assert !v0.equal(v1);
     }
-
-    #[test]
-    fn test_equal_sneaky_small() {
-        let a = bitv::bitv(1, false);
-        a.set(0, true);
-
-        let b = bitv::bitv(1, true);
-        b.set(0, true);
-
-        assert a.equal(b);
-    }
-
-    #[test]
-    fn test_equal_sneaky_big() {
-        let a = bitv::bitv(100, false);
-        for uint::range(0, 100) |i| {
-            a.set(i, true);
-        }
-
-        let b = bitv::bitv(100, true);
-        for uint::range(0, 100) |i| {
-            b.set(i, true);
-        }
-
-        assert a.equal(b);
-    }
-
 }
 
 //