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))
def setUp(self):
self.engine = DefaultEngine()
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}]),
)
