def createClassDefine(id): classDefine, className, classMap = createClassDefineCore(id) settingsMap = tree.Node("map") settingsPair = createPair("settings", settingsMap) variantsMap = tree.Node("map") variantsPair = createPair("variants", variantsMap) propertiesMap = tree.Node("map") propertiesPair = createPair("properties", propertiesMap) membersMap = tree.Node("map") membersPair = createPair("members", membersMap) staticsMap = tree.Node("map") staticsPair = createPair("statics", staticsMap) propertiesPair.addChild(createBlockComment("properties")) membersPair.addChild(createBlockComment("members")) staticsPair.addChild(createBlockComment("statics")) settingsPair.addChild(createBlockComment("settings")) variantsPair.addChild(createBlockComment("variants")) classMap.addChild(staticsPair) classMap.addChild(propertiesPair) classMap.addChild(membersPair) classMap.addChild(settingsPair) classMap.addChild(variantsPair) return classDefine, className, classMap, settingsMap, variantsMap, propertiesMap, membersMap, staticsMap
def p_declaracao_funcao(p): '''declaracao_funcao : tipo cabecalho | cabecalho''' if len(p) > 2: p[0] = tree.Node(parser.get_next_id(), 'declaracao_funcao', p[1:]) else: p[0] = tree.Node(parser.get_next_id(), 'declaracao_funcao', ['vazio', p[1]])
def p_corpo(p): '''corpo : corpo acao | empty''' if(p[1] != None): p[0] = tree.Node(parser.get_next_id(), 'corpo', p[1:]) else: p[0] = tree.Node(parser.get_next_id(), 'corpo')
def DTL(examples, attributes, default): if not examples: return t.Node(dist=default, gain=0) elif sameclass(examples): return t.Node(dist=DISTRIBUTION(examples), gain=0) else: best_attribute, best_threshold, max_gain = choose_attribute( examples, attributes) tree = t.Node(best_attribute=best_attribute, best_threshold=best_threshold, gain=max_gain) examples_left, examples_right = separate(examples, best_attribute, best_threshold) # Pruning if len(examples_left) < 50 or len(examples_right) < 50: tree.dist = DISTRIBUTION(examples) tree.best_threshold = -1 tree.best_attribute = -1 tree.gain = 0 else: tree.left_child = DTL(examples_left, attributes, DISTRIBUTION(examples)) tree.right_child = DTL(examples_right, attributes, DISTRIBUTION(examples)) return tree
def build_tree(back, table, words): q = [] i = 0 j = len(words) label = 'TOP' top = tree.Node(label, []) count = 0 q.append((top, i, j)) while len(q) > 0: tuple_pop = q.pop() node = tuple_pop[0] i = tuple_pop[1] j = tuple_pop[2] back_tuple = back[(i, j, node.label)] if back_tuple: count += 1 k = back_tuple[0] left = tree.Node(back_tuple[1], []) node.append_child(left) q.append((left, i, k)) if back_tuple[2] is not '': right = tree.Node(back_tuple[2], []) node.append_child(right) q.append((right, k, j)) t = tree.Tree(top) # print t.__str__() # # Q2 # print "Output for the first line:" # print t.__str__() # print "Probability; ", table[(0, len(words), 'TOP')] if count > 0: return t.__str__() return ''
def _makeTree(bitstream): """ recursively construct a huffman tree from the encoding bit stream based on the schema specified in schema.py Time Complexity: O(m) where m is the no of individual unique chars used in the data. Note that indivdual number of chars are typically much smaller than total no of chars encoded or decoded. For example, the value of m will be 127 to decode any size of ascii data. """ try: b = next(bitstream) if b == str(schema.LEAF_NODE): n = next(bitstream) return tree.Node(int(n,2)) nodeleft = _makeTree(bitstream) noderight = _makeTree(bitstream) if noderight == None: return nodeleft node = tree.Node('*') node.add_left_child(nodeleft) node.add_right_child(noderight) return node except StopIteration: return None
def setUp(self): self.child1 = tree.Node('child1') self.parent = tree.Node('parent') self.child2 = tree.Node('child2') self.child1.parent = self.parent self.child2.parent = self.parent
def p_lista_parametros(p): '''lista_parametros : lista_parametros VIRGULA parametro | parametro | empty''' if(p[1] != None): p[0] = tree.Node(parser.get_next_id(), 'lista_parametros', p[1:]) else: p[0] = tree.Node(parser.get_next_id(), 'lista_parametros')
def p_lista_argumentos(p): '''lista_argumentos : lista_argumentos VIRGULA expressao | expressao | empty ''' if(p[1] != None): p[0] = tree.Node(parser.get_next_id(), 'lista_argumentos', p[1:]) else: p[0] = tree.Node(parser.get_next_id(), 'lista_argumentos')
def _fake_tree_helper(lhs, rhs, antvalues): children = [] for x in rhs: if sym.isvar(x): children.append(antvalues[sym.getindex(x) - 1]) else: children.append(tree.Node(sym.tostring(x), [])) return tree.Node(sym.totag(lhs), children)
def _fake_tree_helper(lhs, rhs, antvalues): children = [] for x in rhs: if isinstance(x, rule.Nonterminal): children.append(antvalues[x.getindex() - 1]) else: children.append(tree.Node(x, [])) return tree.Node(lhs.cat, children)
def build_decision_tree(self): info = self.num_classes_in_data(self.data) d_tree = tree.Node(str(info[1][0]), 1.0) if (info[0] > 1): d_tree = self.build_decision_tree_r(self.data, tree.Node("", 1)) else: d_tree = tree.Node(str(info[1][0]), 1.0) return d_tree
def test_should_pass_None_to_the_child_parent(self): with patch('tree.Node.parent', new_callable=PropertyMock) as mock_prop: parent = tree.Node('parent') child = tree.Node('child') parent._children.append(child) child._parent = parent parent.remove_child(child) mock_prop.assert_called_with(None)
def createVariable(l): var = tree.Node("variable") for name in l: iden = tree.Node("identifier") iden.set("name", name) var.addChild(iden) return var
def test_is_sub_tree(self): n1 = tree.Node(2) n2 = tree.Node(2) n3 = tree.Node(2) t = tree.Node(0, tree.Node(1, n1), n2) t.build_parents() n3.build_parents() self.assertTrue(ex10.is_sub_tree(t, n1)) self.assertTrue(ex10.is_sub_tree(t, n2)) self.assertFalse(ex10.is_sub_tree(t, n3))
def q_append_non_leaf(node, q): """This method will append null node children to the given node. (Step 2) When adding null nodes to a non-leaf node, the null nodes should exist on both side of the real children. This is why the first of each pair of children added sets the flag 'before=True', ensuring that on the left and right (or start and end) of the list of children a node is added.""" for i in range(q-1): node.addkid(tree.Node("*"), before=True) node.addkid(tree.Node("*"))
def createPair(key, value, commentParent=None): par = tree.Node("keyvalue") sub = tree.Node("value") par.set("key", key) par.addChild(sub) sub.addChild(value) if commentParent and commentParent.hasChild("commentsBefore"): par.addChild(commentParent.getChild("commentsBefore")) return par
def grow(): ct = tree.RBTree() ct.root = tree.Node(3) ct.root.left = tree.Node(1, ct.root) ct.root.right = tree.Node(5, ct.root) ct.root.left.left = tree.Node(0, ct.root.left) ct.root.left.right = tree.Node(2, ct.root.left) ct.root.right.left = tree.Node(4, ct.root.right) ct.root.right.right = tree.Node(7, ct.root.right) ct.root.right.right.left = tree.Node(6, ct.root.right.right) ct.root.right.right.right = tree.Node(8, ct.root.right.right) ct.root.right.right.right.right = tree.Node(9, ct.root.right.right.right) return ct
def traverse(t): """ traverses the nltk tree """ try: t.label() except AttributeError: return tree.Node(t[1]) else: some_root = tree.Node(t.label()) for child in t: some_root.addkid(traverse(child)) return some_root
def inlineIfStatement(ifNode, conditionValue): """ Inline an if statement assuming that the condition of the if statement evaluates to "conditionValue" (True/False") """ if ifNode.type != "loop" or ifNode.get("loopType") != "IF": raise tree.NodeAccessException("Expected a the LOOP node of an if statement!", mapNode) replacement = [] newDefinitions = [] reovedDefinitions = [] if ifNode.getChild("elseStatement", False): if conditionValue: reovedDefinitions = getDefinitions(ifNode.getChild("elseStatement")) newDefinitions = getDefinitions(ifNode.getChild("statement")) replacement = ifNode.getChild("statement").children else: reovedDefinitions = getDefinitions(ifNode.getChild("statement")) newDefinitions = getDefinitions(ifNode.getChild("elseStatement")) replacement = ifNode.getChild("elseStatement").children else: if conditionValue: newDefinitions = getDefinitions(ifNode.getChild("statement")) replacement = ifNode.getChild("statement").children else: reovedDefinitions = getDefinitions(ifNode.getChild("statement")) newDefinitions = map(lambda x: x.get("identifier"), newDefinitions) definitions = [] for definition in reovedDefinitions: if not definition.get("identifier") in newDefinitions: definitions.append(definition) if len(definitions) > 0: defList = tree.Node("definitionList") defList.set("line", ifNode.get("line")) for definition in definitions: if definition.hasChildren(): del definition.children defList.addChild(definition) replacement.append(defList) if replacement != []: replaceChildWithNodes(ifNode.parent, ifNode, replacement) else: emptyBlock = tree.Node("block"); emptyBlock.set("line", ifNode.get("line")) ifNode.parent.replaceChild(ifNode, emptyBlock)
def randtree(depth=2, alpha='abcdefghijklmnopqrstuvwxyz', repeat=2, width=2): labels = [''.join(x) for x in itertools.product(alpha, repeat=repeat)] random.shuffle(labels) labels = (x for x in labels) root = tree.Node("root") p = [root] c = list() for x in xrange(depth - 1): for y in p: for z in xrange(random.randint(1, 1 + width)): n = tree.Node(labels.next()) y.addkid(n) c.append(n) p = c c = list() return root
def parsefile(root_dir, filename, globals=[]): node = tree.Node(parsed_file.ParsedFile(root_dir, filename)) fullpath = os.path.join(root_dir, filename) if os.path.exists(fullpath): #TODO add some info if file coudn't be opened #TODO handle circular includes with open(fullpath) as fp: for line in fp: match = BRACKET_INCLUDE_PATTERN.match(line) if match: result = process_global_include(match.group("path"), globals) if result is None: result = process_local_include(match.group("path"), root_dir) if result is None: result=os.path.join("UNDETERMINED_PATH", match.group("path")) match = QUOTES_INCLUDE_PATTERN.match(line) if match: result = process_local_include(match.group("path"), root_dir) if result is None: result = process_global_include(match.group("path"), globals) if result is None: result=os.path.join("UNDETERMINED_PATH", match.group("path")) if result is not None: file_dir = os.path.dirname(result) file_name = os.path.basename(result) node.add_child(parsefile(file_dir, file_name, globals)) return node
def makeForest(dataset, n, header): #print(" === Função makeForest") list_trees = [] bootstrap_list = [] #print("Dataset:") #print (*dataset,sep="\n") for i in range(n): #print("Criando Bootrap") bootstrap_list.append(bootstrap.bootstrap(dataset, len(dataset))) #print("Bootstrap criado") new_tree = tree.Node() bootstrap_list[i] = header.getHeader(bootstrap_list[i]) #print(" ======== Conteudo do bootstrap list ========") #print (*bootstrap_list,sep="\n") #print("===============================================") makeTree(bootstrap_list[i], new_tree) #print("Arvore Criada") list_trees.append(new_tree) return list_trees
def program(self): # root = t.Node("root"," ","r",True,True) temp = t.Node("root", " ", "r", False, False) root = self.stmt_sequence(temp) # program = Node(node) self.out.write("Program Found\n") return root
def createClassDefineCore(id): call = tree.Node("call") oper = tree.Node("operand") para = tree.Node("params") con = createConstant("string", id) args = tree.Node("map") call.addChild(oper) call.addChild(para) oper.addChild(createVariable(["qx", "Class", "define"])) para.addChild(con) para.addChild(args) return call, con, args
def zad4(): tree_1 = tree.Node(d=tree.Data(4, str(4))) add_left(tree_1, tree.Data(3, str(3))) add_right(tree_1, tree.Data(6, str(6))) print_node(tree_minimum(tree_1)) print_node(tree_maximum(tree_1)) print_node(tree_successor(tree_1))
def __init__(self): self.moves_num = 0 self.mcts_batch = None self.current_node = tree.Node(tree.FakeNode(), 0, config.black, board.Board()) self.current_node.is_game_root = True self.current_node.is_search_root = True
def setUp(self): self.nodes = [tree.Node(i) for i in "abcdefg"] parent_index = 0 for index, child in enumerate(self.nodes): if index == 0: continue child.parent = self.nodes[parent_index] parent_index += 1 if index % 2 == 0 else 0
def _grow_tree(self, X, y, depth=0): """Build a decision tree by recursively finding the best split.""" # Population for each class in current node. The predicted class is the one with # largest population. num_samples_per_class = [ np.sum(y == i) for i in range(self.n_classes_) ] predicted_class = np.argmax(num_samples_per_class) node = tree.Node( gini=self._gini(y), num_samples=y.size, num_samples_per_class=num_samples_per_class, predicted_class=predicted_class, ) # Split recursively until maximum depth is reached. if depth < self.max_depth: idx, thr = self._best_split(X, y) if idx is not None: indices_left = X[:, idx] < thr X_left, y_left = X[indices_left], y[indices_left] X_right, y_right = X[~indices_left], y[~indices_left] node.feature_index = idx node.threshold = thr node.left = self._grow_tree(X_left, y_left, depth + 1) node.right = self._grow_tree(X_right, y_right, depth + 1) return node
def insert_helper(self, node, value): if node.data == value: return elif node.data > value: if not node.left: node.left = tree.Node(value) node.left.parent = node else: self.insert_helper(node.left, value) else: if not node.right: node.right = tree.Node(value) node.right.parent = node else: self.insert_helper(node.right, value) return