From 8eb6d2d8296fb91b91c50c2e1d127a69a57be714 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sat, 20 Jul 2013 18:38:10 -0400 Subject: [PATCH] Eliminated SmallIntSet SmallIntSet is equivalent to BitvSet but with 8 times the memory overhead. There's no reason for it to exist. --- src/libextra/smallintmap.rs | 369 ------------------------------------ 1 file changed, 369 deletions(-) diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs index 47d7fca4076..bd78f41ddf5 100644 --- a/src/libextra/smallintmap.rs +++ b/src/libextra/smallintmap.rs @@ -15,8 +15,6 @@ #[allow(missing_doc)]; - -use std::cmp; use std::iterator::{Iterator, IteratorUtil, EnumerateIterator, FilterMapIterator, InvertIterator}; use std::uint; use std::util::replace; @@ -309,155 +307,6 @@ double_ended_iterator!(impl SmallIntMapMutIterator -> (uint, &'self mut T), get_ pub type SmallIntMapMutRevIterator<'self, T> = InvertIterator<(uint, &'self mut T), SmallIntMapMutIterator<'self, T>>; - -/// A set implemented on top of the SmallIntMap type. This set is always a set -/// of integers, and the space requirements are on the order of the highest -/// valued integer in the set. -pub struct SmallIntSet { - priv map: SmallIntMap<()> -} - -impl Container for SmallIntSet { - /// Return the number of elements in the map - fn len(&self) -> uint { - self.map.len() - } - - /// Return true if the map contains no elements - fn is_empty(&self) -> bool { self.len() == 0 } -} - -impl Mutable for SmallIntSet { - /// Clear the map, removing all key-value pairs. - fn clear(&mut self) { self.map.clear() } -} - -impl Set for SmallIntSet { - /// Return true if the set contains a value - fn contains(&self, value: &uint) -> bool { self.map.contains_key(value) } - - /// Return true if the set has no elements in common with `other`. - /// This is equivalent to checking for an empty uintersection. - fn is_disjoint(&self, other: &SmallIntSet) -> bool { - for self.each |v| { if other.contains(v) { return false } } - true - } - - /// Return true if the set is a subset of another - fn is_subset(&self, other: &SmallIntSet) -> bool { - for self.each |v| { if !other.contains(v) { return false } } - true - } - - /// Return true if the set is a superset of another - fn is_superset(&self, other: &SmallIntSet) -> bool { - other.is_subset(self) - } - - /// Visit the values representing the difference - fn difference(&self, other: &SmallIntSet, f: &fn(&uint) -> bool) -> bool { - self.each(|v| other.contains(v) || f(v)) - } - - /// Visit the values representing the symmetric difference - fn symmetric_difference(&self, - other: &SmallIntSet, - f: &fn(&uint) -> bool) -> bool { - let len = cmp::max(self.map.v.len() ,other.map.v.len()); - - for uint::range(0, len) |i| { - if self.contains(&i) ^ other.contains(&i) { - if !f(&i) { return false; } - } - } - return true; - } - - /// Visit the values representing the uintersection - fn intersection(&self, other: &SmallIntSet, f: &fn(&uint) -> bool) -> bool { - self.each(|v| !other.contains(v) || f(v)) - } - - /// Visit the values representing the union - fn union(&self, other: &SmallIntSet, f: &fn(&uint) -> bool) -> bool { - let len = cmp::max(self.map.v.len() ,other.map.v.len()); - - for uint::range(0, len) |i| { - if self.contains(&i) || other.contains(&i) { - if !f(&i) { return false; } - } - } - return true; - } -} - -impl MutableSet for SmallIntSet { - /// Add a value to the set. Return true if the value was not already - /// present in the set. - fn insert(&mut self, value: uint) -> bool { self.map.insert(value, ()) } - - /// Remove a value from the set. Return true if the value was - /// present in the set. - fn remove(&mut self, value: &uint) -> bool { self.map.remove(value) } -} - -impl SmallIntSet { - /// Create an empty SmallIntSet - pub fn new() -> SmallIntSet { SmallIntSet{map: SmallIntMap::new()} } - - /// Visit all values in order - pub fn each(&self, f: &fn(&uint) -> bool) -> bool { self.map.each_key(f) } - - /// An iterator visiting all set members in ascending order. - /// Iterator element type is uint - pub fn iter<'r>(&'r self) -> SmallIntSetIterator<'r> { - SmallIntSetIterator { - iter: self.map.iter() - } - } - - /// An iterator visiting all set members in descending order. - /// Iterator element type is uint - pub fn rev_iter<'r>(&'r mut self) -> SmallIntSetRevIterator<'r> { - self.iter().invert() - } - -} - -pub struct SmallIntSetIterator<'self> { - priv iter: SmallIntMapIterator<'self, ()> -} - -impl<'self> Iterator for SmallIntSetIterator<'self> { - #[inline] - fn next(&mut self) -> Option { - let next_opt = self.iter.next(); - match next_opt { - None => { None } - Some((idx, _)) => { Some(idx) } - } - } - - #[inline] - fn size_hint(&self) -> (uint, Option) { - self.iter.size_hint() - } -} - -impl<'self> DoubleEndedIterator for SmallIntSetIterator<'self> { - #[inline] - fn next_back(&mut self) -> Option { - let next_opt = self.iter.next_back(); - match next_opt { - None => { None } - Some((idx, _)) => { Some(idx) } - } - } -} - -pub type SmallIntSetRevIterator<'self> = InvertIterator>; - - #[cfg(test)] mod test_map { @@ -732,221 +581,3 @@ mod bench { find_seq_n(10_000, &mut m, bh); } } - -#[cfg(test)] -mod test_set { - - use super::SmallIntSet; - - #[test] - fn test_disjoint() { - let mut xs = SmallIntSet::new(); - let mut ys = SmallIntSet::new(); - assert!(xs.is_disjoint(&ys)); - assert!(ys.is_disjoint(&xs)); - assert!(xs.insert(5)); - assert!(ys.insert(11)); - assert!(xs.is_disjoint(&ys)); - assert!(ys.is_disjoint(&xs)); - assert!(xs.insert(7)); - assert!(xs.insert(19)); - assert!(xs.insert(4)); - assert!(ys.insert(2)); - assert!(xs.is_disjoint(&ys)); - assert!(ys.is_disjoint(&xs)); - assert!(ys.insert(7)); - assert!(!xs.is_disjoint(&ys)); - assert!(!ys.is_disjoint(&xs)); - } - - #[test] - fn test_subset_and_superset() { - let mut a = SmallIntSet::new(); - assert!(a.insert(0)); - assert!(a.insert(5)); - assert!(a.insert(11)); - assert!(a.insert(7)); - - let mut b = SmallIntSet::new(); - assert!(b.insert(0)); - assert!(b.insert(7)); - assert!(b.insert(19)); - assert!(b.insert(250)); - assert!(b.insert(11)); - assert!(b.insert(200)); - - assert!(!a.is_subset(&b)); - assert!(!a.is_superset(&b)); - assert!(!b.is_subset(&a)); - assert!(!b.is_superset(&a)); - - assert!(b.insert(5)); - - assert!(a.is_subset(&b)); - assert!(!a.is_superset(&b)); - assert!(!b.is_subset(&a)); - assert!(b.is_superset(&a)); - } - - #[test] - fn test_intersection() { - let mut a = SmallIntSet::new(); - let mut b = SmallIntSet::new(); - - assert!(a.insert(11)); - assert!(a.insert(1)); - assert!(a.insert(3)); - assert!(a.insert(77)); - assert!(a.insert(103)); - assert!(a.insert(5)); - - assert!(b.insert(2)); - assert!(b.insert(11)); - assert!(b.insert(77)); - assert!(b.insert(5)); - assert!(b.insert(3)); - - let mut i = 0; - let expected = [3, 5, 11, 77]; - for a.intersection(&b) |x| { - assert!(expected.contains(x)); - i += 1 - } - assert_eq!(i, expected.len()); - } - - #[test] - fn test_difference() { - let mut a = SmallIntSet::new(); - let mut b = SmallIntSet::new(); - - assert!(a.insert(1)); - assert!(a.insert(3)); - assert!(a.insert(5)); - assert!(a.insert(9)); - assert!(a.insert(11)); - - assert!(b.insert(3)); - assert!(b.insert(9)); - - let mut i = 0; - let expected = [1, 5, 11]; - for a.difference(&b) |x| { - assert!(expected.contains(x)); - i += 1 - } - assert_eq!(i, expected.len()); - } - - #[test] - fn test_symmetric_difference() { - let mut a = SmallIntSet::new(); - let mut b = SmallIntSet::new(); - - assert!(a.insert(1)); - assert!(a.insert(3)); - assert!(a.insert(5)); - assert!(a.insert(9)); - assert!(a.insert(11)); - - assert!(b.insert(3)); - assert!(b.insert(9)); - assert!(b.insert(14)); - assert!(b.insert(22)); - - let mut i = 0; - let expected = [1, 5, 11, 14, 22]; - for a.symmetric_difference(&b) |x| { - assert!(expected.contains(x)); - i += 1 - } - assert_eq!(i, expected.len()); - } - - #[test] - fn test_union() { - let mut a = SmallIntSet::new(); - let mut b = SmallIntSet::new(); - - assert!(a.insert(1)); - assert!(a.insert(3)); - assert!(a.insert(5)); - assert!(a.insert(9)); - assert!(a.insert(11)); - assert!(a.insert(16)); - assert!(a.insert(19)); - assert!(a.insert(24)); - - assert!(b.insert(1)); - assert!(b.insert(5)); - assert!(b.insert(9)); - assert!(b.insert(13)); - assert!(b.insert(19)); - - let mut i = 0; - let expected = [1, 3, 5, 9, 11, 13, 16, 19, 24]; - for a.union(&b) |x| { - assert!(expected.contains(x)); - i += 1 - } - assert_eq!(i, expected.len()); - } - - #[test] - fn test_iterator() { - let mut a = SmallIntSet::new(); - - assert!(a.insert(0)); - assert!(a.insert(1)); - assert!(a.insert(3)); - assert!(a.insert(6)); - assert!(a.insert(10)); - - let mut it = a.iter(); - assert_eq!(it.size_hint(), (0, Some(11))); - assert_eq!(it.next().unwrap(), 0); - assert_eq!(it.size_hint(), (0, Some(10))); - assert_eq!(it.next().unwrap(), 1); - assert_eq!(it.size_hint(), (0, Some(9))); - assert_eq!(it.next().unwrap(), 3); - assert_eq!(it.size_hint(), (0, Some(7))); - assert_eq!(it.next().unwrap(), 6); - assert_eq!(it.size_hint(), (0, Some(4))); - assert_eq!(it.next().unwrap(), 10); - assert_eq!(it.size_hint(), (0, Some(0))); - assert!(it.next().is_none()); - } - - #[test] - fn test_iterator_size_hints() { - let mut a = SmallIntSet::new(); - - assert!(a.insert(0)); - assert!(a.insert(1)); - assert!(a.insert(3)); - assert!(a.insert(6)); - assert!(a.insert(10)); - - assert_eq!(a.iter().size_hint(), (0, Some(11))); - assert_eq!(a.rev_iter().size_hint(), (0, Some(11))); - } - - #[test] - fn test_rev_iterator() { - let mut a = SmallIntSet::new(); - - assert!(a.insert(0)); - assert!(a.insert(1)); - assert!(a.insert(3)); - assert!(a.insert(6)); - assert!(a.insert(10)); - - let mut it = a.rev_iter(); - assert_eq!(it.next().unwrap(), 10); - assert_eq!(it.next().unwrap(), 6); - assert_eq!(it.next().unwrap(), 3); - assert_eq!(it.next().unwrap(), 1); - assert_eq!(it.next().unwrap(), 0); - assert!(it.next().is_none()); - } -}