def make_redo_do(i, do, redo): '''Function adds redo and do i times to a given tree''' sequence = TreeNode('sequence:1;', format=1) for j in range(i): sequence.add_child(child=redo.copy()) sequence.add_child(child=do.copy()) return sequence
def assert_depth_first_traverse_on_one_level_tree(self, function): node1 = TreeNode('1') node11 = node1.add_child('11') node12 = node1.add_child('12') node13 = node1.add_child('13') function(node1, self.node_visitor) self.assertEqual([node1, node11, node12, node13], self.visited_nodes)
def test_breadth_first_traverse_on_one_level_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node12 = node1.add_child('12') node13 = node1.add_child('13') node1.breadth_first_traverse(self.node_visitor) self.assertEqual([node1, node11, node12, node13], self.visited_nodes)
def test_breadth_first_traverse_gen_on_one_level_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node12 = node1.add_child('12') node13 = node1.add_child('13') generated_nodes = [n for n in node1.breadth_first_traverse_gen()] self.assertEqual([node1, node11, node12, node13], generated_nodes)
def test_height_of_one_level_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node12 = node1.add_child('12') node13 = node1.add_child('13') self.assertEqual(1, node1.height) self.assertEqual(0, node11.height) self.assertEqual(0, node12.height) self.assertEqual(0, node13.height)
def test_size_of_one_level_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node12 = node1.add_child('12') node13 = node1.add_child('13') self.assertEqual(4, node1.size) self.assertEqual(1, node11.size) self.assertEqual(1, node12.size) self.assertEqual(1, node13.size)
def run_command(string, root: tree.TreeNode, current: tree.TreeNode): command = string.split(' ') function_name = command[0] if function_name == 'ls': if len(command) == 1: current.list_children() else: path = command[1].split('/') tmp = root.arrive_node(path) if tmp is None: print('No such path.') else: tmp.list_children() elif function_name == 'cd': if len(command) == 1: print('Path is needed.') else: path = command[1].split('/') tmp = root.arrive_node(path) if tmp is None: print('No such path.') else: current = tmp elif function_name == 'pwd': current.print_path() elif function_name == 'mkdir': if len(command) == 1: print('Path is needed.') else: current.add_child(tree.TreeNode(command[1])) elif function_name == 'touch': if len(command) == 1: print('Path is needed.') else: current.add_child(command[1]) elif function_name == 'rm': if len(command) == 1: print('Path is needed.') else: current.del_child(command[1]) elif function_name == 'tree': root.show_tree() else: print('Command not found.') return current
def unfold_loop(loop_nodes, max_iterations): '''Function takes the deepest loop node and unfolds this loop into a choice between zero and the maximum number of iterations of do and redo''' last_loop = loop_nodes[-1] branch_probabilities = compute_probabilities_loop(max_iterations) '''create a new tree with a sequence as root node and three children: -original do-child of the loop -a choice between 0,...,max_iterations of redo and do children -original exit-child''' unfolded_loop = TreeNode('sequence:1;', format=1) children_loop = last_loop.get_children() unfolded_loop.add_child(child=children_loop[0].copy()) second_child = TreeNode('(tau:' + str(branch_probabilities[0]) + ')choice:1;', format=1) for i in range(max_iterations): sequence = make_redo_do(i + 1, children_loop[0].copy(), children_loop[1].copy()) second_child.add_child(child=sequence, dist=branch_probabilities[i + 1]) unfolded_loop.add_child(child=second_child) unfolded_loop.add_child(child=children_loop[2].copy()) '''replace old loop node (with subtree) by unfolded loop node''' for child in last_loop.get_children(): child.detach() last_loop.name = 'sequence' for child in unfolded_loop.get_children(): last_loop.add_child(child)
def test_repr_node_with_parent(self): root = TreeNode('a') node = root.add_child('b') self.assertEqual( '[key=a, parent=None, children=[[key=b, parent=a, children=[]]]]', repr(root)) self.assertEqual('[key=b, parent=a, children=[]]', repr(node))
class UninformedSearch: def __init__(self, search_problem, state, container): assert isinstance(search_problem, SearchProblem) assert isinstance(container, Container) # Keep search problem and container object for later use. self.search_problem = search_problem self.fringe = container # Create a set of visited nodes and add the current state to it. self.visited = set() self.visited.add(self.search_problem.get_hashable(state)) # Create a root tree node and add it to the fringe. self.current_node = TreeNode(None, state) self.fringe.put_one(self.current_node) def run(self): while True: # Stop searching if the fringe is empty. if self.fringe.size() == 0: break # Take the next element from the fringe self.current_node = self.fringe.take() assert isinstance(self.current_node, TreeNode) state = self.current_node.state # Check if the goal has been reached. if self.search_problem.is_goal(state): break # Get the children states of the current search state. successors = self.search_problem.get_children(state) # Generate hashable value for each of the children states. successors = list( map(lambda s: [s, self.search_problem.get_hashable(s)], successors)) # Filter out those children states which have been already visited. successors = list( filter(lambda s: s[1] not in self.visited, successors)) # Expand the current search tree node. child_nodes = [] for child_state, hashable in successors: child_node = self.current_node.add_child(child_state) child_nodes.append(child_node) self.visited.add(hashable) # Add the children nodes to the fringe. self.fringe.put_many(child_nodes) return self.current_node
def test_size_three_level_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node111 = node11.add_child('111') node1111 = node111.add_child('1111') node1112 = node111.add_child('1112') node12 = node1.add_child('12') node121 = node12.add_child('121') node122 = node12.add_child('122') node13 = node1.add_child('13') self.assertEqual(9, node1.size) self.assertEqual(4, node11.size) self.assertEqual(3, node111.size) self.assertEqual(1, node1111.size) self.assertEqual(1, node1112.size) self.assertEqual(3, node12.size) self.assertEqual(1, node121.size) self.assertEqual(1, node122.size) self.assertEqual(1, node13.size)
def test_depth_first_traverse_gen_on_five_level_chain_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node111 = node11.add_child('111') node1111 = node111.add_child('1111') node11111 = node1111.add_child('11111') node111111 = node11111.add_child('111111') generated_nodes = [n for n in node1.depth_first_traverse_gen()] self.assertEqual( [node1, node11, node111, node1111, node11111, node111111], generated_nodes)
def test_breadth_first_traverse_on_five_level_chain_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node111 = node11.add_child('111') node1111 = node111.add_child('1111') node11111 = node1111.add_child('11111') node111111 = node11111.add_child('111111') node1.breadth_first_traverse(self.node_visitor) self.assertEqual( [node1, node11, node111, node1111, node11111, node111111], self.visited_nodes)
def spacynode_to_treenode(spacy_token, parent=None, root=None): """Transforms a SpaCy node (spacy.token) in a Treenode. A Treenode is a pickable version of a SpaCy token parsed tree. Both parent and root parameters are only used internally, and should not be passed by the caller. Args: spacy_token: The SpaCy node itself (spacy.token). parent: The Treenode node parent, if exists (Treenode). This is needed so references are maintained accross the tree as to make traversing possible. root: The Treenode root node, if exists (Treenode). This is needed so references are maintained accross the tree as to make traversing possible. Returns: A Treenode pickable copy of the original SpaCy tree. """ # if further attributes are needed on the copied version, this constructor will need change node = TreeNode(spacy_token.dep_, spacy_token.pos_, spacy_token.orth_, spacy_token.idx, spacy_token.n_lefts, spacy_token.n_rights) if isinstance(parent, TreeNode): node.set_head(parent) elif parent is None: node.set_is_root() else: raise ValueError('Unsupported parent node provided to spacy_to_tree2 method') if isinstance(root, TreeNode): node.set_root(root) elif root is None: root = node node.set_is_root() else: raise ValueError('Unsupported root node provided to spacy_to_tree2 method') for child in spacy_token.children: node.add_child(spacynode_to_treenode(child, node, root)) return node
def test_size_of_five_level_chain_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node111 = node11.add_child('111') node1111 = node111.add_child('1111') node11111 = node1111.add_child('11111') node111111 = node11111.add_child('111111') self.assertEqual(6, node1.size) self.assertEqual(5, node11.size) self.assertEqual(4, node111.size) self.assertEqual(3, node1111.size) self.assertEqual(2, node11111.size) self.assertEqual(1, node111111.size)
def test_add_child(self): key1 = 'a' root = TreeNode(key1) key2 = 'b' node = root.add_child(key2) self.assertEqual(None, root.parent) self.assertEqual(key1, root.key) self.assertEqual([node], root.children) self.assertEqual(root, node.parent) self.assertEqual(key2, node.key) self.assertEqual([], node.children)
def test_height_of_five_level_chain_tree(self): node1 = TreeNode('1') node11 = node1.add_child('11') node111 = node11.add_child('111') node1111 = node111.add_child('1111') node11111 = node1111.add_child('11111') node111111 = node11111.add_child('111111') self.assertEqual(5, node1.height) self.assertEqual(4, node11.height) self.assertEqual(3, node111.height) self.assertEqual(2, node1111.height) self.assertEqual(1, node11111.height) self.assertEqual(0, node111111.height)
def setUp(self): root = TreeNode('fruit') root.add_child(TreeNode('lemon')) root.add_child(TreeNode('strawberry')) self.fruit = root
def test_duplicate(self): node_01 = TreeNode('A', 1) node_02 = TreeNode('X', 2) node_03 = TreeNode('H', 3) node_04 = TreeNode('G', 4) node_05 = TreeNode('E', 5) node_06 = TreeNode('G', 6) node_07 = TreeNode('E', 7) node_08 = TreeNode('H', 8) node_09 = TreeNode('A', 9) node_10 = TreeNode('B', 10) node_11 = TreeNode('C', 11) node_12 = TreeNode('H', 12) node_13 = TreeNode('A', 13) node_14 = TreeNode('C', 14) node_15 = TreeNode('B', 15) node_16 = TreeNode('E', 16) node_17 = TreeNode('E', 17) node_18 = TreeNode('E', 18) node_19 = TreeNode('E', 19) node_20 = TreeNode('A', 20) node_21 = TreeNode('B', 21) node_22 = TreeNode('C', 22) node_23 = TreeNode('A', 23) node_24 = TreeNode('B', 24) node_25 = TreeNode('C', 25) node_26 = TreeNode('D', 26) node_27 = TreeNode('A', 27) node_28 = TreeNode('B', 28) node_29 = TreeNode('C', 29) node_30 = TreeNode('A', 30) node_31 = TreeNode('B', 31) node_32 = TreeNode('C', 32) node_33 = TreeNode('D', 33) node_01.add_child(node_02) node_01.add_child(node_03) node_01.add_child(node_04) node_03.add_child(node_05) node_03.add_child(node_06) node_03.add_child(node_07) node_04.add_child(node_08) node_05.add_child(node_09) node_05.add_child(node_10) node_05.add_child(node_11) node_06.add_child(node_12) node_07.add_child(node_13) node_07.add_child(node_14) node_07.add_child(node_15) node_08.add_child(node_16) node_08.add_child(node_17) node_12.add_child(node_18) node_12.add_child(node_19) node_16.add_child(node_20) node_16.add_child(node_21) node_16.add_child(node_22) node_17.add_child(node_23) node_17.add_child(node_24) node_17.add_child(node_25) node_17.add_child(node_26) node_18.add_child(node_27) node_18.add_child(node_28) node_18.add_child(node_29) node_19.add_child(node_30) node_19.add_child(node_31) node_19.add_child(node_32) node_19.add_child(node_33) root = node_01 # Compare trees by structure and by values by_struct_and_value_group_01 = { # A leafs node_09, node_13, node_20, node_23, node_27, node_30 } by_struct_and_value_group_02 = { # B leafs node_10, node_15, node_21, node_24, node_28, node_31 } by_struct_and_value_group_03 = { # C leafs node_11, node_14, node_22, node_25, node_29, node_32 } by_struct_and_value_group_04 = { # D leafs node_26, node_33 } by_struct_and_value_group_05 = { # height 2 group 1 node_05, node_18, node_16 } by_struct_and_value_group_06 = { # height 2 group 2 node_17, node_19 } by_struct_and_value_group_07 = { # height 3 node_08, node_12 } by_struct_and_value_group_08 = { # height 4 node_04, node_06 } expected_duplicate_groups = [ by_struct_and_value_group_01, by_struct_and_value_group_02, by_struct_and_value_group_03, by_struct_and_value_group_04, by_struct_and_value_group_05, by_struct_and_value_group_06, by_struct_and_value_group_07, by_struct_and_value_group_08, ] print("Expected:") pprint(expected_duplicate_groups) dup_groups = root.duplicates(minheight=1, compare_values=True) print("Actual:") pprint(dup_groups) assert len(dup_groups) == len(expected_duplicate_groups), \ 'Sizes of expected and actual groups are not equal' match = False for exp_set in expected_duplicate_groups: match = False for act_set in dup_groups: if exp_set ^ act_set == set(): match = True break # inner loop assert match, \ "Expected group not found in result set. Expected: {}".format(exp_set)
#!/usr/bin/python3 from tree import TreeNode if __name__ == '__main__': root = TreeNode('Harry') node1 = root.add_child('Jane') node11 = node1.add_child('Jog') node12 = node1.add_child('Diane') node121 = node12.add_child('George') node1211 = node121.add_child('Jill') node12111 = node1211.add_child('Carol') node122 = node12.add_child('Mary') node13 = node1.add_child('Mark') node2 = root.add_child('Bill') node21 = node2.add_child('Grace') root.display() print('***** DEPTH-FIRST GENERATOR ITERATION *****') for node in root.depth_first_traverse_gen(): print(node) print('***** DEPTH-FIRST ITERATION *****') root.depth_first_traverse(print) print('***** BREADTH-FIRST GENERATOR ITERATION *****') for node in root.breadth_first_traverse_gen(): print(node) print('***** BREADTH-FIRST ITERATION *****')
invalid_input = True break if invalid_input: print('Invalid input!') continue calc.set_infix_string(user_input) postfix = calc.get_postfix_notation() memory = [] i = 0 while len(postfix) > i: current = postfix[i] if current in operators_set: node = TreeNode(current) child2 = memory.pop() child1 = memory.pop() child1.set_parent(node) child2.set_parent(node) node.add_child(child1) node.add_child(child2) memory.append(node) else: node = TreeNode(current) memory.append(node) i += 1 tree = Tree('0') tree.root = memory.pop() print(tree.root) print('result:', calc.calculate()) print()
def _TreeGenerate(self, D, A, v=None, depth=0): """Generate a decision tree. Note that all data vectors are Lists. Args: D (Tuple[x, y]): x is feature vectors and y is label vectors. A (List[Tuple(name, type)]): arrtributes index list. """ root = TreeNode() root.set_value(v) X, y = D # all the samples belong to the same class if len(set(y)) == 1: root.set_label(y[0]) return root # A is empty set or all the samples are the same on arrtributes set A or achieving the maximum depth if len(A) == 0 or ID3DecisionTree._is_same(X) or ( self.max_depth > 0 and depth + 1 > self.max_depth): most_common_class = Counter(y).most_common(1)[0][0] root.set_label(most_common_class) return root # get the optimal spliting attribute optimal_attribute_idx, optimal_point = self._get_optimal_attribute_idx( D, A) buf_v = dict() for index, sample in enumerate(X): v = sample[optimal_attribute_idx] if A[optimal_attribute_idx][1] != "CONTINUOUS": if v not in buf_v: buf_v[v] = [[], []] buf_v[v][0].append(sample[:optimal_attribute_idx] + sample[optimal_attribute_idx + 1:]) buf_v[v][1].append(y[index]) else: if "pos" not in buf_v: buf_v["pos"] = [[], []] buf_v["neg"] = [[], []] if v <= optimal_point: buf_v["neg"][0].append(sample[:optimal_attribute_idx] + sample[optimal_attribute_idx + 1:]) buf_v["neg"][1].append(y[index]) else: buf_v["pos"][0].append(sample[:optimal_attribute_idx] + sample[optimal_attribute_idx + 1:]) buf_v["pos"][1].append(y[index]) # set the optimal attribute for root root.set_attr(A[optimal_attribute_idx][0]) root.set_attr_idx(self.attr2idx[A[optimal_attribute_idx][0]]) new_A = A[:optimal_attribute_idx] + A[optimal_attribute_idx + 1:] for v in buf_v: D_v = tuple(buf_v[v]) if A[optimal_attribute_idx][1] != "CONTINUOUS": if D_v[0]: root.add_child(self._TreeGenerate(D_v, new_A, v, depth + 1)) else: if D_v[0]: if v == "pos": root.add_child( self._TreeGenerate(D_v, new_A, (">", optimal_point), depth + 1)) else: root.add_child( self._TreeGenerate(D_v, new_A, ("<", optimal_point), depth + 1)) return root
class TestTreeNode(unittest.TestCase): def setUp(self): self.root_data = 1 self.root = TreeNode(self.root_data) def test_data_descriptor(self): self.assertEqual(self.root_data, self.root.data) with self.assertRaises(AttributeError): self.root.data = 2 def test_insert_child(self): with self.assertRaises(TypeError): self.root.insert_child(2) with self.assertRaises(TypeError): self.root.insert_child(0, 2) with self.assertRaises(TypeError): self.root.insert_child(TreeNode(2)) self.root.insert_child(0, TreeNode(2)) self.root.insert_child(0, TreeNode(3)) self.root.insert_child(10, TreeNode(10)) self.assertEqual(3, self.root._children[0].data) self.assertEqual(2, self.root._children[1].data) self.assertEqual(10, self.root._children[2].data) def test_add_child(self): with self.assertRaises(TypeError): self.root.add_child(2) for i in range(2, 5): self.root.add_child(TreeNode(i)) for i in range(2, 5): self.assertEqual( i, self.root._children[i-2].data ) def test_children(self): itr = self.root.children() with self.assertRaises(StopIteration): next(itr) data = [2, 3, 4, 5] for i in data: self.root.add_child(TreeNode(i)) itr = self.root.children() first = next(itr) self.assertTrue(issubclass(type(first), TreeNode)) self.assertEquals(data[0], first.data) for i, node in enumerate(itr): self.assertEquals(data[i+1], node.data) def test_getitem(self): with self.assertRaises(IndexError): tmp = self.root[0] data = [2, 3, 4, 5] for i in data: self.root.add_child(TreeNode(i)) first = self.root[0] self.assertTrue(issubclass(type(first), TreeNode)) self.assertEquals(data[0], first.data) for i in range(1, len(data)): self.assertEquals(data[i], self.root[i].data) def test_duplicate(self): node_01 = TreeNode('A', 1) node_02 = TreeNode('X', 2) node_03 = TreeNode('H', 3) node_04 = TreeNode('G', 4) node_05 = TreeNode('E', 5) node_06 = TreeNode('G', 6) node_07 = TreeNode('E', 7) node_08 = TreeNode('H', 8) node_09 = TreeNode('A', 9) node_10 = TreeNode('B', 10) node_11 = TreeNode('C', 11) node_12 = TreeNode('H', 12) node_13 = TreeNode('A', 13) node_14 = TreeNode('C', 14) node_15 = TreeNode('B', 15) node_16 = TreeNode('E', 16) node_17 = TreeNode('E', 17) node_18 = TreeNode('E', 18) node_19 = TreeNode('E', 19) node_20 = TreeNode('A', 20) node_21 = TreeNode('B', 21) node_22 = TreeNode('C', 22) node_23 = TreeNode('A', 23) node_24 = TreeNode('B', 24) node_25 = TreeNode('C', 25) node_26 = TreeNode('D', 26) node_27 = TreeNode('A', 27) node_28 = TreeNode('B', 28) node_29 = TreeNode('C', 29) node_30 = TreeNode('A', 30) node_31 = TreeNode('B', 31) node_32 = TreeNode('C', 32) node_33 = TreeNode('D', 33) node_01.add_child(node_02) node_01.add_child(node_03) node_01.add_child(node_04) node_03.add_child(node_05) node_03.add_child(node_06) node_03.add_child(node_07) node_04.add_child(node_08) node_05.add_child(node_09) node_05.add_child(node_10) node_05.add_child(node_11) node_06.add_child(node_12) node_07.add_child(node_13) node_07.add_child(node_14) node_07.add_child(node_15) node_08.add_child(node_16) node_08.add_child(node_17) node_12.add_child(node_18) node_12.add_child(node_19) node_16.add_child(node_20) node_16.add_child(node_21) node_16.add_child(node_22) node_17.add_child(node_23) node_17.add_child(node_24) node_17.add_child(node_25) node_17.add_child(node_26) node_18.add_child(node_27) node_18.add_child(node_28) node_18.add_child(node_29) node_19.add_child(node_30) node_19.add_child(node_31) node_19.add_child(node_32) node_19.add_child(node_33) root = node_01 # Compare trees by structure and by values by_struct_and_value_group_01 = { # A leafs node_09, node_13, node_20, node_23, node_27, node_30 } by_struct_and_value_group_02 = { # B leafs node_10, node_15, node_21, node_24, node_28, node_31 } by_struct_and_value_group_03 = { # C leafs node_11, node_14, node_22, node_25, node_29, node_32 } by_struct_and_value_group_04 = { # D leafs node_26, node_33 } by_struct_and_value_group_05 = { # height 2 group 1 node_05, node_18, node_16 } by_struct_and_value_group_06 = { # height 2 group 2 node_17, node_19 } by_struct_and_value_group_07 = { # height 3 node_08, node_12 } by_struct_and_value_group_08 = { # height 4 node_04, node_06 } expected_duplicate_groups = [ by_struct_and_value_group_01, by_struct_and_value_group_02, by_struct_and_value_group_03, by_struct_and_value_group_04, by_struct_and_value_group_05, by_struct_and_value_group_06, by_struct_and_value_group_07, by_struct_and_value_group_08, ] print("Expected:") pprint(expected_duplicate_groups) dup_groups = root.duplicates(minheight=1, compare_values=True) print("Actual:") pprint(dup_groups) assert len(dup_groups) == len(expected_duplicate_groups), \ 'Sizes of expected and actual groups are not equal' match = False for exp_set in expected_duplicate_groups: match = False for act_set in dup_groups: if exp_set ^ act_set == set(): match = True break # inner loop assert match, \ "Expected group not found in result set. Expected: {}".format(exp_set)
from tree import TreeNode from dfs import dfs from dfs import width_counter tree_node1 = TreeNode(1) tree_node2 = TreeNode(2) tree_node3 = TreeNode(3) tree_node4 = TreeNode(4) tree_node5 = TreeNode(5) tree_node6 = TreeNode(6) tree_node7 = TreeNode(7) tree_node8 = TreeNode(8) tree_node1.add_child(tree_node2) tree_node1.add_child(tree_node3) tree_node2.add_child(tree_node4) tree_node2.add_child(tree_node5) tree_node3.add_child(tree_node8) tree_node8.add_child(tree_node6) tree_node8.add_child(tree_node7) goal_path = dfs(tree_node1, 7) print(width_counter(goal_path))
node_19 = TreeNode('E', 19) node_20 = TreeNode('A', 20) node_21 = TreeNode('B', 21) node_22 = TreeNode('C', 22) node_23 = TreeNode('A', 23) node_24 = TreeNode('B', 24) node_25 = TreeNode('C', 25) node_26 = TreeNode('D', 26) node_27 = TreeNode('A', 27) node_28 = TreeNode('B', 28) node_29 = TreeNode('C', 29) node_30 = TreeNode('A', 30) node_31 = TreeNode('B', 31) node_32 = TreeNode('C', 32) node_33 = TreeNode('D', 33) node_01.add_child(node_02) node_01.add_child(node_03) node_01.add_child(node_04) node_03.add_child(node_05) node_03.add_child(node_06) node_03.add_child(node_07) node_04.add_child(node_08) node_05.add_child(node_09) node_05.add_child(node_10) node_05.add_child(node_11) node_06.add_child(node_12) node_07.add_child(node_13) node_07.add_child(node_14) node_07.add_child(node_15) node_08.add_child(node_16) node_08.add_child(node_17)
def main(): root = TreeNode("Electronics") laptop = TreeNode("Laptop") laptop.add_child(TreeNode("Mac")) laptop.add_child(TreeNode("Surface")) laptop.add_child(TreeNode("Thinkpad")) cellphone = TreeNode("Cell Phone") cellphone.add_child(TreeNode("iPhone")) cellphone.add_child(TreeNode("Google Pixel")) cellphone.add_child(TreeNode("Vivo")) tv = TreeNode("TV") tv.add_child(TreeNode("Samsung")) tv.add_child(TreeNode("LG")) root.add_child(laptop) root.add_child(cellphone) root.add_child(tv) root.print_tree()
#specify the folder with the trees tree_files = glob.glob(tree_folder + "*.nw") #for each tree for filepath in tree_files: #generate traces t = TreeNode(filepath,format=1) if t.get_tree_root().name == 'choice': traces = [] children = t.get_children() for i in range(no_cases): child = select_child(children) if child.is_leaf(): artificial_parent = TreeNode('sequence:1;') artificial_parent.add_child(child=child) simulator = TraceSimulator(artificial_parent.write(format=1,format_root_node=True), record_timestamps) else: simulator = TraceSimulator(child.write(format=1,format_root_node=True), record_timestamps) traces.append(simulator.case.trace) else: simulator = LogSimulator(t.write(format=1,format_root_node=True),no_cases, record_timestamps) traces = simulator.returnLog() #add noise noise_generator = NoiseGenerator(traces, noise_probability) traces = noise_generator.resulting_traces
def test_str_node_with_parent(self): root = TreeNode('a') node = root.add_child('b') self.assertEqual('a', str(root)) self.assertEqual('b', str(node))
def setUp(self): a_node = TreeNode('A') b_node = TreeNode('B') a_node.add_child(b_node) c_node = TreeNode('C') b_node.add_child(c_node) self.tree_one = Tree(a_node) self.tree_one.build_caches() a_node = TreeNode('A') b_node = TreeNode('B') c_node = TreeNode('C') d_node = TreeNode('D') a_node.add_child(b_node) a_node.add_child(c_node) c_node.add_child(d_node) self.tree_two = Tree(a_node) self.tree_two.build_caches() a_node = TreeNode('A') b_node = TreeNode('B') c_node = TreeNode('C') d_node = TreeNode('D') e_node = TreeNode('E') a_node.add_child(b_node) a_node.add_child(c_node) c_node.add_child(d_node) d_node.add_child(e_node) self.tree_three = Tree(a_node) self.tree_three.build_caches()
def levelWidth(root): END = 'end of level' widths = [0] queue = deque([root, END]) # END will remain after all nodes processed while len(queue) > 1: node = queue.popleft() if node is END: widths.append(0) queue.append(END) else: queue.extend(node.children) widths[-1] += 1 return widths n = TreeNode('root') for i in range(3): n.add_child(f'node {i}') for c in n.children: c.add_child(f'node {c.data} leaf 1') c.add_child(f'node {c.data} leaf 2') assert levelWidth(n) == [1, 3, 6] n.add_child('another child') assert levelWidth(n) == [1, 4, 6] print('All tests passed!')