def test_isub(self): q = MathSet(self.small2_listnum) q -= self.small2_listnum assert q == MathSet() q = MathSet(self.small2_listnum) q -= MathSet() assert q == q
def test_pop(self): # These tests could be improved by seeding random number # generation to ensure determinism. assert self.small1_set.pop() == {-1, 1} assert self.small1_set == MathSet() original = MathSet(self.small2_listnum) q = self.small2_listnum.pop() assert len(self.small2_listnum) + 1 == len(original) self.small2_listnum.add(q) assert self.small2_listnum == original
def mathset_test(): s = MathSet([1,2,[1,2] ] ) q = MathSet() q.add(1) q |= [1,2] q |= ['a', 3, {3}] c = s | s d = s | q assert(c is not s) assert(q._set == {'a',1,2,3} ) assert(q._list == [{3} ] ) assert(c._set == {1,2} ) assert(c._list == [[1,2] ] ) assert(d._set == {1,2,3,'a'} ) assert(d._list == [[1,2], {3} ] ) assert(isinstance(s, Iterable) ) assert(1 in s) assert(2 in s) assert([1, 2] in s) assert(5 not in q) assert(len(s) == 3) s.remove([1,2] ) assert([1,2] not in s) assert(s._set == {1,2} ) assert(s._list == []) assert(len(s) == 2) for item in s: print(item) """Mutable""" a = MathSet() b = MathSet([{'a':1} ] ) a |= b assert(a._set == set() ) assert(a._list == [{'a':1} ] )
def ba_test(): ba = trs.BA() aps = ['p'] ba.atomic_propositions |= {'p'} assert ('p' in ba.atomic_propositions) assert (ba.atomic_propositions == MathSet(aps)) assert (ba.alphabet == PowerSet(aps)) ba.states.add_from({'q0', 'q1'}) assert (set(ba.states) == {'q0', 'q1'}) ba.states.initial.add('q0') assert (set(ba.states.initial) == {'q0'}) ba.states.accepting.add('q1') assert (set(ba.states.accepting) == {'q1'}) ba.transitions.add('q0', 'q1', letter={'p'}) ba.transitions.add('q1', 'q1', letter={'p'}) ba.transitions.add('q1', 'q0', letter=set()) ba.transitions.add('q0', 'q0', letter=set()) logger.debug(ba) ba.save('ba.pdf') return ba
def open_fts_multiple_env_actions_test(): env_modes = MathSet({'up', 'down'}) env_choice = MathSet({'left', 'right'}) env_actions = [ { 'name': 'env_modes', 'values': env_modes, 'setter': True}, { 'name': 'env_choices', 'values': env_choice}] ts = FTS(env_actions) assert(ts.env_modes is env_modes) assert(not hasattr(ts, 'env_choices') ) assert(ts.sys_actions == MathSet() )
def __init__(self): edge_label_types = [{ 'name': self.action_label, 'values': MathSet(), 'setter': True }] super(MarkovDecisionProcess, self).__init__() super(MarkovDecisionProcess, self).add_label_types(edge_label_types, True) self.actions = self.action
def powerset_test(): s = [[1, 2], '3', {'a': 1}, 1] p = PowerSet(s) s2 = ['3', {'a': 1}, [1, 2], 1] q = PowerSet() q.math_set = MathSet(s2) assert (p.math_set == MathSet(s)) assert (q.math_set == MathSet(s)) assert (isinstance(q.math_set, MathSet)) assert (p == q) q.math_set.add(6) # CAUTION: comparing p() and q() might yield False, due to ordering f = p + q assert (isinstance(f, PowerSet)) assert (f.math_set._set == {1, '3', 6}) assert (compare_lists(f.math_set._list, [[1, 2], {'a': 1}])) return s
def test_add_from(self): self.S_ap.add_from([(0, {'ap':{'p'}}), (1, {'ap':{'q'} })]) assert len(self.S_ap) == 2 current_labels = [l["ap"] for (s,l) in self.S_ap(data=True)] assert len(current_labels) == 2 and \ MathSet(current_labels) == MathSet([{'p'}, {'q'}]) self.S_ap.add_from([(10, {'ap':{'r'} }), (11, {'ap':{'x'} })], check=False) assert len(self.S_ap) == 4 self.S_ap.add_from([(10, {'ap':{'a'} }), (11, {'ap':{'b'} })]) assert len(self.S_ap) == 4 current_labels = [l["ap"] for (s,l) in self.S_ap(data=True)] assert len(current_labels) == 4 and \ MathSet(current_labels)== MathSet([{'p'}, {'q'}, {'a'}, {'b'}]) assert MathSet([l["ap"] for (s,l) in self.S_ap(data=True)]) == MathSet(current_labels)
def test_add_untyped_keys(self): self.S_ap.add(1, foo=MathSet(['p']), check=True)
def test_add_unhashable(self): self.small1_set.add([1, 2]) assert self.small1_set == MathSet([{-1, 1}, [1, 2]])
def test_sub(self): assert self.small2_listnum - self.small2_listnum == MathSet() assert self.small1_set - self.small2_listnum == self.small1_set assert self.x - self.small2_listnum == \ MathSet(['a', 1, {'a', 'b', '8'} ] )
def setUp(self): self.x = MathSet(['a', 1, [1, 2], {'a', 'b', '8'}]) self.y = MathSet(['b', -2, [3.5, 2.25], {'/', '_'}]) self.small2_listnum = MathSet([[1, 2], 0.2]) self.small1_set = MathSet([{-1, 1}])
def setUp(self): self.p = PowerSet({1, 2, 3}) self.q_unhashable = PowerSet(MathSet([[1, 2], ["a", "b"]])) self.singleton = PowerSet(set([1])) self.empty = PowerSet()
def test_tuple(): s = MathSet((1, 2)) assert (s._set == {1, 2}) assert (s._list == [])
def test_intersection(self): assert self.x.intersection(self.small2_listnum) == MathSet([[1, 2]]) assert self.x.intersection(MathSet()) == MathSet()
def __init__(self, env_actions=None, sys_actions=None): """Instantiate finite transition system. @param env_actions: environment (uncontrolled) actions, defined as C{edge_label_types} in L{LabeledDiGraph.__init__} @param sys_actions: system (controlled) actions, defined as C{edge_label_types} in L{LabeledDiGraph.__init__} """ self._owner = 'sys' if env_actions is None: env_actions = [ {'name': 'env_actions', 'values': MathSet(), 'setter': True}] if sys_actions is None: sys_actions = [ {'name': 'sys_actions', 'values': MathSet(), 'setter': True}] # note: "sys_actions" used to be "actions" # in closed systems (old FTS) action_types = env_actions + sys_actions edge_label_types = action_types ap_labels = PowerSet() node_label_types = [ {'name': 'ap', 'values': ap_labels, 'setter': ap_labels.math_set, 'default': set()}] super(FiniteTransitionSystem, self).__init__( node_label_types, edge_label_types) # make them available also via an "actions" dicts # name, codomain, *rest = x actions = {x['name']: x['values'] for x in edge_label_types} if 'actions' in actions: msg = '"actions" cannot be used as an action type name,\n' msg += 'because if an attribute for this action type' msg += 'is requested,\n then it will conflict with ' msg += 'the dict storing all action types.' raise ValueError(msg) self.actions = actions self.atomic_propositions = self.ap self.aps = self.atomic_propositions # shortcut # action constraint used in synth.synthesize self.env_actions_must = 'xor' self.sys_actions_must = 'xor' # dot formatting self._state_dot_label_format = { 'ap': '', 'type?label': '', 'separator': r'\\n'} self._transition_dot_label_format = { 'sys_actions': 'sys', # todo: '' if no env 'env_actions': 'env', 'type?label': ':', # todo: '' if no env 'separator': r'\\n'} self._transition_dot_mask = dict() self.dot_node_shape = {'normal': 'box'} # todo: rectangle if no env self.default_export_fname = 'fts'
def test_mul(self): assert self.small2_listnum * self.small1_set == \ MathSet([([1,2], {-1, 1}), (0.2, {-1, 1})]) assert self.small2_listnum * self.small2_listnum == \ MathSet([([1,2], [1,2]), ([1,2], 0.2), (0.2, [1,2]), (0.2, 0.2)])