def test_transpose(self): """Basic tests of couplets.transpose().""" # Wrong argument types. self.assertRaises(TypeError, lambda: transpose(3)) self.assertIs(transpose(Atom(3)), Undef()) RaiseOnUndef.set_level(1) self.assertRaises(UndefException, lambda: transpose(Set('a', 'b'))) RaiseOnUndef.reset() # T(a^b) = b^a result = transpose(_couplet_a_to_b) self.assertEqual(result, _couplet_b_to_a)
def test_transpose(self): """Basic tests of couplets.transpose().""" # Wrong argument types. try: self.assertRaises(AttributeError, lambda: transpose(3)) self.assertIs(transpose(Atom(3)), Undef()) RaiseOnUndef.set_level(1) self.assertRaises(UndefException, lambda: transpose(Set('a', 'b'))) RaiseOnUndef.reset() except: # Make sure RaiseOnUndef level gets reset. RaiseOnUndef.reset() raise result = transpose(_couplet_b_to_a) self.assertEqual(result, _couplet_a_to_b)
def is_symmetric(rel, _checked=True) -> bool: """Return ``True`` if ``rel`` is :term:`symmetric`. :return: ``True`` if ``rel`` is :term:`symmetric` or `Undef()` if ``rel`` is not a :term:`relation`. """ if _checked: if not is_member(rel): return _make_or_raise_undef() else: assert is_member(rel) if not rel.cached_is_symmetric and not rel.cached_is_not_symmetric: symmetric = all(rel.has_element( _couplets.transpose(couplet, _checked=False)) for couplet in rel) rel.cache_is_symmetric(symmetric) return rel.cached_is_symmetric
def is_symmetric(rel, _checked=True) -> bool: """Return whether ``rel`` is symmetric. :return: ``True`` if ``rel`` is :term:`symmetric`, ``False`` if it is not, or `Undef()` if ``rel`` is not a :term:`relation`. """ if _checked: if not is_member(rel): return _undef.make_or_raise_undef() else: assert is_member(rel) if rel.cached_symmetric == _mo.CacheStatus.UNKNOWN: symmetric = all(rel.has_element( _couplets.transpose(couplet, _checked=False)) for couplet in rel) rel.cache_symmetric(_mo.CacheStatus.from_bool(symmetric)) return rel.cached_symmetric == _mo.CacheStatus.IS
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_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 is_symmetric(rel, _checked=True) -> bool: """Return whether ``rel`` is symmetric. :return: ``True`` if ``rel`` is :term:`symmetric`, ``False`` if it is not, or `Undef()` if ``rel`` is not a :term:`relation`. """ if _checked: if not is_member(rel): return _undef.make_or_raise_undef2(rel) else: assert is_member_or_undef(rel) if rel is _undef.Undef(): return _undef.make_or_raise_undef(2) if rel.cached_symmetric == _mo.CacheStatus.UNKNOWN: symmetric = all( rel.has_element(_couplets.transpose(couplet, _checked=False)) for couplet in rel) rel.cache_symmetric(_mo.CacheStatus.from_bool(symmetric)) return rel.cached_symmetric == _mo.CacheStatus.IS
together = Couplet(peanut_butter, jelly) print(together) # MathObject initializers will coerce their arguments to be Atoms if non-MathObjects are passed. coerced = Couplet("this", "that") print(repr(coerced)) # The components of a Couplet are known as its left and right (abbreviated as 'right'). # Sometimes initializng a Couplet with named arguments can add clarity. up_down = Couplet(left="up", right="down") print("left is {}, right is {}".format(up_down.left, up_down.right)) # A Couplet's components can be swapped by evaluating the unary operation transpose. import algebraixlib.algebras.couplets as couplets one_two = Couplet(1, 2) transpose_result = couplets.transpose(one_two) print("A couplet {} and its transpose {}".format(one_two, transpose_result)) # When an expression is undefined in algebraixlib, it returns a special value, the singleton Undef. # Undef cannot be used as a value in a MathObject and cannot be compared to any value (even itself). # Use the is and is not operators to test if a value is undefined. from algebraixlib.undef import Undef print(Undef() is Undef()) print(Undef() is not Undef()) print(None is not Undef()) # The binary operation composition(a^b, c^d) evaluates to a^d when b == c, otherwise it is # undefined. a_to_b = Couplet('a', 'b') # b^a b_to_c = Couplet('b', 'c') # c^b print(couplets.compose(b_to_c, a_to_b)) # c^a
together = Couplet(peanut_butter, jelly) print(together) # MathObject initializers will coerce their arguments to be Atoms if non-MathObjects are passed. coerced = Couplet("this", "that") print(repr(coerced)) # The components of a Couplet are known as its left and right (abbreviated as 'right'). # Sometimes initializng a Couplet with named arguments can add clarity. up_down = Couplet(left="up", right="down") print("left is {}, right is {}".format(up_down.left, up_down.right)) # A Couplet's components can be swapped by evaluating the unary operation transpose. import algebraixlib.algebras.couplets as couplets one_two = Couplet(1, 2) transpose_result = couplets.transpose(one_two) print("A couplet {} and its transpose {}".format(one_two, transpose_result)) # When an expression is undefined in algebraixlib, it returns a special value, the singleton Undef. # Undef cannot be used as a value in a MathObject and cannot be compared to any value (even itself). # Use the is and is not operators to test if a value is undefined. from algebraixlib.undef import Undef print(Undef() is Undef()) print(Undef() is not Undef()) print(None is not Undef()) # The binary operation composition(c->d, a->b) evaluates to a->d when b == c, otherwise it is # undefined. a_to_b = Couplet('a', 'b') # a->b b_to_c = Couplet('b', 'c') # b->c print(couplets.compose(b_to_c, a_to_b)) # a->c