Esempio n. 1
0
def benchmark(nb_singletons=50, nb_elements=100):
    # Initialization (not measured).
    n = nb_singletons
    m = nb_elements

    engine = Engine()
    singletons = [[random.randint(0, m // 2) for _ in range(m)] for _ in range(n)]

    # Benchmark tests.
    benchmark_start = time.time()
    singleton_start = time.time()

    diagrams = [engine.make_from_container(singleton) for singleton in singletons]

    singleton_time = time.time() - singleton_start
    union_start = time.time()

    reduce(or_, diagrams)

    union_time = time.time() - union_start
    benchmark_time = time.time() - benchmark_start

    # Print results.
    print('{:<20} {}'.format('Total time:', benchmark_time))
    print('{:<20} {}'.format('Create singletons:', singleton_time))
    print('{:<20} {}'.format('Compute unions:', union_time))
Esempio n. 2
0
class TestDefaultEngine(unittest.TestCase):
    def setUp(self):
        self.engine = DefaultEngine()

    def test_make_terminal(self):
        self.assertTrue(self.engine.make_terminal(False).is_zero())
        self.assertTrue(self.engine.make_terminal(True).is_one())

    def test_make_node(self):
        zero = self.engine.make_terminal(False)
        one = self.engine.make_terminal(True)

        a = self.engine.make_node(1, one, zero)
        self.assertEqual(a.key, 1)
        self.assertEqual(a.then_, one)
        self.assertEqual(a.else_, zero)

        b = self.engine.make_node(0, one, a)
        self.assertEqual(b.key, 0)
        self.assertEqual(b.then_, one)
        self.assertEqual(b.else_, a)

    def test_make_from_container(self):
        self.assertTrue(self.engine.make(set()).is_one())
        self.assertTrue(self.engine.make([]).is_one())

        self.assertEqual(list(self.engine.make_from_container({-1, 1})), [{-1, 1}])
        self.assertEqual(list(self.engine.make_from_container([-1, 1])), [{-1, 1}])

        self.assertEqual(list(self.engine.make_from_container({-1, 1, 1})), [{-1, 1}])
        self.assertEqual(list(self.engine.make_from_container([-1, 1, 1])), [{-1, 1}])

        self.assertEqual(list(self.engine.make_from_container({-1, 1, 2})), [{-1, 1, 2}])
        self.assertEqual(list(self.engine.make_from_container([-1, 1, 2])), [{-1, 1, 2}])

    def test_make(self):
        zero = self.engine.make_terminal(False)
        one = self.engine.make_terminal(True)

        self.assertEqual(self.engine.make(), zero)
        self.assertEqual(self.engine.make(set()), one)
        self.assertEqual(list(self.engine.make({1, 2})), [{1, 2}])

        family = self.engine.make({4}, {4, 5}, {4, 6, 9})
        self.assertEqual(set(frozenset(el) for el in family), set(frozenset(el) for el in ({4}, {4, 5}, {4, 6, 9})))

        family = self.engine.make({4, 5}, {4, 5}, {4, 6, 9})
        self.assertEqual(set(frozenset(el) for el in family), set(frozenset(el) for el in ({4, 5}, {4, 6, 9})))

    def test_unicity(self):
        a = self.engine.make()
        b = self.engine.make()
        self.assertEqual(id(a), id(b))

        a = self.engine.make(set())
        b = self.engine.make(set())
        self.assertEqual(id(a), id(b))

        a = self.engine.make({1})
        b = self.engine.make({1})
        self.assertEqual(id(a), id(b))

        a = self.engine.make({-2, 0, 2})
        b = self.engine.make({2, -2, 0})
        self.assertEqual(id(a), id(b))

        a = self.engine.make({4, 5}, {4}, {4, 6, 9})
        b = self.engine.make({4}, {4, 6, 9}, {4, 5})
        self.assertEqual(id(a), id(b))

    def test_contains(self):
        family = self.engine.make_terminal(False)
        self.assertFalse(set() in family)

        family = self.engine.make_terminal(True)
        self.assertTrue(set() in family)
        self.assertFalse({1} in family)

        family = self.engine.make({1})
        self.assertTrue({1} in family)
        self.assertFalse(set() in family)
        self.assertFalse({2} in family)

        family = self.engine.make({1, 2}, {1, 3}, {4, 5})
        self.assertTrue({1, 2} in family)
        self.assertTrue({1, 3} in family)
        self.assertTrue({4, 5} in family)

        self.assertFalse(set() in family)
        self.assertFalse({1} in family)
        self.assertFalse({1, 5} in family)

    def test_iter(self):
        family = self.engine.make_terminal(False)
        self.assertEqual(list(family), [])

        family = self.engine.make_terminal(True)
        self.assertEqual(list(family), [set()])

        family = self.engine.make({1})
        self.assertEqual(list(family), [{1}])

        family = self.engine.make({1, 2})
        self.assertEqual(list(family), [{1, 2}])

        family = self.engine.make({4}, {4, 5}, {4, 6, 9})
        self.assertEqual(set(frozenset(el) for el in family), set(frozenset(el) for el in ({4}, {4, 5}, {4, 6, 9})))

    def test_len(self):
        self.assertEqual(len(self.engine.make_terminal(False)), 0)
        self.assertEqual(len(self.engine.make_terminal(True)), 1)
        self.assertEqual(len(self.engine.make({1, 2})), 1)
        self.assertEqual(len(self.engine.make({4}, {4, 5}, {4, 6, 9})), 3)

    def test_lt(self):
        zero = self.engine.make_terminal(False)
        one = self.engine.make_terminal(True)

        # Test the inclusion of the empty family.
        family = zero
        self.assertFalse(family < zero)
        self.assertTrue(family < one)
        self.assertTrue(family < self.engine.make([1, 2]))
        self.assertTrue(family < self.engine.make([4], [4, 5], [4, 6, 9]))

        # Test the inclusion of the familiy of empty set.
        family = one
        self.assertFalse(family < zero)
        self.assertFalse(family < one)
        self.assertFalse(family < self.engine.make([1, 2]))
        self.assertFalse(family < self.engine.make([4], [4, 5], [4, 6, 9]))

        # Test the inclusion of a family of a singleton.
        family = self.engine.make([4, 5])
        self.assertFalse(family < zero)
        self.assertFalse(family < one)
        self.assertFalse(family < self.engine.make([4, 5]))
        self.assertTrue(family < self.engine.make([4], [4, 5], [4, 6, 9]))

        # Test the inclusion of an arbitrary family.
        family = self.engine.make([4, 5], [4, 6, 9])
        self.assertFalse(family < zero)
        self.assertFalse(family < one)
        self.assertFalse(family < self.engine.make([4, 5], [4, 6, 9]))
        self.assertTrue(family < self.engine.make([4], [4, 5], [4, 6, 9]))

    def test_le(self):
        zero = self.engine.make_terminal(False)
        one = self.engine.make_terminal(True)

        # Test the inclusion of the empty family.
        family = zero
        self.assertTrue(family <= zero)
        self.assertTrue(family <= one)
        self.assertTrue(family <= self.engine.make([1, 2]))
        self.assertTrue(family <= self.engine.make([4], [4, 5], [4, 6, 9]))

        # Test the inclusion of the familiy of empty set.
        family = one
        self.assertFalse(family <= zero)
        self.assertTrue(family <= one)
        self.assertFalse(family <= self.engine.make([1, 2]))
        self.assertFalse(family <= self.engine.make([4], [4, 5], [4, 6, 9]))

        # Test the inclusion of a family of a singleton.
        family = self.engine.make([4, 5])
        self.assertFalse(family <= zero)
        self.assertFalse(family <= one)
        self.assertTrue(family <= self.engine.make([4, 5]))
        self.assertTrue(family <= self.engine.make([4], [4, 5], [4, 6, 9]))

        # Test the inclusion of an arbitrary family.
        family = self.engine.make([4, 5], [4, 6, 9])
        self.assertFalse(family <= zero)
        self.assertFalse(family <= one)
        self.assertTrue(family <= self.engine.make([4, 5], [4, 6, 9]))
        self.assertTrue(family <= self.engine.make([4], [4, 5], [4, 6, 9]))

    def test_union(self):
        # Test the union of families of empty set.
        eue = self.engine.make([]) | self.engine.make([])
        self.assertEqual(list(eue), [set()])

        # Test the union of identical families.
        family = self.engine.make({1, 3, 8})
        self.assertEqual(family | family, family)

        families = [
            # Test the union of families with overlapping elements.
            ({1, 3, 9}, {1, 3, 8}),
            ({1, 3, 8}, {1, 3, 9}),
            # Test the union of families with disjoint elements.
            ({1, 3, 9}, {0, 2, 4}),
            ({0, 2, 4}, {1, 3, 9}),
        ]

        for fa, fb in families:
            a = self.engine.make(fa)
            b = self.engine.make(fb)
            aub = a | b
            bua = b | a

            self.assertEqual(set(frozenset(el) for el in aub), set(frozenset(el) for el in (fa, fb)))
            self.assertEqual(aub, bua)

    def test_intersection(self):
        # Test the intersection of families of empty set.
        eie = self.engine.make([]) & self.engine.make([])
        self.assertEqual(list(eie), [set()])

        # Test the intersection of identical families.
        family = self.engine.make({1, 3, 8}, {0, 2, 4})
        self.assertEqual(family & family, family)

        # Test the intersection of overlapping families.
        families = [([{1, 3, 9}, {0, 2, 4}], [{1, 3, 9}, {5, 6, 7}]), ([{1, 3, 9}, {5, 6, 7}], [{1, 3, 9}, {0, 2, 4}])]

        for fa, fb in families:
            a = self.engine.make(*fa)
            b = self.engine.make(*fb)
            aib = a & b
            bia = b & a

            self.assertEqual(list(aib), [{1, 3, 9}])
            self.assertEqual(aib, bia)

        # Test the intersection of disjoint families.
        families = [([{1, 3, 9}, {0, 2, 4}], [{1, 3, 0}, {5, 6, 7}]), ([{1, 3, 0}, {5, 6, 7}], [{1, 3, 9}, {0, 2, 4}])]

        for fa, fb in families:
            a = self.engine.make(*fa)
            b = self.engine.make(*fb)
            aib = a & b
            bia = b & a

            self.assertEqual(list(aib), [])
            self.assertEqual(aib, bia)

    def test_difference(self):
        # Test the difference between 2 families of empty set.
        ede = self.engine.make([]) - self.engine.make([])
        self.assertEqual(list(ede), [])

        # Test the difference between identical families.
        family = self.engine.make({1, 3, 8}, {0, 2, 4})
        self.assertEqual(list(family - family), [])

        # Test the difference between overlapping families.
        a = self.engine.make({1, 3, 9}, {0, 2, 4})
        b = self.engine.make({1, 3, 9}, {5, 6, 7})
        self.assertEqual(list(a - b), [{0, 2, 4}])

        # Test the difference between disjoint families.
        a = self.engine.make({1, 3, 9}, {0, 2, 4})
        b = self.engine.make({1, 3, 0}, {5, 6, 7})
        self.assertEqual(set(frozenset(el) for el in (a - b)), set([frozenset({1, 3, 9}), frozenset({0, 2, 4})]))

    def test_symmetric_difference(self):
        # Test the symmetric difference between 2 families of empty set.
        ede = self.engine.make([]) ^ self.engine.make([])
        self.assertEqual(list(ede), [])

        # Test the symmetric difference between identical families.
        family = self.engine.make({1, 3, 8}, {0, 2, 4})
        self.assertEqual(list(family ^ family), [])

        # Test the difference between overlapping families.
        a = self.engine.make({1, 3, 9}, {0, 2, 4})
        b = self.engine.make({1, 3, 9}, {5, 6, 7})
        self.assertEqual(set(frozenset(el) for el in (a ^ b)), set([frozenset({0, 2, 4}), frozenset({5, 6, 7})]))

        # Test the difference between disjoint families.
        a = self.engine.make({1, 3, 9}, {0, 2, 4})
        b = self.engine.make({1, 3, 0}, {5, 6, 7})
        self.assertEqual(
            set(frozenset(el) for el in (a ^ b)),
            set(frozenset(el) for el in [{1, 3, 9}, {0, 2, 4}, {1, 3, 0}, {5, 6, 7}]),
        )