def test_simple_operations(self):
result = union(_multiset1, _multiset2)
self.assertEqual(result, Multiset(_collections.Counter("badog")))
result = add(_multiset1, _multiset2)
self.assertEqual(result, _multiset3)
result = intersect(_multiset1, _multiset2)
self.assertEqual(result, Multiset(_collections.Counter("d")))
result = minus(_multiset_magic, _multiset1)
self.assertEqual(result, Multiset(_collections.Counter("racaabra")))
p1 = Multiset(_collections.Counter("aaa"))
p2 = Multiset(_collections.Counter("bbb"))
p3 = Multiset(_collections.Counter("ccc"))
combined = Set({p1, p2, p3})
result = big_union(combined)
self.assertEqual(result, Multiset(_collections.Counter("abc" * 3)))
result = big_intersect(
Set({
_multiset_magic,
Multiset(_collections.Counter("abc" * 3)),
Multiset("a", "a", "b", "c")
}))
self.assertEqual(result, Multiset(_collections.Counter("aabc")))
def test_membership(self):
self.assertTrue(is_member(Multiset()))
self.assertTrue(is_member(Multiset(3)))
self.assertFalse(is_member(Atom(3)))
self.assertTrue(is_absolute_member(Multiset(3)))
self.assertFalse(is_absolute_member(Multiset(Couplet(3, 4))))
self.assertRaises(AttributeError, lambda: is_member(3))
def test_basic_multiset(self):
m = Multiset(_collections.Counter({'a': 2, 'b': 1}))
self.assertEqual(m.cardinality, 3)
m_repr = repr(m)
m_str = str(m)
self.assertEqual(m_repr, "Multiset({Atom('a'): 2, Atom('b'): 1})")
self.assertEqual(m_str, "['a':2, 'b':1]")
self.assertEqual(m.get_multiplicity(Atom('a')), 2)
self.assertEqual(m.get_multiplicity(Atom('b')), 1)
m_struct = m.get_ground_set()
self.assertEqual(m_struct, _atom_multiset_struct)
single_m = Multiset(Set([1, 2, 3, 4]), direct_load=True)
self.assertEqual(single_m.cardinality, 1)
self.assertEqual(repr(single_m), """Multiset({Set(Atom(1), Atom(2), Atom(3), Atom(4)): 1})""")
self.assertEqual(str(single_m), "[{1, 2, 3, 4}:1]")
empty_m = Multiset()
self.assertEqual(empty_m.cardinality, 0)
self.assertEqual(repr(empty_m), "Multiset({})")
self.assertEqual(str(empty_m), "[]")
for element in m:
self.assertTrue(isinstance(element, Atom))
def test_diag(self):
"""Basic tests of multiclans.diag()."""
clan1 = Multiset(Set(Couplet('a'), Couplet('b')))
self.assertEqual(diag('a', 'b'), clan1)
self.assertEqual(diag(), Multiset(Set()))
self.assertIs(diag(Undef()), Undef())
self.assertIs(diag(Undef(), _checked=False), Undef())
def test_membership(self):
self.assertTrue(is_member(Multiset(Set(Couplet(1, 2)))))
self.assertFalse(is_member(Multiset(Couplet(3, 4))))
self.assertTrue(is_absolute_member(Multiset(Set(Couplet(1, 2)))))
self.assertFalse(
is_absolute_member(Multiset(Set(Couplet(Set(2, 3), 4)))))
self.assertFalse(is_absolute_member(Set(2, 3)))
# noinspection PyTypeChecker
self.assertRaises(AttributeError, lambda: is_member(3))
def test_multify(self):
self._check_argument_types_unary_undef(multify)
letters = [l for l in "abracadabra"]
self.assertIs(multify(Multiset(letters)), Undef())
multiset = multify(Set(letters)) # Set object drops duplicates
self.assertTrue(isinstance(multiset, Multiset))
self.assertEqual(multiset.cardinality, 5) # multiset of unique items
letters = [l for l in "abrcd"]
self.assertEqual(multiset, Multiset(letters))
def test_binary_multi_extend_errors(self):
self.assertRaises(
AttributeError,
lambda: extension.binary_multi_extend(1, 2, sets.union))
self.assertRaises(
AttributeError,
lambda: extension.binary_multi_extend(Multiset(1), 2, sets.union))
self.assertRaises(
AttributeError,
lambda: extension.binary_multi_extend(1, Multiset(2), sets.union))
def test_intersect(self):
self._check_wrong_argument_types_binary(intersect)
result = intersect(_set1, _set2)
self.assertEqual(result, _set1i2)
a_c_0 = Multiset(
[Multiset('a'),
Multiset('a'),
Multiset('c'),
Multiset()])
ci = extension.binary_multi_extend(_ab_c, _ac_a, intersect)
self.assertEqual(ci, a_c_0)
def test_membership(self):
s = Multiset({"a": 2, "b": 1})
self.assertTrue(Atom("a") in s)
self.assertTrue("a" in s)
self.assertTrue("b" in s)
self.assertFalse("c" in s)
self.assertTrue(s.has_element(Atom("a")))
self.assertFalse(s.has_element(Atom("c")))
test_list = [Atom("a"), Atom("a"), Atom("b")]
multiset_iter = iter(s)
for i in range(len(test_list)):
self.assertEqual(test_list[i], next(multiset_iter))
def test_membership(self):
s = Multiset({'a': 2, 'b': 1})
self.assertTrue(Atom('a') in s)
self.assertTrue('a' in s)
self.assertTrue('b' in s)
self.assertFalse('c' in s)
self.assertTrue(s.has_element(Atom('a')))
self.assertFalse(s.has_element(Atom('c')))
test_list = [Atom('a'), Atom('a'), Atom('b')]
multiset_iter = iter(s)
for i in range(len(test_list)):
self.assertEqual(test_list[i], next(multiset_iter))
def test_membership(self):
s = Multiset({'a': 2, 'b': 1})
self.assertTrue(Atom('a') in s)
self.assertTrue('a' in s)
self.assertTrue('b' in s)
self.assertFalse('c' in s)
self.assertTrue(s.has_element(Atom('a')))
self.assertFalse(s.has_element(Atom('c')))
test_list = [Atom('a'), Atom('a'), Atom('b')]
multiset_iter = iter(s)
for i in multiset_iter:
self.assertTrue(i in test_list)
test_list.remove(i)
def test_membership(self):
s = Multiset({'a': 2, 'b': 1})
self.assertTrue(Atom('a') in s)
self.assertTrue('a' in s)
self.assertTrue('b' in s)
self.assertFalse('c' in s)
self.assertTrue(s.has_element(Atom('a')))
self.assertFalse(s.has_element(Atom('c')))
test_list = [Atom('a'), Atom('a'), Atom('b')]
multiset_iter = iter(s)
for i in multiset_iter:
self.assertTrue(i in test_list)
test_list.remove(i)
def test_union(self):
self._check_wrong_argument_types_binary(union)
result = union(_set1, _set2)
self.assertEqual(result, _set1u2)
abc_ab_ac = Multiset([
Multiset('a', 'b', 'c'),
Multiset('a', 'b'),
Multiset('a', 'c'),
Multiset('a', 'c')
])
ab_c = _ab_c
ac_a = _ac_a
cu = extension.binary_multi_extend(ab_c, ac_a, union)
self.assertEqual(cu, abc_ab_ac)
def test_project(self):
"""Basic tests of multiclans.project()."""
self.assertIs(project(Undef(), Undef()), Undef())
c1 = ac['clan1']
self.assertIs(project(c1, Undef()), Undef())
c2 = Multiset(Set(Couplet('a', 1)), Set(Couplet('a', 4)))
self.assertEqual(project(c1, 'a'), c2)
def test_superstrict(self):
"""Basic tests of clans.superstrict()."""
self._check_wrong_argument_types_binary(superstrict)
# Superstriction.
result = superstrict(ac['clan1'], ac['clan2'])
self.assertEqual(result, Multiset())
result = superstrict(ac['clan1'], ac['clan3'])
self.assertEqual(result, ac['clan1subsupstr3'])
def _check_wrong_argument_types_binary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3, 4))
self.assertRaises(AttributeError,
lambda: operation(Multiset(Set(Couplet(1, 2))), 3))
self.assertIs(operation(Atom(3), Atom(4)), Undef())
self.assertIs(operation(Multiset(Set(Couplet(1, 2))), Atom(3)),
Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException,
lambda: operation(Couplet(1, 2), Couplet(3, 4)))
RaiseOnUndef.reset()
c = ac['clan1']
self.assertIs(operation(c, Undef()), Undef())
self.assertIs(operation(c, Undef(), _checked=False), Undef())
self.assertIs(operation(Undef(), c), Undef())
self.assertIs(operation(Undef(), c, _checked=False), Undef())
def test_demultify(self):
letters = [l for l in "abracadabra"]
self.assertIs(demultify(Set(letters)), Undef())
set1 = demultify(Multiset(letters))
self.assertTrue(isinstance(set1, Set))
self.assertEqual(set1.cardinality, 5) # set only unique letters
letters = [l for l in "abrcd"]
self.assertEqual(set1, Set(letters))
def test_multiset_with_one_empty_element(self):
m = Multiset(Set())
self.assertEqual(m.cardinality, 1)
m_repr = repr(m)
m_str = str(m)
self.assertEqual(m_repr, "Multiset({Set(): 1})")
self.assertEqual(m_str, "[{}:1]")
self.assertEqual(m.get_multiplicity(Set()), 1)
self.assertEqual(m.get_multiplicity(Atom('b')), 0)
m_struct = m.get_ground_set()
m_expected_struct = PowerSet(CartesianProduct(Structure(), GenesisSetN()))
self.assertEqual(m_struct, m_expected_struct)
import algebraixlib.algebras.multiclans as _multiclans
self.assertTrue(_multiclans.is_member(m))
self.assertTrue(_multiclans.is_absolute_member(m))
def test_multiset_with_one_empty_element(self):
m = Multiset(Set())
self.assertEqual(m.cardinality, 1)
m_repr = repr(m)
m_str = str(m)
self.assertEqual(m_repr, "Multiset({Set(): 1})")
self.assertEqual(m_str, "[{}:1]")
self.assertEqual(m.get_multiplicity(Set()), 1)
self.assertEqual(m.get_multiplicity(Atom('b')), 0)
m_struct = m.get_ground_set()
m_expected_struct = PowerSet(
CartesianProduct(Structure(), GenesisSetN()))
self.assertEqual(m_struct, m_expected_struct)
import algebraixlib.algebras.multiclans as _multiclans
self.assertTrue(_multiclans.is_member(m))
self.assertTrue(_multiclans.is_absolute_member(m))
def test_less_than(self):
for value_key1, atom1 in ba.items():
for value_key2, atom2 in ba.items():
self.assertNotEqual(atom1 < atom2, NotImplemented)
self.assertNotEqual(atom2 < atom1, NotImplemented)
if atom1 == atom2:
self.assertFalse(atom1 < atom2)
self.assertFalse(atom2 < atom1)
for mo in [Couplet(1, 2), Multiset(1, 2, 3), Set(1, 2, 3)]:
self.assertTrue(atom1 < mo)
def test_less_than(self):
for value_key1, set1 in basic_sets.items():
for value_key2, set2 in basic_sets.items():
self.assertNotEqual(set1 < set2, NotImplemented)
self.assertNotEqual(set2 < set1, NotImplemented)
if set1 == set2:
self.assertFalse(set1 < set2)
self.assertFalse(set2 < set1)
for mo in [Atom(1), Couplet(1, 2), Multiset(1, 2, 3)]:
self.assertTrue(mo < set1)
def _check_wrong_argument_types_unary(self, operation):
"""Negative tests for set algebra unary operations."""
self.assertIs(operation(Atom(3)), Undef())
self.assertIs(operation(Set(Atom(3))), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3)))
self.assertRaises(UndefException, lambda: operation(Multiset(Atom(3))))
RaiseOnUndef.reset()
self.assertIs(operation(Undef()), Undef())
self.assertIs(operation(Undef(), _checked=False), Undef())
def test_less_than(self):
for value_key1, cp1 in basic_couplets.items():
for value_key2, cp2 in basic_couplets.items():
self.assertNotEqual(cp1 < cp2, NotImplemented)
self.assertNotEqual(cp2 < cp1, NotImplemented)
if cp1 == cp2:
self.assertFalse(cp1 < cp2)
self.assertFalse(cp2 < cp1)
for mo in [Atom(1)]:
self.assertTrue(mo < cp1)
for mo in [Multiset(1, 2, 3), Set(1, 2, 3)]:
self.assertTrue(cp1 < mo)
def test_basic_multiset(self):
m = Multiset(_collections.Counter({'a': 2, 'b': 1}))
self.assertEqual(m.cardinality, 3)
m_repr = repr(m)
m_str = str(m)
self.assertEqual(m_repr, "Multiset({Atom('a'): 2, Atom('b'): 1})")
self.assertEqual(m_str, "['a':2, 'b':1]")
self.assertEqual(m.get_multiplicity(Atom('a')), 2)
self.assertEqual(m.get_multiplicity(Atom('b')), 1)
m_struct = m.get_ground_set()
self.assertEqual(m_struct, _atom_multiset_struct)
single_m = Multiset(Set([1, 2, 3, 4]), direct_load=True)
self.assertEqual(single_m.cardinality, 1)
self.assertEqual(
repr(single_m),
"Multiset({Set(Atom(1), Atom(2), Atom(3), Atom(4)): 1})")
self.assertEqual(str(single_m), "[{1, 2, 3, 4}:1]")
empty_m = Multiset()
self.assertEqual(empty_m.cardinality, 0)
self.assertEqual(repr(empty_m), "Multiset({})")
self.assertEqual(str(empty_m), "[]")
for element in m:
self.assertTrue(isinstance(element, Atom))
def test_getitem(self):
self.assertEqual(Multiset()['callable'], Multiset())
# Creating multiclans (multisets of relations)
multiset1 = Multiset({Couplet('b', 'w'): 2, Couplet('b', 'y'): 3})
multiset2 = Multiset({Couplet('a', 'x'): 5, Couplet('x', 'y'): 1})
right_values1 = multiset1[Atom('b')]
self.assertEqual(right_values1, Multiset({Atom('w'): 2, Atom('y'): 3}))
right_values2 = multiset2[Atom('b')]
self.assertEqual(right_values2, Multiset())
def _check_wrong_argument_types_binary(self, operation):
"""Negative tests for set algebra binary operations."""
self.assertRaises(AttributeError,
lambda: operation(3, Multiset(Atom(3))))
self.assertIs(operation(Atom(3), Multiset(Atom(4))), Undef())
self.assertRaises(TypeError, lambda: operation(Multiset(Atom(3), 4)))
self.assertIs(operation(Multiset(Atom(3)), Atom(4)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException,
lambda: operation(Atom(3), Multiset(Atom(4))))
self.assertRaises(UndefException,
lambda: operation(Multiset(Atom(3)), Atom(4)))
RaiseOnUndef.reset()
self.assertIs(operation(_set1, Undef()), Undef())
self.assertIs(operation(_set1, Undef(), _checked=False), Undef())
self.assertIs(operation(Undef(), _set1), Undef())
self.assertIs(operation(Undef(), _set1, _checked=False), Undef())
'empty': [],
'num in dict': {Atom(1), Atom(2), Atom(3)},
'str in array': [Atom(el) for el in 'abc'],
'single num': 1,
'single Coupl': Couplet(right='a', left='b'),
'left func': [Couplet(l, r) for l, r in zip('abc', [1, 2, 3])],
'left func/lefts': ['a', 'b', 'c'],
'left func/rights': [1, 2, 3],
'not left func': [Couplet(s, c) for s, c in zip('abca', [1, 2, 3, 4])],
'not right func': [Couplet(s, c) for s, c in zip('abcd', [1, 2, 3, 1])],
'diagonal': [Couplet(s, s) for s in 'abc']
}.items()}
_print_object_collection('basic_sets')
#: Basic Multiset instances.
basic_multisets = {key: _create_test_object(Multiset(val), key, val) for key, val in {
'empty': [],
'dict': dict([('a', 3), ('b', 2), ('c', 5)]),
'num in dict': {Atom(1), Atom(2), Atom(3)},
'str in array': [Atom(el) for el in 'abc'],
'single alpha': 'A'
}.items()}
_print_object_collection('basic_multisets')
#: Relation instances for testing the relation algebra.
algebra_relations = {key: _create_test_object(val, key) for key, val in {
'rel1': Set([Couplet('a', 1), Couplet('b', 2), Couplet('c', 3)]),
'rel1/lefts': Set('a', 'b', 'c'),
'rel1/rights': Set([1, 2, 3]),
'rel2': Set([Couplet('x', 'a'), Couplet('zzz', 'zzz'), Couplet('y', 'c')]),
'rel2/lefts': Set(['x', 'zzz', 'y']),
class OperationsTests(unittest.TestCase):
_print_examples = False
def test_diagonal(self):
base_set = Set(Atom(1))
diag_rels = [relations.diag(*base_set), relations.diag(1)]
for diag_rel in diag_rels:
self.assertEqual(diag_rel.cardinality, 1)
self.assertTrue(relations.is_member(diag_rel))
self.assertTrue(diag_rel.has_element(Couplet(1, 1)))
base_set = Set(Atom(1), Atom('a'))
diag_clan = clans.diag(1, 'a')
self.assertEqual(diag_clan.cardinality, 1)
diag_rels = [
relations.diag(*base_set),
relations.diag(1, 'a'),
sets.single(diag_clan)
]
for diag_rel in diag_rels:
self.assertEqual(diag_rel.cardinality, 2)
self.assertTrue(relations.is_member(diag_rel))
self.assertTrue(diag_rel.has_element(Couplet(1, 1)))
self.assertTrue(diag_rel.has_element(Couplet('a', 'a')))
arg1 = Set(1, 2, 3)
arg2 = [v for v in Set(1, 2, 3)]
result_diag = Set(Couplet(1, 1), Couplet(2, 2), Couplet(3, 3))
self.assertEqual(relations.diag(*arg1), result_diag)
self.assertEqual(relations.diag(*arg2), result_diag)
test_set1 = {
"input":
Set([
Couplet(1, '1'),
Couplet(2, '2'),
Couplet(3, '3'),
Couplet(4, '4'),
Couplet(5, '5')
]),
"even_part":
Set([
Set([Couplet(2, '2'), Couplet(4, '4')]),
Set([Couplet(1, '1'),
Couplet(3, '3'),
Couplet(5, '5')])
]),
"even_part_equiv":
Set([
Couplet(Atom(True), Set([Couplet(2, '2'),
Couplet(4, '4')])),
Couplet(Atom(False),
Set([Couplet(1, '1'),
Couplet(3, '3'),
Couplet(5, '5')]))
]),
"input2":
Set([
Couplet(1, '1'),
Couplet(2, '2'),
Couplet(3, '3'),
Couplet(4, '4'),
Couplet(5, '5'),
Couplet(6, '6'),
Couplet(7, '7'),
Couplet(8, '8'),
Couplet(9, '9'),
Couplet(10, '10'),
Couplet(11, '11'),
Couplet(12, '12'),
Couplet(13, '13'),
Couplet(14, '14'),
Couplet(15, '15')
]),
"thirds_part":
Set([
Set([
Couplet(1, '1'),
Couplet(4, '4'),
Couplet(7, '7'),
Couplet(10, '10'),
Couplet(13, '13')
]),
Set([
Couplet(2, '2'),
Couplet(5, '5'),
Couplet(8, '8'),
Couplet(11, '11'),
Couplet(14, '14')
]),
Set([
Couplet(3, '3'),
Couplet(6, '6'),
Couplet(9, '9'),
Couplet(12, '12'),
Couplet(15, '15')
])
])
}
def test_partition(self):
test_set = OperationsTests.test_set1
even_part = partition.partition(test_set["input"],
lambda elem: elem.left.value % 2 == 0)
self.assertEqual(even_part, test_set["even_part"])
if OperationsTests._print_examples:
print("Even partition Actual: ", even_part)
print("Even partition Expected:", test_set["even_part"])
thirds_part = partition.partition(test_set["input2"],
lambda elem: elem.left.value % 3)
self.assertEqual(thirds_part, test_set["thirds_part"])
if OperationsTests._print_examples:
print("Thirds partition Actual: ", thirds_part)
print("Thirds partition Expected:", test_set["thirds_part"])
even_part_equiv = partition.make_labeled_partition(
test_set["input"], lambda elem: elem.left.value % 2 == 0)
self.assertEqual(even_part_equiv, test_set["even_part_equiv"])
if OperationsTests._print_examples:
print(even_part_equiv)
# Negative test, returning something that can not be put inside an atom
my_equiv_rel_fun = lambda elem: "even" if elem.left.value % 2 == 0 else Undef(
)
self.assertRaises(
TypeError,
lambda: partition.partition(test_set["input2"], my_equiv_rel_fun))
my_left_eq_rel_fn = lambda: partition.make_labeled_partition(
test_set["input2"], my_equiv_rel_fun)
self.assertRaises(TypeError, my_left_eq_rel_fn)
test_set2 = {
"input":
Multiset(
Counter({
Couplet(1, '1'): 1,
Couplet(2, '2'): 2,
Couplet(3, '3'): 3,
Couplet(4, '4'): 4,
Couplet(5, '5'): 5
})),
"even_part":
Set([
Multiset(Counter({
Couplet(2, '2'): 2,
Couplet(4, '4'): 4
})),
Multiset(
Counter({
Couplet(1, '1'): 1,
Couplet(3, '3'): 3,
Couplet(5, '5'): 5
}))
]),
"even_part_equiv":
Set([
Couplet(
Atom(True),
Multiset(Counter({
Couplet(2, '2'): 2,
Couplet(4, '4'): 4
}))),
Couplet(
Atom(False),
Multiset(
Counter({
Couplet(1, '1'): 1,
Couplet(3, '3'): 3,
Couplet(5, '5'): 5
})))
]),
"input2":
Multiset(
Counter({
Couplet(1, '1'): 1,
Couplet(2, '2'): 2,
Couplet(3, '3'): 3,
Couplet(4, '4'): 4,
Couplet(5, '5'): 5,
Couplet(6, '6'): 6,
Couplet(7, '7'): 7,
Couplet(8, '8'): 8,
Couplet(9, '9'): 9,
Couplet(10, '10'): 10,
Couplet(11, '11'): 11,
Couplet(12, '12'): 12,
Couplet(13, '13'): 13,
Couplet(14, '14'): 14,
Couplet(15, '15'): 15
})),
"thirds_part":
Set([
Multiset(
Counter({
Couplet(1, '1'): 1,
Couplet(4, '4'): 4,
Couplet(7, '7'): 7,
Couplet(10, '10'): 10,
Couplet(13, '13'): 13
})),
Multiset(
Counter({
Couplet(2, '2'): 2,
Couplet(5, '5'): 5,
Couplet(8, '8'): 8,
Couplet(11, '11'): 11,
Couplet(14, '14'): 14
})),
Multiset(
Counter({
Couplet(3, '3'): 3,
Couplet(6, '6'): 6,
Couplet(9, '9'): 9,
Couplet(12, '12'): 12,
Couplet(15, '15'): 15
}))
])
}
def test_partition_multiset(self):
test_set = OperationsTests.test_set2
even_part = partition.partition(test_set["input"],
lambda elem: elem.left.value % 2 == 0)
self.assertEqual(even_part, test_set["even_part"])
if OperationsTests._print_examples:
print("Even partition (msets) Actual: ", even_part)
print("Even partition (msets) Expected:", test_set["even_part"])
thirds_part = partition.partition(test_set["input2"],
lambda elem: elem.left.value % 3)
self.assertEqual(thirds_part, test_set["thirds_part"])
if OperationsTests._print_examples:
print("Thirds partition (msets) Actual: ", thirds_part)
print("Thirds partition (msets) Expected:",
test_set["thirds_part"])
even_part_equiv = partition.make_labeled_partition(
test_set["input"], lambda elem: elem.left.value % 2 == 0)
self.assertEqual(even_part_equiv, test_set["even_part_equiv"])
if OperationsTests._print_examples:
print(even_part_equiv)
# Negative test, returning something that can not be put inside an atom
my_equiv_rel_fun = lambda elem: "even" if elem.left.value % 2 == 0 else Undef(
)
self.assertRaises(
TypeError,
lambda: partition.partition(test_set["input2"], my_equiv_rel_fun))
my_left_eq_rel_fn = lambda: partition.make_labeled_partition(
test_set["input2"], my_equiv_rel_fun)
self.assertRaises(TypeError, my_left_eq_rel_fn)
def test_unary_extend(self):
"""Verify that unary extend uses the input set and operation to invoke the equivalent
operation in next higher power set."""
self.assertEqual(Set(Set(Couplet(1, 1))),
extension.unary_extend(Set(*Set(1)), relations.diag))
def test_unary_extend_errors(self):
self.assertRaises(AttributeError,
lambda: extension.unary_extend(1, sets.big_union))
def test_binary_extend_errors(self):
self.assertRaises(AttributeError,
lambda: extension.binary_extend(1, 2, sets.union))
self.assertRaises(
AttributeError,
lambda: extension.binary_extend(Set(1), 2, sets.union))
self.assertRaises(
AttributeError,
lambda: extension.binary_extend(1, Set(2), sets.union))
def test_binary_multi_extend_errors(self):
self.assertRaises(
AttributeError,
lambda: extension.binary_multi_extend(1, 2, sets.union))
self.assertRaises(
AttributeError,
lambda: extension.binary_multi_extend(Multiset(1), 2, sets.union))
self.assertRaises(
AttributeError,
lambda: extension.binary_multi_extend(1, Multiset(2), sets.union))
def test_some(self):
# self._check_wrong_argument_types_unary(some)
self.assertIs(some(Undef()), Undef())
self.assertIs(some(Multiset()), Undef())
self.assertEqual(some(_set1m2), Atom('a'))
self.assertTrue(some(_set1) in _set1)
def test_flags_empty_set(self):
s = Multiset()
self.assertEqual(s.cached_relation, CacheStatus.IS_NOT)
self.assertEqual(s.cached_clan, CacheStatus.IS_NOT)
self.assertEqual(s.cached_multiclan, CacheStatus.IS)
self.assertEqual(s.cached_functional, CacheStatus.IS)
self.assertEqual(s.cached_right_functional, CacheStatus.IS)
self.assertEqual(s.cached_regular, CacheStatus.IS)
self.assertEqual(s.cached_reflexive, CacheStatus.IS)
self.assertEqual(s.cached_symmetric, CacheStatus.IS)
self.assertEqual(s.cached_transitive, CacheStatus.IS)
self.assertRaises(AssertionError,
lambda: s.cache_relation(CacheStatus.IS))
self.assertRaises(AssertionError, lambda: s.cache_clan(CacheStatus.IS))
self.assertRaises(AssertionError,
lambda: s.cache_multiclan(CacheStatus.IS_NOT))
s.cache_multiclan(CacheStatus.IS)
self.assertRaises(Exception,
lambda: s.cache_transitive(CacheStatus.IS_NOT))
self.assertRaises(Exception,
lambda: s.cache_functional(CacheStatus.IS_NOT))
self.assertRaises(Exception,
lambda: s.cache_right_functional(CacheStatus.IS_NOT))
self.assertRaises(Exception,
lambda: s.cache_regular(CacheStatus.IS_NOT))
self.assertRaises(Exception,
lambda: s.cache_reflexive(CacheStatus.IS_NOT))
self.assertRaises(Exception,
lambda: s.cache_symmetric(CacheStatus.IS_NOT))
self.assertRaises(Exception,
lambda: s.cache_transitive(CacheStatus.IS_NOT))
def test_invalid_constructs(self):
"""Test invalid Multisets."""
self.assertRaises(TypeError, lambda: Multiset(Undef()))
def test_from_dict(self):
"""Basic tests of multiclans.from_dict()."""
c1 = Multiset(Set(Couplet('a', 1), Couplet('b', 2)))
self.assertEqual(c1, from_dict({'a': 1, 'b': 2}))
self.assertRaises(AttributeError, lambda: from_dict(Undef()))
def test_get_rights(self):
"""Basic tests of clans.get_rights()."""
self._check_wrong_argument_type_unary(get_rights)
self.assertEqual(get_rights(Multiset()), Multiset())
def test_flags_empty_set(self):
s = Multiset()
self.assertEqual(s.cached_relation, CacheStatus.IS_NOT)
self.assertEqual(s.cached_clan, CacheStatus.IS_NOT)
self.assertEqual(s.cached_multiclan, CacheStatus.IS)
self.assertEqual(s.cached_functional, CacheStatus.IS)
self.assertEqual(s.cached_right_functional, CacheStatus.IS)
self.assertEqual(s.cached_regular, CacheStatus.IS)
self.assertEqual(s.cached_reflexive, CacheStatus.IS)
self.assertEqual(s.cached_symmetric, CacheStatus.IS)
self.assertEqual(s.cached_transitive, CacheStatus.IS)
self.assertRaises(AssertionError, lambda: s.cache_relation(CacheStatus.IS))
self.assertRaises(AssertionError, lambda: s.cache_clan(CacheStatus.IS))
self.assertRaises(AssertionError, lambda: s.cache_multiclan(CacheStatus.IS_NOT))
s.cache_multiclan(CacheStatus.IS)
self.assertRaises(Exception, lambda: s.cache_transitive(CacheStatus.IS_NOT))
self.assertRaises(Exception, lambda: s.cache_functional(CacheStatus.IS_NOT))
self.assertRaises(Exception, lambda: s.cache_right_functional(CacheStatus.IS_NOT))
self.assertRaises(Exception, lambda: s.cache_regular(CacheStatus.IS_NOT))
self.assertRaises(Exception, lambda: s.cache_reflexive(CacheStatus.IS_NOT))
self.assertRaises(Exception, lambda: s.cache_symmetric(CacheStatus.IS_NOT))
self.assertRaises(Exception, lambda: s.cache_transitive(CacheStatus.IS_NOT))
def test_csv(self):
"""Test loading clan from csv."""
clan = Set({Set({Couplet('a', '1'), Couplet('b', '2')})})
st1 = import_csv(IoCsvTests.path('set1.csv'))
self.assertEqual(clan, st1)
self.assertEqual(st1.cached_clan, CacheStatus.IS)
self.assertEqual(st1.cached_functional, CacheStatus.IS)
self.assertEqual(st1.cached_regular, CacheStatus.IS)
clan = Set({Set({Couplet('a', '1'), Couplet('b', '2')})})
st1a = import_csv(IoCsvTests.path('set1a.csv'))
# NOTE: duplicate row is removed
self.assertEqual(clan, st1a)
self.assertEqual(st1a.cached_clan, CacheStatus.IS)
self.assertEqual(st1a.cached_functional, CacheStatus.IS)
self.assertEqual(st1a.cached_regular, CacheStatus.IS)
clan = Set(
Set({Couplet('a', '1'),
Couplet('b', '2'),
Couplet('row', 0)}),
Set({Couplet('a', '1'),
Couplet('b', '2'),
Couplet('row', 1)}))
st1a = import_csv(IoCsvTests.path('set1a.csv'), index_column='row')
# NOTE: duplicate row is NOT removed
self.assertEqual(clan, st1a)
self.assertEqual(st1a.cached_clan, CacheStatus.IS)
self.assertEqual(st1a.cached_functional, CacheStatus.IS)
self.assertEqual(st1a.cached_regular, CacheStatus.IS)
expected = Multiset({Set(Couplet('a', '1'), Couplet('b', '2')): 2})
actual = import_csv(IoCsvTests.path('set1a.csv'), has_dup_rows=True)
# NOTE: duplicate row is not removed
self.assertEqual(actual, expected)
self.assertEqual(actual.cached_multiclan, CacheStatus.IS)
self.assertEqual(actual.cached_functional, CacheStatus.IS)
self.assertEqual(actual.cached_regular, CacheStatus.IS)
clan = Set({
Set({Couplet('a', '1'), Couplet('b', '2')}),
Set({Couplet('a', '3'), Couplet('b', '4')})
})
st2 = import_csv(IoCsvTests.path('set2.csv'))
self.assertEqual(clan, st2)
self.assertEqual(st2.cached_clan, CacheStatus.IS)
self.assertEqual(st2.cached_functional, CacheStatus.IS)
self.assertEqual(st2.cached_regular, CacheStatus.IS)
clan = Set(Set([Couplet(s, c) for s, c in zip('abcd', [1, 2, 3, 4])]),
Set([Couplet(s, c) for s, c in zip('abc', [5, 6, 7])]),
Set([Couplet(s, c) for s, c in zip('bd', [8, 9])]))
types = {'a': int, 'b': int, 'c': int, 'd': int}
st3 = import_csv(IoCsvTests.path('set3.csv'), types)
# print("expected", clan)
# print("actual", st3)
self.assertEqual(clan, st3)
self.assertEqual(st3.cached_clan, CacheStatus.IS)
self.assertEqual(st3.cached_functional, CacheStatus.IS)
self.assertEqual(st3.cached_regular, CacheStatus.IS_NOT)
expected = Multiset({
Set(Couplet('a', '1'), Couplet('b', '2'), Couplet('c', '3'),
Couplet('d', '4')):
1,
Set(Couplet('a', '5'), Couplet('b', '6'), Couplet('c', '7')):
1,
Set(Couplet('b', '8'), Couplet('d', '9')):
1
})
actual = import_csv(IoCsvTests.path('set3.csv'), has_dup_rows=True)
self.assertEqual(actual, expected)
self.assertEqual(actual.cached_multiclan, CacheStatus.IS)
self.assertEqual(actual.cached_functional, CacheStatus.IS)
self.assertEqual(actual.cached_regular, CacheStatus.IS_NOT)
expected = Multiset({
Set(Couplet('a', '5'), Couplet('b', '6'), Couplet('c', '7')):
1,
Set(Couplet('b', '8'), Couplet('d', '9')):
1,
Set(Couplet('a', '1'), Couplet('b', '2'), Couplet('c', '3'),
Couplet('d', '4')):
1
})
export_path = IoCsvTests.path('export.csv')
self.assertFalse(export_csv(expected, export_path))
self.assertTrue(export_csv(expected, export_path,
ordered_lefts='abcd'))
actual = import_csv(export_path, has_dup_rows=True)
self.assertEqual(actual, expected)
def test_multiset(self):
self.print_string('test_multiset')
msets = [
Multiset(None, None),
Multiset(False, False),
Multiset(2, 2, 1),
Multiset(2.0, 2.0, 3),
Multiset(complex('1+2j')),
Multiset('2', '3', '2'),
Multiset(bytes(2)),
Multiset(range(-1, 5), range(-1, 5), range(1, 5)),
Multiset(
frozenset([
None,
bool(2),
int(2),
float(2),
complex('1+2j'),
str(2),
bytes(2),
range(-1, 5),
frozenset([None, None]),
tuple((34, 35)),
Atom(int(2)),
Couplet(-1, -2),
Set('x', 'y', 'z')
])),
Multiset(tuple((34, 35))),
Multiset(Atom('jkh'), Atom('jkh'), Atom('AA'), Atom('jkh')),
Multiset(Couplet('a', 1), Couplet('B', 1), Couplet('a', 1)),
]
self.verify_string_import_export(msets)
self.verify_file_import_export(msets)
