def cross_functional_union(mclan1: 'P(P(M x M) x N)', mclan2: 'P(P(M x M) x N)', _checked=True) -> 'P(P(M x M) x N)': r"""Return the :term:`cross-functional union` of ``mclan1`` and ``mclan2``. :return: The :term:`binary multi-extension` of the :term:`functional union` from the :term:`algebra of relations` to the :term:`algebra of multiclans`, applied to ``mclan1`` and ``mclan2``, or `Undef()` if ``mclan1`` or ``mclan2`` are not :term:`multiclan`\s. """ if _checked: if not is_member(mclan1): return _undef.make_or_raise_undef2(mclan1) if not is_member(mclan2): return _undef.make_or_raise_undef2(mclan2) else: assert is_member_or_undef(mclan1) assert is_member_or_undef(mclan2) if mclan1 is _undef.Undef() or mclan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_multi_extend( mclan1, mclan2, _functools.partial(_relations.functional_union, _checked=False), _checked=False) if not result.is_empty: result.cache_multiclan(CacheStatus.IS) result.cache_functional(CacheStatus.IS) if mclan1.cached_is_not_right_functional or mclan2.cached_is_not_right_functional: result.cache_right_functional(CacheStatus.IS_NOT) return result
def right_functional_union(rel1: 'P(M x M)', rel2: 'P(M x M)', _checked=True) -> 'P(M x M)': r"""Return the union of ``rel1`` and ``rel2`` if it is right-functional, otherwise `Undef()`. :return: The :term:`right-functional union` of the :term:`relation`\s ``rel1`` and ``rel2``; that is, the :term:`union` if the result is :term:`right-functional`, otherwise `Undef()`. Also return `Undef()` if ``rel1`` or ``rel2`` are not relations. """ if _checked: if not is_member(rel1): return _undef.make_or_raise_undef2(rel1) if not is_member(rel2): return _undef.make_or_raise_undef2(rel2) else: assert is_member_or_undef(rel1) assert is_member_or_undef(rel2) if rel1 is _undef.Undef() or rel2 is _undef.Undef(): return _undef.make_or_raise_undef(2) rel_union = _sets.union(rel1, rel2, _checked=False).cache_relation( _mo.CacheStatus.IS) if not is_right_functional(rel_union, _checked=False): return _undef.make_or_raise_undef(2) return rel_union
def cross_intersect(clan1: 'PP(M x M)', clan2: 'PP(M x M)', _checked=True) -> 'PP(M x M)': r"""Return the cross-intersection of ``clan1`` and ``clan2``. The :term:`cross-intersection` of two :term:`clan`\s is a clan that contains the result of intersecting every :term:`relation` from one clan with every relation from the other clan. :return: The :term:`binary extension` of :term:`intersection` from the :term:`algebra of relations` (which inherits it from the :term:`algebra of sets`) to the :term:`algebra of clans` applied to ``clan1`` and ``clan2``, or `Undef()` if ``clan1`` or ``clan2`` are not :term:`clan`\s. """ if _checked: if not is_member(clan1): return _undef.make_or_raise_undef2(clan1) if not is_member(clan2): return _undef.make_or_raise_undef2(clan2) else: assert is_member_or_undef(clan1) assert is_member_or_undef(clan2) if clan1 is _undef.Undef() or clan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_extend(clan1, clan2, _functools.partial( _sets.intersect, _checked=False), _checked=False) if not result.is_empty: result.cache_clan(_mo.CacheStatus.IS) if clan1.cached_is_functional or clan2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if clan1.cached_is_right_functional or clan2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) return result
def binary_extend(set1: 'P( M )', set2: 'P( M )', op, _checked=True) -> 'P( M )': r"""Return the :term:`binary extension` of ``op`` from one :term:`algebra` to another algebra. For this extension, the elements of the extended algebra must be :term:`set`\s of the elements of the original algebra. :param set1: A :term:`set` with elements on which ``op`` operates. :param set2: A set with elements on which ``op`` operates. :param op: A :term:`binary operation` that operates on the elements of ``set1`` and ``set2``. :return: A set that consists of the defined results of ``op`` when executed on all combinations of the elements of ``set1`` and ``set2``, or `Undef()` if either set is not a :class:`~.Set`. """ if _checked: if not _sets.is_member(set1): return _undef.make_or_raise_undef2(set1) if not _sets.is_member(set2): return _undef.make_or_raise_undef2(set2) else: assert _sets.is_member_or_undef(set1) assert _sets.is_member_or_undef(set2) if set1 is _undef.Undef() or set2 is _undef.Undef(): return _undef.make_or_raise_undef(2) def _get_values(_set1, _set2): for e1 in _set1: for e2 in _set2: result = op(e1, e2) if result is not _undef.Undef(): yield result return _mo.Set(_get_values(set1, set2), direct_load=True)
def lhs_cross_functional_union(lhs: 'PP( MxM )', rhs: 'PP( MxM )', _checked=True) -> 'PP(M x M)': """Return the :term:`lhs-cross-functional union` ('left join') of ``lhs`` and ``rhs``. This operation results in a :term:`clan` that contains every :term:`relation` of a :term:`cross-functional union`, but also contains all relations in ``lhs`` that are not already part of one of the resulting relations. :param lhs: All relations in this clan are guaranteed to be represented in the result. :return: The resulting clan or `Undef()` if ``lhs`` or ``rhs`` are not clans. """ if _checked: if not is_member(lhs): return _undef.make_or_raise_undef2(lhs) if not is_member(rhs): return _undef.make_or_raise_undef2(rhs) else: assert is_member_or_undef(lhs) assert is_member_or_undef(rhs) if lhs is _undef.Undef() or rhs is _undef.Undef(): return _undef.make_or_raise_undef(2) cfu = cross_functional_union(lhs, rhs, _checked=False) lhs_rest = _mo.Set( lhs_elem for lhs_elem in lhs if cross_functional_union(_mo.Set(lhs_elem, direct_load=True), rhs).is_empty) result = _sets.union(cfu, lhs_rest, _checked=False) if not result.is_empty: result.cache_clan(_mo.CacheStatus.IS) if lhs.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if lhs.cached_is_not_right_functional or rhs.cached_is_not_right_functional: result.cache_right_functional(_mo.CacheStatus.IS_NOT) if not rhs.is_empty and not lhs_rest.is_empty: result.cache_regular(_mo.CacheStatus.IS_NOT) return result
def compose(rel1: 'P(M x M)', rel2: 'P(M x M)', _checked=True) -> 'P(M x M)': r"""Return the composition of ``rel1`` with ``rel2``. :return: The :term:`binary extension` of :term:`composition` from the :term:`algebra of couplets` to the :term:`algebra of relations`, applied to the :term:`relation`\s ``rel1`` and ``rel2``, or `Undef()` if ``rel1`` or ``rel2`` are not relations. """ if _checked: if not is_member(rel1): return _undef.make_or_raise_undef2(rel1) if not is_member(rel2): return _undef.make_or_raise_undef2(rel2) else: assert is_member_or_undef(rel1) assert is_member_or_undef(rel2) if rel1 is _undef.Undef() or rel2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_extend(rel1, rel2, _functools.partial( _couplets.compose, _checked=False), _checked=False) if not result.is_empty: result.cache_relation(_mo.CacheStatus.IS) if rel1.cached_is_absolute and rel2.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) if rel1.cached_is_functional and rel2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if rel1.cached_is_right_functional and rel2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) return result
def cross_right_functional_union(clan1: 'PP(M x M)', clan2: 'PP(M x M)', _checked=True) -> 'PP(M x M)': r"""Return the cross-right-functional union of ``clan1`` and ``clan2``. The :term:`cross-right-functional union` of two :term:`clan`\s is the :term:`cross-union` of these clans, but removing all resulting :term:`relation`\s that are not :term:`right-functional`. :return: The :term:`binary extension` of the :term:`right-functional union` from the :term:`algebra of relations` to the :term:`algebra of clans`, applied to ``clan1`` and ``clan2``, or `Undef()` if ``clan1`` or ``clan2`` are not :term:`clan`\s. """ if _checked: if not is_member(clan1): return _undef.make_or_raise_undef2(clan1) if not is_member(clan2): return _undef.make_or_raise_undef2(clan2) else: assert is_member_or_undef(clan1) assert is_member_or_undef(clan2) if clan1 is _undef.Undef() or clan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_extend(clan1, clan2, _functools.partial( _relations.right_functional_union, _checked=False), _checked=False) if not result.is_empty: result.cache_clan(_mo.CacheStatus.IS) result.cache_right_functional(_mo.CacheStatus.IS) if clan1.cached_is_not_functional or clan2.cached_is_not_functional: result.cache_functional(_mo.CacheStatus.IS_NOT) return result
def cross_intersect(multiclan1: 'P(P(M x M) x N)', multiclan2: 'PP(M x M)', _checked=True) -> 'PP(M x M)': r"""Return the :term:`cross-intersection` of ``multiclan1`` and ``multiclan2``. :return: The :term:`binary multi-extension` of :term:`intersection` from the :term:`algebra of relations` (which inherits it from the :term:`algebra of sets`) to the :term:`algebra of multiclans` applied to ``multiclan1`` and ``multiclan2``, or `Undef()` if ``multiclan1`` or ``multiclan2`` are not :term:`multiclan`\s. """ if _checked: if not is_member(multiclan1): return _undef.make_or_raise_undef2(multiclan1) if not is_member(multiclan2): return _undef.make_or_raise_undef2(multiclan2) else: assert is_member_or_undef(multiclan1) assert is_member_or_undef(multiclan2) if multiclan1 is _undef.Undef() or multiclan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_multi_extend(multiclan1, multiclan2, _functools.partial( _sets.intersect, _checked=False), _checked=False) if not result.is_empty: result.cache_multiclan(_mo.CacheStatus.IS) if multiclan1.cached_is_functional or multiclan2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if multiclan1.cached_is_right_functional or multiclan2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) return result
def compose(multiclan1: 'P(P(M x M) x N)', multiclan2: 'P(P(M x M) x N)', _checked=True) -> 'P(P(M x M) x N)': r"""Return the composition of ``multiclan1`` with ``multiclan2``. :return: The :term:`binary multi-extension` of :term:`composition` from the :term:`algebra of relations` to the :term:`algebra of multiclans`, applied to ``multiclan1`` and ``multiclan2``, or `Undef()` if ``multiclan1`` or ``multiclan2`` are not :term:`multiclan`\s. """ if _checked: if not is_member(multiclan1): return _undef.make_or_raise_undef2(multiclan1) if not is_member(multiclan2): return _undef.make_or_raise_undef2(multiclan2) else: assert is_member_or_undef(multiclan1) assert is_member_or_undef(multiclan2) if multiclan1 is _undef.Undef() or multiclan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_multi_extend(multiclan1, multiclan2, _functools.partial( _relations.compose, _checked=False), _checked=False) if not result.is_empty: result.cache_multiclan(_mo.CacheStatus.IS) if multiclan1.cached_is_absolute and multiclan2.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) if multiclan1.cached_is_functional and multiclan2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if multiclan1.cached_is_right_functional and multiclan2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) return result
def fill_lefts(rel: 'P(M x M)', renames: 'P(M x M)', _checked=True) -> 'P(M x M)': r"""Return the left components in ``rel`` that are missing in ``renames`` as a diagonal unioned with ``renames``. The purpose is to create a :term:`relation` that can be used with the :term:`composition` operation to change (rename) one or more :term:`left component`\s and leave the rest alone. :param rel: The :term:`relation` that provides the full :term:`left set`. :param renames: A relation where the :term:`right component`\s are meant to be :term:`composition` 'origins' and the :term:`left component`\s composition 'targets'. :return: A relation that contains all members of ``renames`` unioned with a :term:`diagonal` that consists of all left components in ``rel`` that are missing in ``renames``. """ if _checked: if not is_member(rel): return _undef.make_or_raise_undef2(rel) if not is_member(renames): return _undef.make_or_raise_undef2(renames) else: assert is_member_or_undef(rel) assert is_member_or_undef(renames) if rel is _undef.Undef() or renames is _undef.Undef(): return _undef.make_or_raise_undef(2) missing_lefts = _sets.minus(get_lefts(rel, _checked=False), get_rights(renames, _checked=False), _checked=False) diag_missing_lefts = diag(*missing_lefts, _checked=False) result = _sets.union(renames, diag_missing_lefts, _checked=False) assert result.cached_is_relation return result
def cross_right_functional_union(clan1: 'PP(M x M)', clan2: 'PP(M x M)', _checked=True) -> 'PP(M x M)': r"""Return the cross-right-functional union of ``clan1`` and ``clan2``. The :term:`cross-right-functional union` of two :term:`clan`\s is the :term:`cross-union` of these clans, but removing all resulting :term:`relation`\s that are not :term:`right-functional`. :return: The :term:`binary extension` of the :term:`right-functional union` from the :term:`algebra of relations` to the :term:`algebra of clans`, applied to ``clan1`` and ``clan2``, or `Undef()` if ``clan1`` or ``clan2`` are not :term:`clan`\s. """ if _checked: if not is_member(clan1): return _undef.make_or_raise_undef2(clan1) if not is_member(clan2): return _undef.make_or_raise_undef2(clan2) else: assert is_member_or_undef(clan1) assert is_member_or_undef(clan2) if clan1 is _undef.Undef() or clan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_extend( clan1, clan2, _functools.partial(_relations.right_functional_union, _checked=False), _checked=False) if not result.is_empty: result.cache_clan(_mo.CacheStatus.IS) result.cache_right_functional(_mo.CacheStatus.IS) if clan1.cached_is_not_functional or clan2.cached_is_not_functional: result.cache_functional(_mo.CacheStatus.IS_NOT) return result
def cross_intersect(clan1: 'PP(M x M)', clan2: 'PP(M x M)', _checked=True) -> 'PP(M x M)': r"""Return the cross-intersection of ``clan1`` and ``clan2``. The :term:`cross-intersection` of two :term:`clan`\s is a clan that contains the result of intersecting every :term:`relation` from one clan with every relation from the other clan. :return: The :term:`binary extension` of :term:`intersection` from the :term:`algebra of relations` (which inherits it from the :term:`algebra of sets`) to the :term:`algebra of clans` applied to ``clan1`` and ``clan2``, or `Undef()` if ``clan1`` or ``clan2`` are not :term:`clan`\s. """ if _checked: if not is_member(clan1): return _undef.make_or_raise_undef2(clan1) if not is_member(clan2): return _undef.make_or_raise_undef2(clan2) else: assert is_member_or_undef(clan1) assert is_member_or_undef(clan2) if clan1 is _undef.Undef() or clan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_extend(clan1, clan2, _functools.partial(_sets.intersect, _checked=False), _checked=False) if not result.is_empty: result.cache_clan(_mo.CacheStatus.IS) if clan1.cached_is_functional or clan2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if clan1.cached_is_right_functional or clan2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) return result
def intersect(multiset1: 'P( M x N )', multiset2: 'P( M x N )', _checked=True) -> 'P( M x N )': """Return the multiset intersection of ``multiset1`` with ``multiset2``. :return: The :term:`multiset intersection` of ``multiset1`` and ``multiset2`` or `Undef()` if ``multiset1`` or ``multiset2`` are not instances of :class:`~.Multiset`. """ if _checked: if not is_member(multiset1): return _undef.make_or_raise_undef2(multiset1) if not is_member(multiset2): return _undef.make_or_raise_undef2(multiset2) else: assert is_member_or_undef(multiset1) assert is_member_or_undef(multiset2) if multiset1 is _undef.Undef() or multiset2 is _undef.Undef(): return _undef.make_or_raise_undef(2) values = multiset1.data & multiset2.data result = _mo.Multiset(values) if not result.is_empty: # Multiclan flags: if multiset1.cached_is_multiclan or multiset2.cached_is_multiclan: result.cache_multiclan(CacheStatus.IS) if multiset1.cached_is_absolute or multiset2.cached_is_absolute: result.cache_absolute(CacheStatus.IS) if multiset1.cached_is_functional or multiset2.cached_is_functional: result.cache_functional(CacheStatus.IS) if multiset1.cached_is_right_functional or multiset2.cached_is_right_functional: result.cache_right_functional(CacheStatus.IS) if multiset1.cached_is_regular or multiset2.cached_is_regular: result.cache_regular(CacheStatus.IS) if multiset1.cached_is_right_regular or multiset2.cached_is_right_regular: result.cache_right_regular(CacheStatus.IS) return result
def intersect(multiset1: 'P( M x N )', multiset2: 'P( M x N )', _checked=True) -> 'P( M x N )': """Return the multiset intersection of ``multiset1`` with ``multiset2``. :return: The :term:`multiset intersection` of ``multiset1`` and ``multiset2`` or `Undef()` if ``multiset1`` or ``multiset2`` are not instances of :class:`~.Multiset`. """ if _checked: if not is_member(multiset1): return _undef.make_or_raise_undef2(multiset1) if not is_member(multiset2): return _undef.make_or_raise_undef2(multiset2) else: assert is_member_or_undef(multiset1) assert is_member_or_undef(multiset2) if multiset1 is _undef.Undef() or multiset2 is _undef.Undef(): return _undef.make_or_raise_undef(2) values = multiset1.data & multiset2.data result = _mo.Multiset(values) if not result.is_empty: # Multiclan flags: if multiset1.cached_is_multiclan or multiset2.cached_is_multiclan: result.cache_multiclan(_mo.CacheStatus.IS) if multiset1.cached_is_absolute or multiset2.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) if multiset1.cached_is_functional or multiset2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if multiset1.cached_is_right_functional or multiset2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) if multiset1.cached_is_regular or multiset2.cached_is_regular: result.cache_regular(_mo.CacheStatus.IS) if multiset1.cached_is_right_regular or multiset2.cached_is_right_regular: result.cache_right_regular(_mo.CacheStatus.IS) return result
def superstrict(multiset1: 'P( M x N )', multiset2: 'P( M X N )', _checked=True) -> 'P( M X N )': """Return ``multiset1`` if ``multiset1`` is a superset of ``multiset2`` or `Undef()` if not. :return: The :term:`superstriction` of ``multiset1`` and ``multiset2`` (may return `Undef()`). Also return `Undef()` if ``multiset1`` or ``multiset2`` are not instances of :class:`~.Multiset`. """ if _checked: if not is_member(multiset1): return _undef.make_or_raise_undef2(multiset1) if not is_member(multiset2): return _undef.make_or_raise_undef2(multiset2) else: assert is_member_or_undef(multiset1) assert is_member_or_undef(multiset2) if multiset1 is _undef.Undef() or multiset2 is _undef.Undef(): return _undef.make_or_raise_undef(2) if not is_superset_of(multiset1, multiset2, _checked=False): return _undef.make_or_raise_undef(2) if not multiset1.is_empty: # Multiclan flags: if multiset1.cached_is_clan: if multiset2.cached_is_not_absolute: multiset1.cache_absolute(CacheStatus.IS_NOT) if multiset2.cached_is_not_functional: multiset1.cache_functional(CacheStatus.IS_NOT) if multiset2.cached_is_not_right_functional: multiset1.cache_right_functional(CacheStatus.IS_NOT) if multiset2.cached_is_not_regular: multiset1.cache_regular(CacheStatus.IS_NOT) if multiset2.cached_is_not_right_regular: multiset1.cache_right_regular(CacheStatus.IS_NOT) return multiset1
def compose(rel1: 'P(M x M)', rel2: 'P(M x M)', _checked=True) -> 'P(M x M)': r"""Return the composition of ``rel1`` with ``rel2``. :return: The :term:`binary extension` of :term:`composition` from the :term:`algebra of couplets` to the :term:`algebra of relations`, applied to the :term:`relation`\s ``rel1`` and ``rel2``, or `Undef()` if ``rel1`` or ``rel2`` are not relations. """ if _checked: if not is_member(rel1): return _undef.make_or_raise_undef2(rel1) if not is_member(rel2): return _undef.make_or_raise_undef2(rel2) else: assert is_member_or_undef(rel1) assert is_member_or_undef(rel2) if rel1 is _undef.Undef() or rel2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_extend(rel1, rel2, _functools.partial(_couplets.compose, _checked=False), _checked=False) if not result.is_empty: result.cache_relation(_mo.CacheStatus.IS) if rel1.cached_is_absolute and rel2.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) if rel1.cached_is_functional and rel2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if rel1.cached_is_right_functional and rel2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) return result
def superstrict(multiset1: 'P( M x N )', multiset2: 'P( M X N )', _checked=True) -> 'P( M X N )': """Return ``multiset1`` if ``multiset1`` is a superset of ``multiset2`` or `Undef()` if not. :return: The :term:`superstriction` of ``multiset1`` and ``multiset2`` (may return `Undef()`). Also return `Undef()` if ``multiset1`` or ``multiset2`` are not instances of :class:`~.Multiset`. """ if _checked: if not is_member(multiset1): return _undef.make_or_raise_undef2(multiset1) if not is_member(multiset2): return _undef.make_or_raise_undef2(multiset2) else: assert is_member_or_undef(multiset1) assert is_member_or_undef(multiset2) if multiset1 is _undef.Undef() or multiset2 is _undef.Undef(): return _undef.make_or_raise_undef(2) if not is_superset_of(multiset1, multiset2, _checked=False): return _undef.make_or_raise_undef(2) if not multiset1.is_empty: # Multiclan flags: if multiset1.cached_is_clan: if multiset2.cached_is_not_absolute: multiset1.cache_absolute(_mo.CacheStatus.IS_NOT) if multiset2.cached_is_not_functional: multiset1.cache_functional(_mo.CacheStatus.IS_NOT) if multiset2.cached_is_not_right_functional: multiset1.cache_right_functional(_mo.CacheStatus.IS_NOT) if multiset2.cached_is_not_regular: multiset1.cache_regular(_mo.CacheStatus.IS_NOT) if multiset2.cached_is_not_right_regular: multiset1.cache_right_regular(_mo.CacheStatus.IS_NOT) return multiset1
def superstrict(multiclan1: 'P(P(M x M) x N)', multiclan2: 'P(P(M x M) x N)', _checked=True) -> 'P(P(M x M) x N)': r"""Return the superstriction of ``multiclan1`` and ``multiclan2``. The :term:`superstriction` of two :term:`multiclan`\s is a multiclan that contains all :term:`relation`\s from ``multiclan1`` that are a :term:`supermultiset` of a relation from ``multiclan2``. :return: The :term:`binary multi-extension` of :term:`superstriction` from the :term:`algebra of relations` (which inherits it from the :term:`algebra of sets`) to the :term:`algebra of multiclans` applied to ``multiclan1`` and ``multiclan2``, or `Undef()` if ``multiclan1`` or ``multiclan2`` are not :term:`multiclan`\s. """ if _checked: if not is_member(multiclan1): return _undef.make_or_raise_undef2(multiclan1) if not is_member(multiclan2): return _undef.make_or_raise_undef2(multiclan2) else: assert is_member_or_undef(multiclan1) assert is_member_or_undef(multiclan2) if multiclan1 is _undef.Undef() or multiclan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_multi_extend(multiclan1, multiclan2, _functools.partial( _sets.superstrict, _checked=False), _checked=False) for elem, multi in result.data.items(): result.data[elem] = multiclan2.data[elem] if not result.is_empty: result.cache_multiclan(_mo.CacheStatus.IS) if multiclan1.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if multiclan1.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) if multiclan1.cached_is_reflexive: result.cache_reflexive(_mo.CacheStatus.IS) if multiclan1.cached_is_symmetric: result.cache_symmetric(_mo.CacheStatus.IS) if multiclan1.cached_is_transitive: result.cache_transitive(_mo.CacheStatus.IS) if multiclan1.cached_is_regular: result.cache_regular(_mo.CacheStatus.IS) if multiclan1.cached_is_right_regular: result.cache_right_regular(_mo.CacheStatus.IS) return result
def minus(set1: 'P( M )', set2: 'P( M )', _checked=True) -> 'P( M )': r"""Return the set difference of ``set1`` and ``set2``. :return: The :term:`difference` of ``set1`` and ``set2`` or `Undef()` if ``set1`` or ``set2`` are not :term:`set`\s (that is, instances of :class:`~.Set`). """ # pylint: disable=too-many-branches if _checked: if not is_member(set1): return _undef.make_or_raise_undef2(set1) if not is_member(set2): return _undef.make_or_raise_undef2(set2) else: assert is_member_or_undef(set1) assert is_member_or_undef(set2) if set1 is _undef.Undef() or set2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _mo.Set(set1.data.difference(set2.data), direct_load=True) if not result.is_empty: # Relation flags: if set1.cached_is_relation: result.cache_relation(_mo.CacheStatus.IS) if set1.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) if set1.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if set1.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) # Clan flags: if set1.cached_is_clan: result.cache_clan(_mo.CacheStatus.IS) if set1.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) if set1.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if set1.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) if set1.cached_is_reflexive: result.cache_reflexive(_mo.CacheStatus.IS) if set1.cached_is_symmetric: result.cache_symmetric(_mo.CacheStatus.IS) if set1.cached_is_transitive: result.cache_transitive(_mo.CacheStatus.IS) if set1.cached_is_regular: result.cache_regular(_mo.CacheStatus.IS) if set1.cached_is_right_regular: result.cache_right_regular(_mo.CacheStatus.IS) return result
def transpose(rel: 'P(M x M)', _checked=True) -> 'P(M x M)': """Return a relation where all couplets have their left and right components swapped. :return: The :term:`unary extension` of :term:`transposition` from the :term:`algebra of couplets` to the :term:`algebra of relations`, applied to the :term:`relation` ``rel``, or `Undef()` if ``rel`` is not a 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) result = _extension.unary_extend(rel, _functools.partial( _couplets.transpose, _checked=False), _checked=False) if not result.is_empty: result.cache_relation(_mo.CacheStatus.IS) result.cache_absolute(rel.cached_absolute) result.cache_functional(rel.cached_right_functional) result.cache_right_functional(rel.cached_functional) result.cache_reflexive(rel.cached_reflexive) result.cache_symmetric(rel.cached_symmetric) result.cache_transitive(rel.cached_transitive) return result
def demultify(multiset: 'P( M x N )', _checked=True) -> 'P( M )': """Return a :term:`set` based on ``multiset`` that contains all elements without multiples.""" if _checked: if not is_member(multiset): return _undef.make_or_raise_undef2(multiset) else: assert is_member_or_undef(multiset) if multiset is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _mo.Set(multiset.data.keys(), direct_load=True) if not result.is_empty: result.cache_clan(multiset.cached_multiclan) if multiset.cached_is_multiclan: result.cache_absolute(multiset.cached_absolute) result.cache_functional(multiset.cached_functional) result.cache_right_functional(multiset.cached_right_functional) result.cache_reflexive(multiset.cached_reflexive) result.cache_symmetric(multiset.cached_symmetric) result.cache_transitive(multiset.cached_transitive) result.cache_regular(multiset.cached_regular) result.cache_right_regular(multiset.cached_right_regular) # We don't yet have a concept of multirelations (multisets of couplets). Because of this, # a multiset that is converted into a set may be a relation without us being able to know # this here. Because of this, the only flags we can propagate are multiclan flags. return result
def is_right_regular(mclan, _checked=True) -> bool: """Return whether ``mclan`` is right-regular. :return: ``True`` if ``mclan`` is :term:`right-regular`, ``False`` if not, or `Undef()` if ``mclan`` is not a :term:`multiclan`. """ if _checked: if not is_member(mclan): return _undef.make_or_raise_undef2(mclan) else: assert is_member_or_undef(mclan) if mclan is _undef.Undef(): return _undef.make_or_raise_undef(2) if mclan.cached_right_regular == _mo.CacheStatus.UNKNOWN: # The empty set is already handled in Set().__init__ via flags initialization. if mclan.cached_is_not_right_functional: mclan.cache_right_regular(_mo.CacheStatus.IS_NOT) return False itr = iter(mclan.data) rel = next(itr) if not _relations.is_right_functional(rel): mclan.cache_right_regular(_mo.CacheStatus.IS_NOT) return False right_set = rel.get_right_set() right_regular = all( _relations.is_right_functional(rel) and right_set == rel.get_right_set() for rel in itr) mclan.cache_regular(_mo.CacheStatus.from_bool(right_regular)) return mclan.cached_is_regular
def get_lefts(clan: 'PP(M x M)', _checked=True) -> 'P( M )': r"""Return the set of the left components of all couplets in all relations in ``clan``. :return: The :term:`union` of the :term:`left set`\s of all :term:`relation`\s in ``clan`` or `Undef()` if ``clan`` is not a :term:`clan`. """ if _checked: if not is_member(clan): return _undef.make_or_raise_undef2(clan) else: assert is_member_or_undef(clan) if clan is _undef.Undef(): return _undef.make_or_raise_undef(2) if clan.is_empty: # The left set of an empty set is the empty set return clan clan_itr = iter(clan) left_set = _relations.get_lefts(next(clan_itr), _checked=False) for rel in clan_itr: left_set = _sets.union(_relations.get_lefts(rel, _checked=False), left_set, _checked=False) if not left_set.is_empty: if clan.cached_is_absolute: left_set.cache_absolute(CacheStatus.IS) return left_set
def get_left(rel: 'P(M x M)', right: '( M )', _checked=True) -> '( M )': r"""Return the left component of the couplet that has a right component of ``right``. In general, use with :term:`right-functional` :term:`relation`\s; that is, relations where all :term:`right component`\s appear at most once. :return: The :term:`left component` of the :term:`couplet` that has a :term:`right component` of ``right``, or `Undef()` if there is not exactly one couplet with the right component ``right`` in ``rel`` or ``rel`` is not a :term:`relation`. """ if _checked: if not is_member(rel): return _undef.make_or_raise_undef2(rel) if right is _undef.Undef(): return _undef.make_or_raise_undef(2) right = _mo.auto_convert(right) else: assert is_member_or_undef(rel) assert _mo.is_mathobject_or_undef(right) if right is _undef.Undef() or rel is _undef.Undef(): return _undef.make_or_raise_undef(2) result = None for elem in rel: assert elem.is_couplet if elem.right == right: if result is not None: return _undef.make_or_raise_undef( ) # Early Undef() exit if more than one found. result = elem.left if result is None: return _undef.make_or_raise_undef() # Undef() exit if none found. return result
def big_intersect(set_: 'PP( M )', _checked=True) -> 'P( M )': """Return the intersection of all members of ``set_``. :return: The :term:`intersection` of all members of ``set_`` or `Undef()` if ``set_`` or any of its members are not instances of :class:`~.Set`. Example code: .. code:: from algebraixlib.mathobjects import Set from algebraixlib.algebras.sets import big_intersect big_intersect(Set(Set('a', 'b'), Set('b', 'c'))) # Output: Set(Atom('b')) big_intersect(Set(Set('a', 'b'), 'a')) # Output: <algebraixlib.undef.Undef at 0x4004978> """ if _checked: if not is_member(set_): return _undef.make_or_raise_undef2(set_) for element in set_: if not is_member(element): return _undef.make_or_raise_undef(2) else: assert is_member_or_undef(set_) if set_ is _undef.Undef(): return _undef.make_or_raise_undef(2) return chain_binary_operation( set_, _functools.partial(intersect, _checked=False), is_member)
def chain_binary_operation(set_, binary_op, is_algebra_member): r"""Chain all elements of ``set_`` with the binary operation ``binary_op`` and return the result. :param set_: A :term:`set` of sets or :term:`multiset`\s. :param binary_op: The operation through which the members of ``set_`` are chained. It must be commutative and associative. :param is_algebra_member: The ``is_member()`` function of the :term:`algebra` of which the elements of ``set_`` must be members. :return: A member of ``algebra`` that is the result of chaining all elements of ``set_`` with the :term:`binary operation` ``binary_op``. """ if not is_member(set_): return _undef.make_or_raise_undef2(set_) if set_.is_empty: return set_ set_itr = iter(set_) element1 = next(set_itr) if not is_algebra_member(element1): return _undef.make_or_raise_undef() result = element1 for element in set_itr: if not is_algebra_member(element): return _undef.make_or_raise_undef() result = binary_op(result, element) return result
def get_rights_for_left(mclan: 'P(P(M x M) x N)', left: '( M )', _checked=True) -> 'P(M x N)': """Return the multiset of the right components of all couplets in the multiclan ``mclan`` associated with the left component ``left``. :return: The :term:`right multiset` of the :term:`multiclan` ``mclan`` associated with the :term:`left component` ``left`` or `Undef()` if ``mclan`` is not a multiclan. """ if _checked: if not is_member(mclan): return _undef.make_or_raise_undef2(mclan) if left is _undef.Undef(): return _mo.Set() left = _mo.auto_convert(left) else: assert is_member_or_undef(mclan) assert _mo.is_mathobject_or_undef(left) if mclan is _undef.Undef(): return _undef.make_or_raise_undef(2) if left is _undef.Undef(): return _mo.Set() clan_itr = iter(mclan) rights = _sets.multify(_relations.get_rights_for_left(next(clan_itr), left, _checked=False)) for rel in clan_itr: rights = _multisets.add( _sets.multify(_relations.get_rights_for_left(rel, left, _checked=False)), rights, _checked=False) if not rights.is_empty: if mclan.cached_is_absolute: rights.cache_absolute(_mo.CacheStatus.IS) return rights
def defined_at(mclan: 'P(P(M x M) x N)', left: '( M )', _checked=True): r"""Return the :term:`relation`\s of ``mclan`` that are defined for ``left``.""" if not is_member(mclan): return _undef.make_or_raise_undef(2) if left is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.unary_multi_extend(mclan, _functools.partial( _relations.defined_at, left=left, _checked=_checked), _checked=_checked) if result is _undef.Undef() or not result: return _undef.make_or_raise_undef2(result) result.cache_multiclan(_mo.CacheStatus.IS) if not result.is_empty: if mclan.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if mclan.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) if mclan.cached_is_regular: result.cache_regular(_mo.CacheStatus.IS) if mclan.cached_is_right_regular: result.cache_right_regular(_mo.CacheStatus.IS) return result
def get_rights_for_left(rel: 'P(M x M)', left: '( M )', _checked=True) -> 'P( M )': """Return the set of the right components of all couplets in the relation ``rel`` associated with the :term:`left component` ``left``. :return: The :term:`right set` of the :term:`relation` ``rel`` associated with the :term:`left component` or `Undef()` if ``rel`` is not a :term:`relation`. """ if _checked: if not is_member(rel): return _undef.make_or_raise_undef2(rel) if left is _undef.Undef(): return _mo.Set() left = _mo.auto_convert(left) else: assert is_member_or_undef(rel) assert _mo.is_mathobject_or_undef(left) if rel is _undef.Undef(): return _undef.make_or_raise_undef(2) if left is _undef.Undef(): return _mo.Set() result = _mo.Set((elem.right for elem in rel if elem.left == left), direct_load=True) if not result.is_empty: if rel.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) return result
def get_left(rel: 'P(M x M)', right: '( M )', _checked=True) -> '( M )': r"""Return the left component of the couplet that has a right component of ``right``. In general, use with :term:`right-functional` :term:`relation`\s; that is, relations where all :term:`right component`\s appear at most once. :return: The :term:`left component` of the :term:`couplet` that has a :term:`right component` of ``right``, or `Undef()` if there is not exactly one couplet with the right component ``right`` in ``rel`` or ``rel`` is not a :term:`relation`. """ if _checked: if not is_member(rel): return _undef.make_or_raise_undef2(rel) if right is _undef.Undef(): return _undef.make_or_raise_undef(2) right = _mo.auto_convert(right) else: assert is_member_or_undef(rel) assert _mo.is_mathobject_or_undef(right) if right is _undef.Undef() or rel is _undef.Undef(): return _undef.make_or_raise_undef(2) result = None for elem in rel: assert elem.is_couplet if elem.right == right: if result is not None: return _undef.make_or_raise_undef() # Early Undef() exit if more than one found. result = elem.left if result is None: return _undef.make_or_raise_undef() # Undef() exit if none found. return result
def big_intersect(set_: 'PP( M )', _checked=True) -> 'P( M )': """Return the intersection of all members of ``set_``. :return: The :term:`intersection` of all members of ``set_`` or `Undef()` if ``set_`` or any of its members are not instances of :class:`~.Set`. Example code: .. code:: from algebraixlib.mathobjects import Set from algebraixlib.algebras.sets import big_intersect big_intersect(Set(Set('a', 'b'), Set('b', 'c'))) # Output: Set(Atom('b')) big_intersect(Set(Set('a', 'b'), 'a')) # Output: <algebraixlib.undef.Undef at 0x4004978> """ if _checked: if not is_member(set_): return _undef.make_or_raise_undef2(set_) for element in set_: if not is_member(element): return _undef.make_or_raise_undef(2) else: assert is_member_or_undef(set_) if set_ is _undef.Undef(): return _undef.make_or_raise_undef(2) return chain_binary_operation(set_, _functools.partial(intersect, _checked=False), is_member)
def transpose(multiclan: 'P(P(M x M) x N)', _checked=True) -> 'P(P(M x M) x N)': """Return a multiclan where all relations have their left and right components swapped. :return: The :term:`unary multi-extension` of :term:`transposition` from the :term:`algebra of relations` to the :term:`algebra of multiclans`, applied to ``multiclan``, or `Undef()` if ``multiclan`` is not a :term:`multiclan`. """ if _checked: if not is_member(multiclan): return _undef.make_or_raise_undef2(multiclan) else: assert is_member_or_undef(multiclan) if multiclan is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.unary_multi_extend(multiclan, _functools.partial( _relations.transpose, _checked=False), _checked=False) if not result.is_empty: result.cache_multiclan(_mo.CacheStatus.IS) result.cache_absolute(multiclan.cached_absolute) result.cache_functional(multiclan.cached_right_functional) result.cache_right_functional(multiclan.cached_functional) result.cache_reflexive(multiclan.cached_reflexive) result.cache_symmetric(multiclan.cached_symmetric) result.cache_transitive(multiclan.cached_transitive) result.cache_regular(multiclan.cached_right_regular) result.cache_right_regular(multiclan.cached_regular) return result
def get_rights(mclan: 'P(P(M x M) x N)', _checked=True) -> 'P( M )': r"""Return the set of the right components of all couplets in all relations in ``mclan``. :return: The :term:`union` of the :term:`right set`\s of all :term:`relation`\s in ``mclan`` or `Undef()` if ``mclan`` is not a :term:`multiclan`. """ if _checked: if not is_member(mclan): return _undef.make_or_raise_undef2(mclan) else: assert is_member_or_undef(mclan) if mclan is _undef.Undef(): return _undef.make_or_raise_undef(2) if mclan.is_empty: # The right set of an empty set is the empty set return mclan clan_itr = iter(mclan) right_set = _relations.get_rights(next(clan_itr), _checked=False) for rel in clan_itr: right_set = _sets.union(_relations.get_rights(rel, _checked=False), right_set, _checked=False) if not right_set.is_empty: if mclan.cached_is_absolute: right_set.cache_absolute(_mo.CacheStatus.IS) return right_set
def get_rights_for_left(mclan: 'P(P(M x M) x N)', left: '( M )', _checked=True) -> 'P(M x N)': """Return the multiset of the right components of all couplets in the multiclan ``mclan`` associated with the left component ``left``. :return: The :term:`right multiset` of the :term:`multiclan` ``mclan`` associated with the :term:`left component` ``left`` or `Undef()` if ``mclan`` is not a multiclan. """ if _checked: if not is_member(mclan): return _undef.make_or_raise_undef2(mclan) if left is _undef.Undef(): return _mo.Set() left = _mo.auto_convert(left) else: assert is_member_or_undef(mclan) assert _mo.is_mathobject_or_undef(left) if mclan is _undef.Undef(): return _undef.make_or_raise_undef(2) if left is _undef.Undef(): return _mo.Set() clan_itr = iter(mclan) rights = _sets.multify( _relations.get_rights_for_left(next(clan_itr), left, _checked=False)) for rel in clan_itr: rights = _multisets.add(_sets.multify( _relations.get_rights_for_left(rel, left, _checked=False)), rights, _checked=False) if not rights.is_empty: if mclan.cached_is_absolute: rights.cache_absolute(_mo.CacheStatus.IS) return rights
def get_rights(mclan: 'P(P(M x M) x N)', _checked=True) -> 'P( M )': r"""Return the set of the right components of all couplets in all relations in ``mclan``. :return: The :term:`union` of the :term:`right set`\s of all :term:`relation`\s in ``mclan`` or `Undef()` if ``mclan`` is not a :term:`multiclan`. """ if _checked: if not is_member(mclan): return _undef.make_or_raise_undef2(mclan) else: assert is_member_or_undef(mclan) if mclan is _undef.Undef(): return _undef.make_or_raise_undef(2) if mclan.is_empty: # The right set of an empty set is the empty set return mclan clan_itr = iter(mclan) right_set = _relations.get_rights(next(clan_itr), _checked=False) for rel in clan_itr: right_set = _sets.union( _relations.get_rights(rel, _checked=False), right_set, _checked=False) if not right_set.is_empty: if mclan.cached_is_absolute: right_set.cache_absolute(_mo.CacheStatus.IS) return right_set
def _to_listgen_check_args(mclan: 'P(P(M x M) x N)', offset: '( A )', limit: '( A )', _checked: bool=True) -> (): """Check the arguments of `multiclan_to_listgen` and `order_slice_to_listgen`. Return a tuple with the clean values of ``offset`` and ``limit`` or `Undef()` if there was a problem. """ if _checked: if not is_member(mclan): return _undef.make_or_raise_undef2(mclan) if isinstance(offset, _mo.Atom) and isinstance(offset.value, int): pass elif isinstance(offset, int): offset = _mo.Atom(limit) elif offset is _undef.Undef(): return _undef.make_or_raise_undef(2) else: return _undef.make_or_raise_undef() if isinstance(limit, _mo.Atom) \ and (isinstance(limit.value, int) or limit.value == float('inf')): pass elif isinstance(limit, int) or limit == float('inf'): limit = _mo.Atom(limit) elif limit is _undef.Undef(): return _undef.make_or_raise_undef(2) else: return _undef.make_or_raise_undef() else: if mclan is _undef.Undef() or offset is _undef.Undef() or limit is _undef.Undef(): return _undef.make_or_raise_undef(2) assert is_member(mclan) assert offset.is_atom and isinstance(offset.value, int) assert limit.is_atom and (isinstance(limit.value, int) or limit.value == float('inf')) return offset, limit
def union(multiset1: 'P( M x N )', multiset2: 'P( M x N )', _checked=True) -> 'P( M x N )': """Return the multiset union of ``multiset1`` with ``multiset2``. :return: The :term:`multiset union` of ``multiset1`` and ``multiset2`` or `Undef()` if ``multiset1`` or ``multiset2`` are not instances of :class:`~.Multiset`. """ # pylint: disable=too-many-branches if _checked: if not is_member(multiset1): return _undef.make_or_raise_undef2(multiset1) if not is_member(multiset2): return _undef.make_or_raise_undef2(multiset2) else: assert is_member_or_undef(multiset1) assert is_member_or_undef(multiset2) if multiset1 is _undef.Undef() or multiset2 is _undef.Undef(): return _undef.make_or_raise_undef(2) values = multiset1.data | multiset2.data result = _mo.Multiset(values, direct_load=True) if not result.is_empty: # Multiclan flags: if multiset1.cached_is_multiclan and multiset2.cached_is_multiclan: result.cache_multiclan(CacheStatus.IS) if multiset1.cached_is_absolute and multiset2.cached_is_absolute: result.cache_absolute(CacheStatus.IS) elif multiset1.cached_is_not_absolute or multiset2.cached_is_not_absolute: result.cache_absolute(CacheStatus.IS_NOT) if multiset1.cached_is_functional and multiset2.cached_is_functional: result.cache_functional(CacheStatus.IS) elif multiset1.cached_is_not_functional or multiset2.cached_is_not_functional: result.cache_functional(CacheStatus.IS_NOT) if multiset1.cached_is_right_functional and multiset2.cached_is_right_functional: result.cache_right_functional(CacheStatus.IS) elif multiset1.cached_is_not_right_functional \ or multiset2.cached_is_not_right_functional: result.cache_right_functional(CacheStatus.IS_NOT) if multiset1.cached_is_not_regular or multiset1.cached_is_not_regular: result.cache_regular(CacheStatus.IS_NOT) if multiset1.cached_is_not_right_regular or multiset1.cached_is_not_right_regular: result.cache_right_regular(CacheStatus.IS_NOT) elif multiset1.cached_is_not_multiclan or multiset2.cached_is_not_multiclan: result.cache_multiclan(CacheStatus.IS_NOT) return result
def is_superset_of(set1: 'P( M )', set2: 'P( M )', _checked=True) -> bool: r"""Return whether ``set1`` is a superset of ``set2``. :return: ``True`` if ``set1`` is a :term:`superset` of ``set2``, ``False`` if not. Return `Undef()` if ``set1`` or ``set2`` are not :term:`set`\s (that is, instances of :class:`~.Set`). """ if _checked: if not is_member(set1): return _undef.make_or_raise_undef2(set1) if not is_member(set2): return _undef.make_or_raise_undef2(set2) else: assert is_member_or_undef(set1) assert is_member_or_undef(set2) if set1 is _undef.Undef() or set2 is _undef.Undef(): return _undef.make_or_raise_undef(2) return set1.data.issuperset(set2.data)
def superstrict(clan1: 'PP(M x M)', clan2: 'PP(M x M)', _checked=True) -> 'PP(M x M)': r"""Return the superstriction of ``clan1`` and ``clan2``. The :term:`superstriction` of two :term:`clan`\s is a clan that contains all :term:`relation`\s from ``clan1`` that are a :term:`superset` of a relation from ``clan2``. :return: The :term:`binary extension` of :term:`superstriction` from the :term:`algebra of sets` to the :term:`algebra of clans` applied to ``clan1`` and ``clan2``, or `Undef()` if ``clan1`` or ``clan2`` are not clans. """ if _checked: if not is_member(clan1): return _undef.make_or_raise_undef2(clan1) if not is_member(clan2): return _undef.make_or_raise_undef2(clan2) else: assert is_member_or_undef(clan1) assert is_member_or_undef(clan2) if clan1 is _undef.Undef() or clan2 is _undef.Undef(): return _undef.make_or_raise_undef(2) result = _extension.binary_extend(clan1, clan2, _functools.partial(_sets.superstrict, _checked=False), _checked=False) if not result.is_empty: result.cache_clan(_mo.CacheStatus.IS) if clan1.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if clan1.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) if clan1.cached_is_reflexive: result.cache_reflexive(_mo.CacheStatus.IS) if clan1.cached_is_symmetric: result.cache_symmetric(_mo.CacheStatus.IS) if clan1.cached_is_transitive: result.cache_transitive(_mo.CacheStatus.IS) if clan1.cached_is_regular: result.cache_regular(_mo.CacheStatus.IS) if clan1.cached_is_right_regular: result.cache_right_regular(_mo.CacheStatus.IS) return result
def big_intersect(set_of_multisets: 'PP( M x N )', _checked=True) -> 'P( M x N )': """Return the multiset intersection of all members of ``multiset``. :return: The :term:`multiset intersection` of all members of ``set_of_multisets`` or `Undef()` if ``set_of_multisets`` is not a :class:`~.Set` or any of its members are not instances of :class:`~.Multiset`. """ if _checked: if not isinstance(set_of_multisets, _mo.Set): return _undef.make_or_raise_undef2(set_of_multisets) for element in set_of_multisets: if not is_member(element): return _undef.make_or_raise_undef2(element) else: assert _sets.is_member_or_undef(set_of_multisets) if set_of_multisets is _undef.Undef(): return _undef.make_or_raise_undef(2) return _sets.chain_binary_operation( set_of_multisets, _functools.partial(intersect, _checked=False), is_member)
def union(multiset1: 'P( M x N )', multiset2: 'P( M x N )', _checked=True) -> 'P( M x N )': """Return the multiset union of ``multiset1`` with ``multiset2``. :return: The :term:`multiset union` of ``multiset1`` and ``multiset2`` or `Undef()` if ``multiset1`` or ``multiset2`` are not instances of :class:`~.Multiset`. """ # pylint: disable=too-many-branches if _checked: if not is_member(multiset1): return _undef.make_or_raise_undef2(multiset1) if not is_member(multiset2): return _undef.make_or_raise_undef2(multiset2) else: assert is_member_or_undef(multiset1) assert is_member_or_undef(multiset2) if multiset1 is _undef.Undef() or multiset2 is _undef.Undef(): return _undef.make_or_raise_undef(2) values = multiset1.data | multiset2.data result = _mo.Multiset(values, direct_load=True) if not result.is_empty: # Multiclan flags: if multiset1.cached_is_multiclan and multiset2.cached_is_multiclan: result.cache_multiclan(_mo.CacheStatus.IS) if multiset1.cached_is_absolute and multiset2.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) elif multiset1.cached_is_not_absolute or multiset2.cached_is_not_absolute: result.cache_absolute(_mo.CacheStatus.IS_NOT) if multiset1.cached_is_functional and multiset2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) elif multiset1.cached_is_not_functional or multiset2.cached_is_not_functional: result.cache_functional(_mo.CacheStatus.IS_NOT) if multiset1.cached_is_right_functional and multiset2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) elif multiset1.cached_is_not_right_functional \ or multiset2.cached_is_not_right_functional: result.cache_right_functional(_mo.CacheStatus.IS_NOT) if multiset1.cached_is_not_regular or multiset1.cached_is_not_regular: result.cache_regular(_mo.CacheStatus.IS_NOT) if multiset1.cached_is_not_right_regular or multiset1.cached_is_not_right_regular: result.cache_right_regular(_mo.CacheStatus.IS_NOT) elif multiset1.cached_is_not_multiclan or multiset2.cached_is_not_multiclan: result.cache_multiclan(_mo.CacheStatus.IS_NOT) return result
def superstrict(set1: 'P( M )', set2: 'P( M )', _checked=True) -> 'P( M )': r"""Return ``set1`` if it is a superset of ``set2``, otherwise return `Undef()`. :return: Return the :term:`superstriction` of ``set1`` and ``set1``; that is, return ``set1`` if it is a :term:`superset` of ``set2`` or `Undef()` if not. Also return `Undef()` if ``set1`` or ``set2`` are not :term:`set`\s (that is, instances of :class:`~.Set`). """ # pylint: disable=too-many-branches if _checked: if not is_member(set1): return _undef.make_or_raise_undef2(set1) if not is_member(set2): return _undef.make_or_raise_undef2(set2) else: assert is_member_or_undef(set1) assert is_member_or_undef(set2) if set1 is _undef.Undef() or set2 is _undef.Undef(): return _undef.make_or_raise_undef(2) if not is_superset_of(set1, set2, _checked=False): return _undef.make_or_raise_undef(2) if not set1.is_empty: # Relation flags: if set1.cached_is_relation: if set2.cached_is_not_absolute: set1.cache_absolute(_mo.CacheStatus.IS_NOT) if set2.cached_is_not_functional: set1.cache_functional(_mo.CacheStatus.IS_NOT) if set2.cached_is_not_right_functional: set1.cache_right_functional(_mo.CacheStatus.IS_NOT) # Clan flags: if set1.cached_is_clan: if set2.cached_is_not_absolute: set1.cache_absolute(_mo.CacheStatus.IS_NOT) if set2.cached_is_not_functional: set1.cache_functional(_mo.CacheStatus.IS_NOT) if set2.cached_is_not_right_functional: set1.cache_right_functional(_mo.CacheStatus.IS_NOT) if set2.cached_is_not_regular: set1.cache_regular(_mo.CacheStatus.IS_NOT) if set2.cached_is_not_right_regular: set1.cache_right_regular(_mo.CacheStatus.IS_NOT) return set1
def intersect(set1: 'P( M )', set2: 'P( M )', _checked=True) -> 'P( M )': r"""Return the intersection of ``set1`` with ``set2``. :return: The :term:`binary intersection` of ``set1`` and ``set2`` or `Undef()` if ``set1`` or ``set2`` are not :term:`set`\s (that is, instances of :class:`~.Set`). """ # pylint: disable=too-many-branches if _checked: if not is_member(set1): return _undef.make_or_raise_undef2(set1) if not is_member(set2): return _undef.make_or_raise_undef2(set2) else: assert is_member_or_undef(set1) assert is_member_or_undef(set2) if set1 is _undef.Undef() or set2 is _undef.Undef(): return _undef.make_or_raise_undef(2) values = set1.data.intersection(set2.data) result = _mo.Set(values, direct_load=True) if not result.is_empty: # Relation flags: if set1.cached_is_relation or set2.cached_is_relation: result.cache_relation(_mo.CacheStatus.IS) if set1.cached_is_absolute or set2.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) if set1.cached_is_functional or set2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if set1.cached_is_right_functional or set2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) # Clan flags: if set1.cached_is_clan or set2.cached_is_clan: result.cache_clan(_mo.CacheStatus.IS) if set1.cached_is_absolute or set2.cached_is_absolute: result.cache_absolute(_mo.CacheStatus.IS) if set1.cached_is_functional or set2.cached_is_functional: result.cache_functional(_mo.CacheStatus.IS) if set1.cached_is_right_functional or set2.cached_is_right_functional: result.cache_right_functional(_mo.CacheStatus.IS) if set1.cached_is_regular or set2.cached_is_regular: result.cache_regular(_mo.CacheStatus.IS) if set1.cached_is_right_regular or set2.cached_is_right_regular: result.cache_right_regular(_mo.CacheStatus.IS) return result
def single(set_: _mo.Set): """Return the single element of ``set_``. :return: Return the single element of ``set_``, or `Undef()` if ``set_`` has not exactly one element or is not a :term:`set` (that is, an instance of :class:`~.Set`). """ if not is_member(set_): return _undef.make_or_raise_undef2(set_) if set_.cardinality == 1: return next(iter(set_)) return _undef.make_or_raise_undef(2)
def functional_add(func: 'P(M x M)', element: 'M x M') -> 'P(M x M)': """Add ``element`` to ``func`` and return the new functional relation. :param func: The source data. Must be a :term:`function`. It must not contain a :term:`couplet` with the same :term:`left component` as ``element``. :param element: The element to be added to ``func``. Must be a :class:`~.Couplet` and its :term:`left component` must not be a left component in ``func``. :return: The new relation, composed of ``func`` and ``element``. """ if not is_member(func) or not is_functional(func): return _undef.make_or_raise_undef2(func) if not _couplets.is_member(element): return _undef.make_or_raise_undef2(element) if _sets.is_subset_of(_mo.Set(element.left), get_lefts(func)): return _undef.make_or_raise_undef(2) element_func = _mo.Set(element).cache_relation(_mo.CacheStatus.IS) result = _sets.union(func, element_func) assert result.cached_is_relation and is_functional(result) result.cache_functional(_mo.CacheStatus.IS) return result