def test_diag(self):
rel1 = Set(Couplet('a', 'a'), Couplet('b', 'b'))
self.assertEqual(diag('a', 'b'), rel1)
self.assertEqual(diag(), Set())
self.assertIs(diag(Undef()), Undef())
self.assertIs(diag(Undef(), _checked=False), Undef())
def test_project(self):
"""Basic tests of clans.project()."""
self.assertIs(project(Undef(), Undef()), Undef())
c1 = ac['clan1']
self.assertIs(project(c1, Undef()), Undef())
c2 = Set(Set(Couplet('a', 1)), Set(Couplet('a', 4)))
self.assertEqual(project(c1, 'a'), c2)
def _atom_assert(self, test_key):
"""Assert that 'test_atom' is a proper Atom (with test additions) with the value 'value'."""
atom = ba[test_key]
value = atom._test_val
value_val = value
while type(value_val) == Atom:
value_val = value_val.value
msg = atom._test_msg
# Test the type structure.
self.assertTrue(isinstance(atom, MathObject))
self.assertTrue(isinstance(atom, Atom))
self.assertFalse(isinstance(atom, Couplet))
self.assertFalse(isinstance(atom, Set))
# Compare the value and make sure it is not a MathObject.
atom_value = atom.value
self.assertFalse(isinstance(atom_value, MathObject))
self.assertEqual(atom_value, value_val)
# Make sure that the representations and string conversion of the atom and the value match.
self.assertEqual(repr(atom),
'Atom({value})'.format(value=repr(value_val)))
self.assertEqual(str(atom), repr(value_val))
# Make sure that the representation evaluates to an atom that compares equal.
repr_exec = 'self.assertEqual(atom, {0})'.format(repr(atom))
exec(repr_exec)
# Check the ground set.
self.assertEqual(atom.get_ground_set(), GenesisSetA())
# Test left set and functionality.
self.assertIs(atom.get_left_set(), Undef())
self.assertIs(is_functional(atom), Undef())
self.assertIs(atom('callable'), Undef())
# Print the representation and the string conversion.
if self.print_examples:
print('repr(Atom({msg})) = {repr}'.format(msg=msg,
repr=repr(atom)))
print('str(Atom({msg})) = {str}'.format(msg=msg, str=str(atom)))
def test_power_set(self):
# self._check_argument_types_unary_undef(power_set)
self.assertIs(power_set(Undef()), Undef())
s1 = Set(1, 2, 3)
p1 = Set(Set(), Set(1), Set(2), Set(3), Set(1, 2), Set(1, 3),
Set(2, 3), Set(1, 2, 3))
self.assertEqual(p1, power_set(s1))
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_functional_add(self):
rel1 = Set(Couplet('a', 1))
couplet = Couplet('b', 1)
rel2 = Set(Couplet('a', 1), Couplet('b', 1))
self.assertEqual(functional_add(rel1, couplet), rel2)
self.assertIs(functional_add(rel1, Undef()), Undef())
self.assertIs(functional_add(Undef(), couplet), Undef())
def _check_wrong_argument_types_binary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3, Set(Couplet(1, 2))))
self.assertRaises(AttributeError, lambda: operation(Set(Couplet(1, 2)), 4))
self.assertIs(operation(Set(Couplet(1, 2)), Atom(4)), Undef())
self.assertIs(operation(Atom(3), Set(Couplet(1, 2))), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Couplet(1, 2), Couplet(3, 4)))
RaiseOnUndef.reset()
def test_is_transitive(self):
"""Basic tests of relations.is_transitive()."""
self.assertRaises(AttributeError, lambda: is_transitive(3))
self.assertIs(is_transitive(Atom(3)), Undef())
self.assertIs(is_transitive(Undef()), Undef())
self.assertIs(is_transitive(Undef(), _checked=False), Undef())
self.assertTrue(is_transitive(Set(Couplet('a', 'b'), Couplet('b', 'c'), Couplet('a', 'c'))))
self.assertFalse(is_transitive(Set(Couplet('a', 'b'), Couplet('b', 'c'))))
def test_ne(self):
"""Test inequality."""
u1 = Undef()
u2 = Undef()
self.assertRaises(TypeError, lambda: u1 != u2)
self.assertRaises(TypeError, lambda: u2 != u1)
self.assertRaises(TypeError, lambda: u1 != u1)
self.assertRaises(TypeError, lambda: u2 != u2)
self.assertRaises(TypeError, lambda: u1 != 3)
def test_eq(self):
"""Test equality."""
u1 = Undef()
u2 = Undef()
self.assertRaises(TypeError, lambda: u1 == u2)
self.assertRaises(TypeError, lambda: u2 == u1)
self.assertRaises(TypeError, lambda: u1 == u1)
self.assertRaises(TypeError, lambda: u2 == u2)
self.assertRaises(TypeError, lambda: u1 == 'a')
def _check_wrong_argument_type_unary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3))
self.assertIs(operation(Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Set('a', 'b')))
RaiseOnUndef.reset()
self.assertIs(operation(Undef()), Undef())
self.assertIs(operation(Undef(), _checked=False), Undef())
def test_is_right_functional(self):
"""Basic tests of relations.is_right_functional()."""
self.assertRaises(AttributeError, lambda: is_right_functional(3))
self.assertIs(is_right_functional(Atom(3)), Undef())
self.assertIs(is_right_functional(Undef()), Undef())
self.assertIs(is_right_functional(Undef(), _checked=False), Undef())
for rel_idx in range(1, 3):
rel_name = 'rel' + str(rel_idx)
self.assertTrue(is_right_functional(ar[rel_name]))
def test_transpose(self):
"""Basic tests of relations.transpose()."""
self._check_wrong_argument_type_unary(transpose)
# Transpose.
result = transpose(ar['rel1'])
self.assertEqual(result, ar['rel1transp'])
result = transpose(ar['reldiag'])
self.assertEqual(result, ar['reldiag'])
self.assertIs(transpose(Undef()), Undef())
self.assertIs(transpose(Undef(), _checked=False), Undef())
def test_restrict(self):
self.assertIs(restrict(Undef(), Undef()), Undef())
s1 = Set(1, 2, 3)
self.assertRaises(TypeError, lambda: restrict(s1, Undef()))
self.assertRaises(TypeError, lambda: restrict(s1, 1))
self.assertRaises(TypeError, lambda: restrict(s1, 'a'))
self.assertEqual(restrict(s1, lambda x: x.value < 3), Set(1, 2))
self.assertEqual(restrict(s1, lambda x: x.value > 1), Set(2, 3))
def test_singleton(self):
"""Test singleton characteristics."""
u1 = Undef()
u2 = Undef()
self.assertIs(u1, u2)
self.assertIs(u1, Undef())
self.assertIs(u2, Undef())
self.assertTrue(u1 is Undef())
self.assertFalse(
u1 is Undef,
'Undef refers to the class Undef, not the instance Undef()')
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)))
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException, lambda: operation(Set(Atom(3))))
RaiseOnUndef.reset()
self._check_argument_types_unary_undef(operation)
def test_membership(self):
self.assertTrue(is_member(Set(Couplet(1, 2))))
self.assertFalse(is_member(Couplet(3, 4)))
self.assertFalse(is_member(Undef()))
self.assertTrue(is_absolute_member(Set(Couplet(1, 2))))
self.assertFalse(is_absolute_member(Set(Couplet(Set(3), 4))))
self.assertFalse(is_absolute_member(Undef()))
self.assertRaises(AttributeError, lambda: is_member(3))
s = Set(Couplet('field', Set(Couplet('name', 'Value'))),
Couplet('field', Set(Couplet('name', 'Year'), Atom('1960'))))
self.assertTrue(is_member(s))
def test_get_rights(self):
"""Basic tests of relations.get_rights()."""
self._check_wrong_argument_type_unary(get_rights)
# Right set.
for rel_idx in range(1, 3):
rel_name = 'rel' + str(rel_idx)
rights_name = rel_name + '/rights'
result = get_rights(ar[rel_name])
self.assertEqual(result, ar[rights_name])
self.assertIs(get_rights(Undef()), Undef())
self.assertIs(get_rights(Undef(), _checked=False), Undef())
def test_conversions(self):
"""test conversions"""
u1 = Undef()
u2 = Undef()
self.assertRaises(TypeError, lambda: not u1)
self.assertRaises(TypeError, lambda: u1 and u2)
self.assertRaises(TypeError, lambda: u1 or u2)
self.assertRaises(TypeError, lambda: bool(u1))
self.assertRaises(TypeError, lambda: int(u1))
self.assertRaises(TypeError, lambda: float(u1))
self.assertRaises(
TypeError,
lambda: {Undef()}) # Can't put Undef() in set()...not hashable
def test_regular(self):
lefts = basic_sets['left func/lefts']
self.assertTrue(is_regular(Set()))
self.assertIs(is_regular(lefts), Undef())
self.assertIs(is_regular(basic_sets['left func']), Undef())
self.assertTrue(is_regular(basic_clans['left func']))
self.assertFalse(is_regular(basic_clans['left func2']))
self.assertFalse(is_regular(basic_clans['not left func']))
embedded_has_irregular_left = Set(basic_sets['left func'], basic_sets['not left func'])
self.assertFalse(is_regular(embedded_has_irregular_left))
s = basic_sets['left func']
self.assertEqual(s.cached_regular, CacheStatus.N_A)
def test_properties(self):
a = ba['2']
self.assertIs(a.get_left_set(), Undef())
self.assertIs(is_functional(a), Undef())
self.assertIs(a.get_right_set(), Undef())
self.assertIs(is_right_functional(a), Undef())
self.assertIs(is_bijective(a), Undef())
self.assertIs(is_reflexive(a), Undef())
self.assertIs(is_symmetric(a), Undef())
self.assertIs(is_transitive(a), Undef())
self.assertIs(is_equivalence_relation(a), Undef())
def test_callable(self):
# Undefined:
self.assertIs(Set()('callable'), Undef())
for set_not_func in [basic_sets[name] for name in [
'empty', 'num in dict', 'str in array', 'single num', 'left func/lefts',
'left func/rights', 'not left func']]:
self.assertIs(set_not_func('callable'), Undef())
# Function:
set1 = basic_sets['left func']
self.assertEqual(set1('a'), Atom(1))
self.assertEqual(set1('b'), Atom(2))
self.assertEqual(set1('c'), Atom(3))
set1 = basic_sets['diagonal']
for left in relations.get_lefts(set1):
self.assertEqual(set1(left), left)
def add_atom(e1, e2):
if type(e1) != Atom:
return _make_or_raise_undef()
if type(e2) != Atom:
return _make_or_raise_undef()
if not isinstance(e1.value, Number):
return _make_or_raise_undef()
if not isinstance(e2.value, Number):
return _make_or_raise_undef()
try:
# noinspection PyUnresolvedReferences
result = e1.value + e2.value
except TypeError:
result = Undef()
return Atom(result) if result is not Undef() else result
def test_transpose(self):
"""Basic tests of couplets.transpose()."""
# Wrong argument types.
self.assertIs(transpose(Atom(3)), Undef())
self.assertIs(transpose(Undef()), Undef())
self.assertIs(transpose(Undef(), _checked=False), Undef())
self.assertRaises(AttributeError, lambda: transpose(3))
self.assertRaises(AssertionError, lambda: transpose(Atom(3), _checked=False))
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: transpose(Set('a', 'b')))
RaiseOnUndef.reset()
result = transpose(_couplet_b_to_a)
self.assertEqual(result, _couplet_a_to_b)
def test_make_or_raise_undef(self):
"""Test make_or_raise_undef() together with RaiseOnUndef."""
try:
self.assertEqual(RaiseOnUndef.get_level(), 0)
self.assertIs(make_or_raise_undef(), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: make_or_raise_undef())
self.assertIs(make_or_raise_undef(2), Undef())
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException, lambda: make_or_raise_undef(2))
RaiseOnUndef.reset()
self.assertIs(make_or_raise_undef(2), Undef())
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
def test_equivalence_relation(self):
self.assertTrue(is_equivalence_relation(Set()))
self.assertFalse(is_equivalence_relation(
Set([Couplet(s, c) for c, s in zip('aba', 'bcc')])))
self.assertIs(is_equivalence_relation(Set('a', 'b', 'c')), Undef())
self.assertFalse(is_equivalence_relation(
Set([Couplet(s, c) for c, s in zip('aba', 'bcd')])))
f = is_equivalence_relation(basic_sets['left func'])
self.assertFalse(f)
f = is_equivalence_relation(basic_sets['not left func'])
self.assertFalse(f)
f = is_equivalence_relation(basic_sets['diagonal'])
self.assertTrue(f)
f = is_equivalence_relation(basic_clans['not left func'])
self.assertFalse(f)
f = is_equivalence_relation(basic_clans['diagonal'])
self.assertTrue(f)
f = is_equivalence_relation(basic_hordes['not left func'])
self.assertFalse(f)
f = is_equivalence_relation(basic_hordes['diagonal'])
self.assertTrue(f)
s = basic_sets['diagonal']
self.assertEqual(s.cached_reflexive, CacheStatus.IS)
self.assertEqual(s.cached_symmetric, CacheStatus.IS)
self.assertEqual(s.cached_transitive, CacheStatus.IS)
def test_transitive(self):
self.assertTrue(is_transitive(Set()))
self.assertTrue(is_transitive(Set()))
self.assertTrue(is_transitive(Set([Couplet(s, c) for c, s in zip('aba', 'bcc')])))
self.assertIs(is_transitive(Set('a', 'b', 'c')), Undef())
rel = Set(Couplet(s, c) for c, s in zip('aba', 'bcd'))
self.assertFalse(is_transitive(rel))
self.assertEqual(rel.cached_transitive, CacheStatus.IS_NOT)
f = is_transitive(basic_sets['left func'])
self.assertTrue(f)
f = is_transitive(basic_sets['not left func'])
self.assertTrue(f)
f = is_transitive(basic_sets['diagonal'])
self.assertTrue(f)
f = is_transitive(basic_clans['not left func'])
self.assertTrue(f)
f = is_transitive(basic_clans['diagonal'])
self.assertTrue(f)
f = is_transitive(basic_hordes['not left func'])
self.assertTrue(f)
f = is_transitive(basic_hordes['diagonal'])
self.assertTrue(f)
s = basic_sets['left func']
self.assertEqual(s.cached_transitive, CacheStatus.IS)
def test_bijection(self):
self.assertTrue(is_bijective(Set()))
self.assertIs(is_bijective(Set('a', 'b', 'c')), Undef())
f = is_bijective(basic_sets['left func'])
self.assertTrue(f)
f = is_bijective(basic_sets['not left func'])
self.assertFalse(f)
f = is_bijective(basic_sets['not right func'])
self.assertFalse(f)
f = is_bijective(basic_clans['left func'])
self.assertTrue(f)
f = is_bijective(basic_clans['not right func'])
self.assertFalse(f)
f = is_bijective(basic_hordes['left func'])
self.assertTrue(f)
f = is_bijective(basic_hordes['not right func'])
self.assertFalse(f)
s = basic_sets['left func']
self.assertEqual(s.cached_functional, CacheStatus.IS)
self.assertEqual(s.cached_right_functional, CacheStatus.IS)
s = basic_sets['not left func']
self.assertEqual(s.cached_functional, CacheStatus.IS_NOT)
# The right flags aren't checked if left fails
self.assertEqual(s.cached_right_functional, CacheStatus.UNKNOWN)
def test_getitem(self):
# Undefined:
self.assertEqual(Set()['callable'], Set())
for set_not_func in [basic_sets[name] for name in [
'num in dict', 'str in array', 'single num', 'left func/lefts',
'left func/rights']]:
self.assertIs(set_not_func['callable'], Undef())
# Relation:
set1 = basic_sets['left func']
self.assertEqual(set1['a'], Set(1))
self.assertEqual(set1['b'], Set(2))
self.assertEqual(set1['c'], Set(3))
set1 = basic_sets['not left func']
self.assertEqual(set1['a'], Set(1, 4))
self.assertEqual(set1['b'], Set(2))
self.assertEqual(set1['c'], Set(3))
set1 = basic_sets['diagonal']
for left in relations.get_lefts(set1):
self.assertEqual(set1[left], Set(left))
# Clan of relations:
self.assertEqual(algebra_clans['clan1']['a'], Set(1, 4))
self.assertEqual(algebra_clans['clan2']['x'], Set('a'))
self.assertEqual(algebra_clans['clan2']['zzz'], Set('zzz'))
self.assertEqual(algebra_clans['clan3']['c'], Set(3, 5))
self.assertEqual(algebra_clans['clan4'][3], Set('c'))
self.assertEqual(algebra_clans['clan4'][5], Set('b', 'c'))
self.assertEqual(algebra_clans['clan5']['b'], Set(2, 5))
self.assertEqual(algebra_clans['clan5']['c'], Set(3))
self.assertEqual(algebra_clans['clan5']['d'], Set())
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)
