Add is_subset() method to IntSet.

Author: garretrieger

read-fonts/src/collections/int_set/bitpage.rs

@@ -52,12 +52,30 @@ impl BitPage {
 
     /// Returns true if this page has any members in common with `other`.
     pub(crate) fn intersects_set(&self, other: &BitPage) -> bool {
-        for (a, b) in self.storage.iter().zip(other.storage.iter()) {
-            if (*a & *b) != 0 {
-                return true;
-            }
+        self.storage
+            .iter()
+            .zip(other.storage.iter())
+            .any(|(a, b)| (*a & *b) != 0)
+    }
+
+    /// Returns true if this page is a subset of `other`.
+    pub(crate) fn is_subset(&self, other: &BitPage) -> bool {
+        if self.len() > other.len() {
+            return false;
         }
-        false
+        self.storage
+            .iter()
+            .zip(other.storage.iter())
+            .all(|(a, b)| (*a & *b) == *a)
+    }
+
+    /// Returns the number of members present in both `self` and `other`.
+    pub(crate) fn intersection_len(&self, other: &BitPage) -> u32 {
+        self.storage
+            .iter()
+            .zip(other.storage.iter())
+            .map(|(a, b)| (*a & *b).count_ones())
+            .sum()
     }
 
     // TODO(garretrieger): iterator that starts after some value (similar to next in hb).
@@ -862,4 +880,60 @@ mod test {
 
         assert_intersects!(c, d, false);
     }
+
+    #[test]
+    fn is_subset() {
+        let a = BitPage::new_zeroes();
+        let b = BitPage::from_iter([32, 400]);
+        let c = BitPage::from_iter([32]);
+        let d = BitPage::from_iter([32, 200, 400]);
+        let e = BitPage::from_iter([32, 300]);
+        let f = BitPage::from_iter([32, 200, 300]);
+
+        assert!(a.is_subset(&a));
+        assert!(a.is_subset(&b));
+        assert!(a.is_subset(&c));
+        assert!(a.is_subset(&d));
+
+        // self subset check
+        assert!(b.is_subset(&b));
+        assert!(c.is_subset(&c));
+        assert!(d.is_subset(&d));
+        assert!(e.is_subset(&e));
+        assert!(f.is_subset(&f));
+
+        // is subset where len a < len b
+        assert!(c.is_subset(&b));
+        assert!(c.is_subset(&d));
+        assert!(b.is_subset(&d));
+
+        // Fails via len a > len b
+        assert!(!b.is_subset(&c));
+        assert!(!d.is_subset(&b));
+        assert!(!d.is_subset(&c));
+        assert!(!b.is_subset(&a));
+
+        // Fails via bitwise check (len a <= len b)
+        assert!(!b.is_subset(&e));
+        assert!(!e.is_subset(&b));
+        assert!(!b.is_subset(&f));
+    }
+
+    #[test]
+    fn intersection_len() {
+        let a = BitPage::new_zeroes();
+        let b = BitPage::from_iter([32, 400]);
+        let c = BitPage::from_iter([32, 200]);
+        let d = BitPage::from_iter([32]);
+
+        assert_eq!(a.intersection_len(&b), 0);
+        assert_eq!(b.intersection_len(&a), 0);
+
+        assert_eq!(b.intersection_len(&c), 1);
+        assert_eq!(c.intersection_len(&b), 1);
+        assert_eq!(b.intersection_len(&d), 1);
+        assert_eq!(d.intersection_len(&b), 1);
+
+        assert_eq!(b.intersection_len(&b), 2);
+    }
 }

read-fonts/src/collections/int_set/bitset.rs

@@ -269,6 +269,69 @@ impl U32Set {
         false
     }
 
+    /// Returns true if this set is a subset of `other`.
+    pub fn is_subset(&self, other: &U32Set) -> bool {
+        if self.len() > other.len() {
+            return false;
+        }
+        let mut it_b = other.page_map.iter().peekable();
+
+        for a_info in self.page_map.iter() {
+            let page_a = &self.pages[a_info.index as usize];
+            if page_a.is_empty() {
+                continue;
+            }
+
+            while let Some(b_info) = it_b.peek() {
+                if b_info.major_value < a_info.major_value {
+                    it_b.next();
+                } else {
+                    break;
+                }
+            }
+
+            match it_b.peek() {
+                Some(b_info) if b_info.major_value == a_info.major_value => {
+                    let page_b = &other.pages[b_info.index as usize];
+                    if !page_a.is_subset(page_b) {
+                        return false;
+                    }
+                    it_b.next();
+                }
+                _ => return false,
+            }
+        }
+
+        true
+    }
+
+    /// Returns the number of members present in both `self` and `other`.
+    pub fn intersection_len(&self, other: &U32Set) -> u64 {
+        let mut it_a = self.page_map.iter().peekable();
+        let mut it_b = other.page_map.iter().peekable();
+        let mut count = 0u64;
+
+        while let (Some(a), Some(b)) = (it_a.peek(), it_b.peek()) {
+            match a.major_value.cmp(&b.major_value) {
+                Ordering::Equal => {
+                    count += self.pages[a.index as usize]
+                        .intersection_len(&other.pages[b.index as usize])
+                        as u64;
+                    it_a.next();
+                    it_b.next();
+                }
+                Ordering::Less => {
+                    it_a.next();
+                }
+                Ordering::Greater => {
+                    it_b.next();
+                }
+            }
+        }
+
+        count
+    }
+
     pub const fn empty() -> U32Set {
         U32Set {
             pages: Vec::new(),
@@ -1530,4 +1593,59 @@ mod test {
 
         assert_intersects!(a, b, true);
     }
+
+    #[test]
+    fn is_subset() {
+        let empty = U32Set::empty();
+        let a = U32Set::from_iter([2, 4, 5, 2057, 7000]);
+        let b = U32Set::from_iter([2, 4, 5, 2057, 7000, 8000]);
+        let c = U32Set::from_iter([2, 4, 5]);
+        let d = U32Set::from_iter([2, 4, 6, 2057, 7000]); // same len as a, different element on page 0
+        let e = U32Set::from_iter([2, 4, 5, 3000, 7000]); // same len as a, different major page
+
+        assert!(empty.is_subset(&empty));
+        assert!(empty.is_subset(&a));
+        assert!(a.is_subset(&a));
+        assert!(a.is_subset(&b));
+        assert!(c.is_subset(&a));
+        assert!(c.is_subset(&b));
+
+        // Fails via length check:
+        assert!(!b.is_subset(&a));
+        assert!(!a.is_subset(&c));
+        assert!(!a.is_subset(&empty));
+
+        // Fails via bitwise check (same len):
+        assert!(!a.is_subset(&d));
+        assert!(!d.is_subset(&a));
+
+        // Fails via page matching check (different major page, same len):
+        assert!(!a.is_subset(&e));
+        assert!(!e.is_subset(&a));
+
+        // Test with empty pages present in self
+        let mut a_with_empty_page = U32Set::empty();
+        a_with_empty_page.insert(100);
+        a_with_empty_page.insert(2057);
+        a_with_empty_page.remove(100); // page for 100 remains in page_map but is empty
+        assert!(a_with_empty_page.is_subset(&b));
+    }
+
+    #[test]
+    fn intersection_len() {
+        let empty = U32Set::empty();
+        let a = U32Set::from_iter([2, 4, 5, 2057, 7000]);
+        let b = U32Set::from_iter([4, 5, 2057, 9000]);
+        let c = U32Set::from_iter([1, 3, 10000]);
+
+        assert_eq!(empty.intersection_len(&a), 0);
+        assert_eq!(a.intersection_len(&empty), 0);
+        assert_eq!(a.intersection_len(&a), 5);
+
+        assert_eq!(a.intersection_len(&b), 3);
+        assert_eq!(b.intersection_len(&a), 3);
+
+        assert_eq!(a.intersection_len(&c), 0);
+        assert_eq!(c.intersection_len(&a), 0);
+    }
 }

read-fonts/src/collections/int_set/mod.rs

@@ -394,6 +394,26 @@ impl<T: Domain> IntSet<T> {
         false
     }
 
+    /// Returns `true` if this set is a subset of `other`.
+    pub fn is_subset(&self, other: &IntSet<T>) -> bool {
+        if self.len() > other.len() {
+            return false;
+        }
+
+        match (&self.0, &other.0) {
+            (Membership::Inclusive(a), Membership::Inclusive(b)) => a.is_subset(b),
+            (Membership::Inclusive(a), Membership::Exclusive(b)) => !a.intersects_set(b),
+            (Membership::Exclusive(a), Membership::Inclusive(b)) => {
+                // For this (A) to be a subset of other (B):
+                // - All members of the domain T must be in either A, B, or both
+                // - So we check that A U B = T, which we can do by checking |A U B| = |T|
+                // - |A U B| is given by |A| + |B| - |A n B| (inclusion exclusion principle)
+                a.len() + b.len() - a.intersection_len(b) == T::count()
+            }
+            (Membership::Exclusive(a), Membership::Exclusive(b)) => b.is_subset(a),
+        }
+    }
+
     /// Returns first element in the set, if any. This element is always the minimum of all elements in the set.
     pub fn first(&self) -> Option<T> {
         return self.iter().next();
@@ -2521,6 +2541,83 @@ mod test {
         assert_intersects!(e, empty, false);
     }
 
+    #[test]
+    fn is_subset() {
+        let empty = IntSet::<u32>::empty();
+        let a = IntSet::from([1u32, 5, 6, 7, 8, 12]);
+        let b = IntSet::from([1u32, 5, 6, 7, 8, 12, 15]);
+        let c = IntSet::from([1u32, 5, 6, 7, 8, 13]);
+
+        // Inclusive - Inclusive
+        assert!(empty.is_subset(&empty));
+        assert!(empty.is_subset(&a));
+        assert!(!a.is_subset(&empty));
+
+        assert!(a.is_subset(&a));
+
+        assert!(a.is_subset(&b));
+        assert!(!b.is_subset(&a)); // Rejection via length check (7 > 6)
+
+        assert!(!a.is_subset(&c)); // Rejection via member check (6 <= 6)
+        assert!(!c.is_subset(&a));
+
+        // Inclusive - Exclusive
+        let mut all_but_13 = IntSet::<u32>::all();
+        all_but_13.remove(13);
+
+        let mut all_but_5 = IntSet::<u32>::all();
+        all_but_5.remove(5);
+
+        assert!(a.is_subset(&all_but_13)); // a doesn't contain 13
+        assert!(!a.is_subset(&all_but_5)); // a contains 5 which is excluded in excl_5
+        assert!(empty.is_subset(&all_but_13));
+
+        // Exclusive - Inclusive
+        let mut all_but_1 = IntSet::<u8>::all();
+        all_but_1.remove(1u8);
+
+        let mut all_but_1_2 = IntSet::<u8>::all();
+        all_but_1_2.remove(1u8);
+        all_but_1_2.remove(2u8);
+
+        let mut incl_all_but_1 = IntSet::<u8>::empty();
+        incl_all_but_1.insert_range(0u8..=255);
+        incl_all_but_1.remove(1u8);
+
+        let mut incl_all_but_3 = IntSet::<u8>::empty();
+        incl_all_but_3.insert_range(0u8..=255);
+        incl_all_but_3.remove(3u8);
+
+        let mut incl_all = IntSet::<u8>::empty();
+        incl_all.insert_range(0u8..=255);
+
+        assert!(all_but_1.is_subset(&incl_all));
+        assert!(all_but_1.is_subset(&incl_all_but_1));
+        assert!(all_but_1_2.is_subset(&incl_all_but_1));
+        assert!(!all_but_1.is_subset(&IntSet::<u8>::from([0u8, 2, 3]))); // Rejection via length check (255 > 3)
+        assert!(!all_but_1_2.is_subset(&incl_all_but_3)); // Rejection via member check (254 <= 255)
+
+        // Exclusive - Exclusive
+        let mut all_but_2_3 = IntSet::<u8>::all();
+        all_but_2_3.remove(2u8);
+        all_but_2_3.remove(3u8);
+
+        assert!(all_but_1_2.is_subset(&all_but_1));
+        assert!(!all_but_1.is_subset(&all_but_1_2)); // Rejection via length check (255 > 254)
+        assert!(!all_but_1_2.is_subset(&all_but_2_3)); // Rejection via member (254 <= 254)
+        assert!(IntSet::<u32>::all().is_subset(&IntSet::<u32>::all()));
+
+        // Discontinuous Domain
+        let even_empty = IntSet::<EvenInts>::empty();
+        let even_a = IntSet::from([EvenInts(2), EvenInts(4)]);
+        let even_b = IntSet::from([EvenInts(2), EvenInts(4), EvenInts(6)]);
+        let even_c = IntSet::from([EvenInts(2), EvenInts(6)]);
+        assert!(even_empty.is_subset(&even_a));
+        assert!(even_a.is_subset(&even_b));
+        assert!(!even_b.is_subset(&even_a)); // Rejection via length check (3 > 2)
+        assert!(!even_c.is_subset(&even_a)); // Rejection via member check (2 <= 2)
+    }
+
     #[test]
     fn intersects_range_discontinuous() {
         let mut set = IntSet::<EvenInts>::empty();