def test_metadata(self):
self.assertEqual(
get_ground_set(),
PowerSet(CartesianProduct(GenesisSetM(), GenesisSetN())))
self.assertEqual(
get_absolute_ground_set(),
PowerSet(CartesianProduct(GenesisSetA(), GenesisSetN())))
self.assertEqual(get_name(), 'Multisets(M): P(M x N)')
def test_GenSetN(self):
"""Basic properties of genesis set M."""
self._basic_assert(setns, GenesisSetN)
self._equality_helper(setns)
# Equality relationships.
self._inequality_assert(GenesisSetN(), GenesisSetA())
# Subset relationships.
self.assertFalse(GenesisSetN().is_subset(GenesisSetA()))
self.assertFalse(GenesisSetN() <= GenesisSetA())
# Test hashing.
self.assertNotEqual(hash(GenesisSetN()), hash(GenesisSetA()))
def test_Union(self):
"""Basic properties and subset relationships of the union."""
self._basic_assert(basic_unions, Union)
self._equality_helper(basic_unions)
# Equality relationships.
self.assertEqual(basic_unions['M'], basic_unions['M-2'])
self.assertEqual(basic_unions['M-4 U(AxM)'],
basic_unions['M-4 U(AxM)-2'])
# Subset relationships.
self._subset_assert(basic_unions['A'], basic_unions['M'])
self._subset_assert(basic_unions['A'], basic_unions['M-2'])
self._subset_assert(basic_unions['A'], basic_unions['AU(AxA)'])
self._subset_assert(basic_unions['A'], basic_unions['M-3 U(AxA)'])
self._subset_assert(basic_unions['A'], basic_unions['M-4 U(AxM)'])
self._subset_assert(basic_unions['A'], basic_unions['M-4 U(AxM)-2'])
self._subset_assert(basic_unions['M'], basic_unions['M-2'])
self._subset_deny(basic_unions['M'], basic_unions['AU(AxA)'])
self._subset_assert(basic_unions['M'], basic_unions['M-3 U(AxA)'])
self._subset_assert(basic_unions['M'], basic_unions['M-4 U(AxM)'])
self._subset_assert(basic_unions['M'], basic_unions['M-4 U(AxM)-2'])
self._subset_deny(basic_unions['M-2'], basic_unions['AU(AxA)'])
self._subset_assert(basic_unions['M-2'], basic_unions['M-3 U(AxA)'])
self._subset_assert(basic_unions['M-2'], basic_unions['M-4 U(AxM)'])
self._subset_assert(basic_unions['M-2'], basic_unions['M-4 U(AxM)-2'])
self._subset_assert(basic_unions['AU(AxA)'],
basic_unions['M-3 U(AxA)'])
self._subset_assert(basic_unions['AU(AxA)'],
basic_unions['M-4 U(AxM)'])
self._subset_assert(basic_unions['AU(AxA)'],
basic_unions['M-4 U(AxM)-2'])
self._subset_assert(basic_unions['M-3 U(AxA)'],
basic_unions['M-4 U(AxM)'])
self._subset_assert(basic_unions['M-3 U(AxA)'],
basic_unions['M-4 U(AxM)-2'])
self._subset_assert(basic_unions['M-4 U(AxM)'],
basic_unions['M-4 U(AxM)-2'])
# Special case for structure Union's conditional return in is_subset() for GenesisSetM
self.assertTrue(Union([GenesisSetM()]).is_subset(GenesisSetM()))
# String representation
self.assertEqual('M', Union([GenesisSetM()]).__str__())
self.assertEqual('(M U N)',
Union([GenesisSetM(), GenesisSetN()]).__str__())
self.assertEqual('Union([GenesisSetM()])',
Union([GenesisSetM()]).__repr__())
self.assertEqual('Union([GenesisSetM(), GenesisSetN()])',
Union([GenesisSetM(), GenesisSetN()]).__repr__())
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))
}.items()
}
_print_object_collection('setas')
#: Two 'instances' of GenesisSetM. (They should be the same.)
setms = {
key: create_test_object(GenesisSetM(), key, val)
for key, val in {
'M': None,
'M-2': None
}.items()
}
_print_object_collection('setms')
setns = {
key: create_test_object(GenesisSetN(), key, val)
for key, val in {
'N': None,
'N-2': None
}.items()
}
_print_object_collection('setns')
#: Basic CartesianProduct instances.
basic_cps = {
key: create_test_object(CartesianProduct(**val), key, val)
for key, val in {
'AxA': {
'left': GenesisSetA(),
'right': GenesisSetA()
},
# You should have received a copy of the GNU Lesser General Public License along with algebraixlib.
# If not, see <http://www.gnu.org/licenses/>.
# --------------------------------------------------------------------------------------------------
import inspect
import os
import unittest
import collections as _collections
from algebraixlib.mathobjects import Atom, CacheStatus, Couplet, Multiset, Set
from algebraixlib.structure import CartesianProduct, GenesisSetN, GenesisSetA, PowerSet, Structure
from algebraixlib.undef import Undef
# Ground set structures for the basic_sets.
_atom_multiset_struct = PowerSet(CartesianProduct(GenesisSetA(),
GenesisSetN()))
class MultisetTest(unittest.TestCase):
"""Test the Set class."""
print_examples = False
# def test_Multiset(self):
# """Create various forms of Sets."""
# if self.print_examples:
# print('(printing examples)') # Make 'nosetests -s' more readable.
# for test_set_name in basic_multisets.keys():
# self._multiset_assert(test_set_name)
# self.assertEqual("{}", str(Multiset()))
# self.assertTrue(Multiset(1) < Multiset(2))