def add_node(self, name=None, id=None, flag=0, expanded_icon=None, collapsed_icon=None, selected=False, expanded=False, full_parent_id=()): """overridden method (Tree)""" Tree.add_node(self, name, id, flag, expanded_icon, collapsed_icon) fullParentPath = self.separater.join(full_parent_id) if fullParentPath not in self.savedNodesMap.keys(): self.savedNodesMap[fullParentPath] = [] savedNode = self._getSavedNode(fullParentPath, name) if savedNode is not None: self.new_nodes[-1].selected = savedNode.selected self.new_nodes[-1].expanded = savedNode.expanded return savedParentNode = self._getSavedNode(self.separater.join(full_parent_id[0:len(full_parent_id) - 1]), full_parent_id[-1]) node = Struct() node.name = name node.expandable = flag node.fullPath = self.separater.join(full_parent_id + (id,)) node.expanded = expanded node.selected = savedParentNode.selected self.savedNodesMap[fullParentPath].append(node) self.new_nodes[-1].selected = node.selected self.new_nodes[-1].expanded = node.expanded
def main(): """ Gets all the input from the file and then passes it on to the bfts search :return: """ start_pts = {} end_pts = {} puz_file = input("Name of the puzzle file: ") with open(puz_file) as f: height, num_colors = [int(x) for x in f.readline().split()] grid = [] x_loc = 0 for line in f: row = [] y = 0 for x in line.split(): if x != "e": # It's number so we should analyze it if str(x) in start_pts: end_pts[x] = (int(x_loc), int(y)) else: start_pts[x] = (int(x_loc), int(y)) row.append(x) else: row.append(-1) y += 1 grid.append(row) x_loc += 1 tree = Tree(num_colors, height, grid, start_pts, end_pts) tree.bfts()
def move_cursor(self, node): """overridden method (Tree)""" # save the old position self.oldPos = self.pos Tree.move_cursor(self, node)
def timeEvict(): ORAMsize = (1 << 13) - 1 z = 4000 start = time.clock() t = Tree(ORAMsize, z) timetaken = time.clock() - start print("Took %.4f seconds to create tree" % (timetaken)) exp = 10 leaves = t._leaves input = random.sample(leaves, exp) num = 400 #number of tests to average for i in range(num/10): start = time.clock() for i in range(10): input = random.sample(leaves, exp) t.evictAll(input) #print(t._buckets) timetaken = time.clock() - start print("%.2f" % (timetaken/10))
def word_ladder(self, origin, destination): """Constructs a word ladder between the given words using the fetched vocabulary. A word ladder is a sequence of words, from origin to destination, where each intermediary word changes exactly one letter in the previous word. All intermediate words in the ladder must be real words. Constructing a word ladder loosely follows the methodology of A* path finding. A tree data structure is used to store a collection of words and the paths between them. The tree is filled first with the destination word and is then traversed breadth first adding each word's legal one character substitutions. Traversal ends when any path has reached the origin and that path's ancestry is returned. The tree is traversed breadth first so that the shortest path is found in all cases. A tree begins at the destination and works backwards to the origin so that the chosen path's ancestry is in the correct order. :param origin: The starting word to construct a word ladder from. :param destination: The word that the ladder traverses to. :return: A sequence of words that constitutes a word ladder. """ paths = Tree() # tree stores all possible paths paths.add_root(destination) # start at destination so that ancestry path is in the correct order visited = set() # no need for ANY branch to revisit a word that another branch has been to for node in paths.breadth_first(): if node.data == origin: # if node is origin, the word ladder is complete path = [] for ancestor in node.ancestor_data(): # construct a path from this nodes ancestors. path.append(ancestor) return path else: for word in self.similar(node.data): # add each similar word to this nodes path... if word not in visited: # ...only if it hasn't been visited by ANY other tree path node.add(word) visited.add(word) return [] # no path was found
def __init__(self, leaf_width=15, leaf_height=0, padding=3, header_height=8, margin_x=10, margin_y=20): self._inc_tree = Tree() self._inc_tree_nodes = {} self._adj_graph = Digraph.Digraph() self._relation_graph = Digraph.Digraph() self._ordered_graph = Digraph.Digraph() self._compound_layer_tree = Tree() self._compound_layer_tree_nodes = {} self._inverted_edges = set() self._fake_vertices = set() self._dummy_vertices = set() self._adj_left = {} self._adj_right = {} self._order_service_graph = Digraph.Digraph() self._order_index = {} self._barycenter = {} self._x = {} self._y = {} self._width = {} self._height = {} self._leaf_width = leaf_width self._leaf_height = leaf_height self._left_top_x = 1 self._left_top_y = 1 self._header_height = header_height self._padding = padding self._margin_y = margin_y self._margin_x = margin_x self._drawer = DrawingFramework.DrawingFramework()
def test_tree_insertion_equal_node(self): tree = Tree() tree.insert(Node.factory(12)) tree.insert(Node.factory(12)) self.assertIsNotNone(tree.root_node) self.assertIsNotNone(tree.root_node.value) self.assertEqual(12, tree.root_node.value) self.assertIsNone(tree.root_node.left.value) self.assertIsNone(tree.root_node.right.value)
def database_indexer(k,threshold, nucleotides, probabilities): """ k : length of k - mer t : threshold value nucleotides : string which is the filename of our list of nucleotides prob : string which is the filename of our list of probabilites """ t = log(threshold) nuc = [] #The probabilities in string format. prob_string = [] probable_emissions = {} with open (nucleotides) as f: for line in f: for char in line: nuc.append(char) with open(probabilities) as f: for line in f: prob_string = line.split(' ') #Convert the probability values from strings to floating point numbers prob = [float(i) for i in prob_string] distributions = [] for i in range(len(nuc)): distributions.append(get_ith_distribution(i, nuc, prob)) #A list which has as the element at index i the log of the maximum probability of an instantiated suffix of S starting at index i. We currently don't make any calls to this max_word_probability = [] for i in range(len(distributions)): max_word_probability.insert(i, prob_upper_bound(distributions, i, k)) for start_idx in range(len(nuc)- k +1): #This is "window" of the probabilistic sequence of length k from which we will look for k - mers instantiating with probability > t distributions_window = distributions[start_idx:start_idx + k ] """ Set up the root of the k mer tree. It currently has no children, a probability of 1, the distribution of the first letter of the probabilistic sequence S, and a string of k"-" characters, showing that all letters in the k - mer are not instantiated """ base_string = list('-'*k) # Look for characters in S which are certain. This will help us minimize the number of nodes created for i in range(len(distributions_window)): if distributions[i][0][1] == 1: base_string[i] = distributions_window[i][0][0] root_distro = distributions_window[0] root = Node(None, [], 0, root_distro, base_string, 0) #Set up the tree using Gardener gardener(t, root, 0, k, distributions_window) #Once nodes have been linked, consolidate to a tree k_mer_tree = Tree(root) probable_emissions[start_idx] = k_mer_tree.harvest() return probable_emissions
class Surpasser: def __init__(self): self.__tree__ = None self.__numArray__ = list() self.__maxSurpasser__ = 0 def setTree(self,tree): self.__tree__ = tree def setArray(self,numArray): self.__numArray__ = numArray def createNode(self,value): node = Node() node.setValue(value) return node def addNode(self,node,startNode): if node.getValue() <= startNode.getValue(): if startNode.getLeft() == None: startNode.setLeft(node) else: self.addNode(node,startNode.getLeft()) else: if startNode.getRight() == None: startNode.setRight(node) else: self.addNode(node,startNode.getRight()) def buildTree(self): for i in self.__numArray__: if self.__tree__ == None: self.__tree__=Tree() self.__tree__.setRoot(self.createNode(i)) else: startNode=self.__tree__.getRoot() node=self.createNode(i) self.addNode(node,startNode) def findMaxSurpasser(self,startNode): if startNode == None: return else: rightNode=startNode.getRight() maxNum=self.findTreeElementNum(rightNode) if maxNum>self.__maxSurpasser__: self.__maxSurpasser__=maxNum self.findMaxSurpasser(startNode.getLeft()) def findTreeElementNum(self,node): if node == None: return 0 else: return 1+ self.findTreeElementNum(node.getLeft())+self.findTreeElementNum(node.getRight())
class TextFile: def __init__(self, file_path): self.tree = Tree() with open(file_path) as f: for line in f: for word in line.split(): self.tree.insert(Node.factory(WordWrapper(word))) def word_count(self): return self.tree.size()
def setUp(self): self.root = Tree() self.c1 = Tree(self.root, 1) self.c2 = Tree(self.root, 2) self.n1 = Tree(self.root) self.c3 = Tree(self.n1, 3) self.c4 = Tree(self.n1, 4) self.n2 = Tree(self.n1) self.c5 = Tree(self.n2, 5) self.c6 = Tree(self.n2, 6)
def testCORAM(): ORAMsize = (1 << 8) - 1; z = 600; t = Tree(ORAMsize, z); A = 100; N = A * ORAMsize / 4; print(z, A) for k in range(int(N/A)): root = [t.randomLeaf() for i in range(A)] t.evictAll(root) counter = 0 while True: count = 0; for i in range(A): count += t.readBlock(t.randomLeaf()) root = [t.randomLeaf() for i in range(count)] t.evictAll(root) counter = counter + 1 if (counter % 100 == 0): print(counter)
def __init__(self, value, children, parent=None): """ Create a tree whose root has specific value (a string) children is a list of references to the roots of the children. parent (if specified) is a reference to the tree's parent node """ Tree.__init__(self, value, children) self._parent = parent for child in self._children: child._parent = self
def add_tree(self, penn_tree, _id): """ Makes a root node, fills up its structure from PTB format and adds it to the list of trees """ tree = Tree(_id=_id) _class = Model.targets[_id] tree.set_target(_class) tree.root = Node() tree.root.read(penn_tree, 0, True) # Chaipi for life tree.root = tree.root.children[0] self.trees.append(tree)
def create_full_tree(depth): if depth == 0: terminal = Terminal.random_terminal() node = Node("terminal", terminal) return Tree(node) else: function = Function.random_function() root_node = Node("function", function) result = Tree(root_node) for i in range(2): #function.arity() result.add_child(Initializer.create_full_tree(depth - 1)) return result
def min_height_bst(arr): if len(arr) == 0: return None elif len(arr) == 1: return Tree(arr[0]) root = Tree(arr[len(arr) / 2]) left = min_height_bst(arr[: len(arr) / 2]) right = min_height_bst(arr[len(arr) / 2 + 1 :]) if left != None: root.left = left if right != None: root.right = right return root
def testTrees(): a = ArtificialPhylogeny(size=20,numChromosomes=5) while len(a.tree.getTips()) < 6: a.evolve() tipScores = [tip.getScore() for tip in a.tree.getTips()] s = a.tree.getScore() tipScores = [score -s for score in tipScores] for score in tipScores: assert score == 0 copyTree = Tree(a.tree) if len(a.tree) != len(copyTree): print( len(a.tree) ) print( len(copyTree)) print( a.tree.getTips()) print(copyTree.getTips()) print(a.tree) print(copyTree) print(a.tree.genome.getName()) print(copyTree.genome.getName()) raise Exception("Trees are not the same size") sub = a.tree.subs[0] a.tree.breakConnection( sub ) if len(copyTree.subs) not in (1,3): print( len(copyTree.subs)) assert False a.tree.addConnection( sub) aTips = a.tree.getTips() for cTip in copyTree.getTips(): assert cTip not in aTips tipScores = [tip.getScore() for tip in a.tree.getTips()] s = a.tree.getScore() tipScores = [score -s for score in tipScores] for score in tipScores: assert score == 0 aTips = a.tree.getTips() subTips = a.tree.subs[0].getTips() for tip in aTips: assert tip in subTips assert 2*len(copyTree.getTips()) - 2 == len(copyTree) print("All tree tests passed.")
def __init__(self, master, root_id, root_label='', get_contents_callback=None, dist_x=15, dist_y=15, text_offset=10, line_flag=1, expanded_icon=None, collapsed_icon=None, regular_icon=None, plus_icon=None, minus_icon=None, unchecked_icon=None, checked_icon=None, greyed_checked_icon=None,node_class=MultiSelectNode, drop_callback=None, node_select_callback=None, *args, **kw_args): self.separater = ' -> ' self.pos = None self.rootId = root_id self.realDistX = dist_x self.nodeSelectCallback = node_select_callback if checked_icon == None: self.checkedIcon=PhotoImage(file='checkedIcon.gif') else: self.checkedIcon=checked_icon if unchecked_icon == None: self.uncheckedIcon=PhotoImage(file='uncheckedIcon.gif') else: self.uncheckedIcon=unchecked_icon if greyed_checked_icon == None: self.greyedCheckedIcon=PhotoImage(file='greyedIcon.gif') else: self.greyedCheckedIcon=greyed_checked_icon if get_contents_callback == None: get_contents_callback = self._getContents savedNode = Struct() savedNode.name = self.rootId savedNode.expandable = True savedNode.fullPath = self.rootId savedNode.expanded = False savedNode.selected = False # This structure is used to remember selected nodes and their selected/expanded states self.savedNodesMap = {'': [savedNode], savedNode.fullPath: []} Tree.__init__(self, master, root_id, root_label, get_contents_callback, dist_x * 2, dist_y, text_offset, line_flag, expanded_icon, collapsed_icon, regular_icon, plus_icon, minus_icon, node_class, drop_callback, *args, **kw_args)
def GetTreeOfMoves ( self, piece, board ) : # Create the tree and the root tree = Tree() tree.addRoot( ( piece.line, piece.collum ) ) children = piece.canKill( board ) for c in children: tree.root.addChild( c ) # Create the childs if len( tree.root.child ) > 0: self.GenerateTree( tree.root, board ) return tree
def readfile(): lines = [] read = open("game2.txt","r") line=read.readline() while True: line = read.readline() print line lines.append(line) if len(line) == 0: break print lines read.close() Tree.set_head(lines[0],lines[1],lines[2]) #"set_head" Tree.make_tree(lines) #"Make the tree"
def constructGraph(self, v,w, D_T_T, D_F_F): G = Graph() V = {} V['s'] = 0 i = 1 for v_i in v.getChildren(): V["v" + str(v_i.getHashNum())] = i i += 1 V['e_i'] = i i += 1 for w_i in w.getChildren(): V["w" + str(w_i.getHashNum())] = i i += 1 V['e_j'] = i i += 1 V['t'] = i G.V = range(len(V)) G.capacity = numpy.zeros([len(V),len(V)]) for v_i in v.getChildren(): G.capacity[V['s'],V["v" + str(v_i.getHashNum())]] = 1 for w_i in w.getChildren(): G.capacity[V["v" + str(v_i.getHashNum())],V["w" + str(w_i.getHashNum())]] = 1 G.capacity[V["v" + str(v_i.getHashNum())],V['e_j']] = 1 for w_i in w.getChildren(): G.capacity[V["w" + str(w_i.getHashNum())], V['t']] = 1 G.capacity[V['e_i'],V["w" + str(w_i.getHashNum())]] = 1 G.capacity[V['s'],V['e_i']] = n_j = len(w.getChildren()) G.capacity[V['e_j'],V['t']] = n_i = len(v.getChildren()) G.capacity[V['e_i'],V['e_j']] = max(n_i, n_j) - min(n_i, n_j) G.cost = numpy.zeros([len(V),len(V)]) for v_i in v.getChildren(): for w_i in w.getChildren(): G.cost[V["v" + str(v_i.getHashNum())], V["w" + str(w_i.getHashNum())]] = self.getConstrainedTED(v_i, w_i, D_T_T, D_F_F) G.cost[V['e_i'], V["w" + str(w_i.getHashNum())]] = self.getConstrainedTED(Tree.getEmptyTree(), w_i, D_T_T, D_F_F) G.cost[V["v" + str(v_i.getHashNum())], V['e_j']] = self.getConstrainedTED(v_i, Tree.getEmptyTree(), D_T_T, D_F_F) G.init_edges() G.init_cost_rev() return (G,V)
def add_tree(self, penn_tree, _id): """ Makes a root node, fills up its structure from PTB format and adds it to the list of trees """ tree = Tree(_id) # _id == 1 is used as a sentinel value for the website if _id != -1: _class = Model.targets[_id] self.set_target(_class) tree.set_target(_class) tree.root = Node() tree.root.read(penn_tree, 0, True) # Chaipi for life tree.root = tree.root.children[0] self.trees.append(tree)
def testOverflow(): ORAMsize = (1 << 10) - 1 z = 1000 t = Tree(ORAMsize, z) exp = 500 leaves = t._leaves counter = 0 while True: input = random.sample(leaves, exp) t.evictAll(input) counter = counter + 1 print(str(counter) + " evictions of " + str(exp) + " blocks completed")
def __init__(self): self.__currentLevel= list() self.__nextLevel = list() self.__maxLevel = int() self.__findNodeValue = int() self.__tree = Tree() self.__visitedNodes=dict()
def setUp(self): self.treeToArray = TreeToArray() tree = Tree() node1=Node() node1.setValue(1) node2=Node() node2.setValue(2) node3=Node() node3.setValue(3) node4=Node() node4.setValue(4) tree.setRoot(node1) node1.setLeft(node2) node1.setRight(node3) node3.setRight(node4) self.treeToArray.setTree(tree)
def parseTreeFromXML(root, PL): children = root.getchildren() if root.tag[0] == "A": t = Tree("Basic", Sigma(root.tag, []), [], [], PL) t._isComplete=True return t else: tree = Tree("Complex", NT(root.tag, []), [], [], PL) isComplete=True for child in children: treeChild = parseTreeFromXML(child, PL) if not treeChild.isComplete(): isComplete=False tree._children.append(treeChild) tree._isComplete=isComplete return tree
def __init__ (self): QtGui.QMainWindow.__init__ (self) self.btnCol = 1 self.radioCol = 0 self.upDirShortCutKey = "/" self.homeDirShortCutKey = "-" self.pyapplaunchConfigDir = ConfigManager.getPyapplaunchConfigDir() self.configManager = ConfigManager.ConfigManager() self.executionManager = ExecutionDelegateManager (self.configManager) self.scriptDatabasePath = self.pyapplaunchConfigDir + os.sep + "scripts.xml" self.tree = Tree (self.scriptDatabasePath) self.upButton = None self.homeButton = None self.initUI() self.buildAppButtons() self.createSysTray() self.restoreWindowPos() # This is an adaptor to call "self.tree.substituteEveryOccurrenceOfValue" # with the right parameters, since the signal we're connecting to can't # connect directly to the function. nameChangeAdaptor = lambda s1, s2: \ self.tree.substituteEveryOccurrenceOfValue (s1, s2, "exec_with") self.executionManager.delegateNameChanged.connect (nameChangeAdaptor)
def calculate(self): if len( self.trees) == 1: self.tree = self.trees[0] else: print("! upgma - in !") while len(self.trees) > 2: t,g = len(self.trees), len(self.genomes) i,j = getMatrixMin(self.distances) newGenome = self.grimm.midGenome(self.genomes[i], self.genomes[j]) newTree = Tree( newGenome ) newTree.addConnection( self.trees[i] ) newTree.addConnection( self.trees[j] ) self.trees[i] = newTree self.trees.pop(j) self.genomes[i] = newGenome self.genomes.pop(j) # self.distances = self.grimm.getUpdatedDistMatrix( self.genomes, self.distances, (i,j) ) self.distances = self.grimm.getDistMatrix( self.genomes ) if t - 1 != len(self.trees) or g - 1 != len(self.genomes): print newGenome print newTree print (i,j) print self.genomes print self.trees raise Exception print(";") print("! upgma - out !") if len( self.trees) == 2: self.tree = self.trees[0] self.tree.addConnection( self.trees[1] ) else: print newGenome print newTree print (i,j) print self.trees print self.genomes raise Exception assert self.tree.isBinary()
def test_tree_multi_level_insertion(self): tree = Tree() tree.insert(Node.factory(12)) tree.insert(Node.factory(12)) tree.insert(Node.factory(10)) tree.insert(Node.factory(11)) tree.insert(Node.factory(1)) tree.insert(Node.factory(100)) self.assertEqual(12, tree.root_node.value) self.assertEqual(100, tree.root_node.right.value) self.assertEqual(10, tree.root_node.left.value) self.assertEqual(11, tree.root_node.left.right.value) self.assertEqual(1, tree.root_node.left.left.value)
def fit(self, X, y): self.base = np.mean(y) self.get_first_entries(X, y) self.trees = [] n_features, n_bins = self.transformer.get_sizes() for _ in range(self.n_estimators): tree = Tree(self.depth, self.loss, self.entries, n_features, n_bins, self.lambda_val, self.gamma) tree.construct() self.trees.append(tree) if tree.real_depth < 1: break for i in range(len(self.entries)): prediction = tree.predict(self.entries[i].x) self.entries[i].prediction += self.eps * prediction self.entries[i].g, self.entries[i].h = \ self.loss(self.entries[i].y, self.entries[i].prediction)
def create_tree_4(): t = Tree(13) import random arr = list(range(1, 26)) random.shuffle(arr) for x in arr: insert(t, x) return t
def splice_nodes_helper(tree, filter_func): spliced_children = [] for child in tree.children: spliced_child_list = splice_nodes_helper(child, filter_func) spliced_children.extend(spliced_child_list) if filter_func(tree.label): return spliced_children return [Tree(tree.label, spliced_children)]
def __init__(self, minSamples=5, maxDepth=5, usedTrees=5, learningRate=0.05): super().__init__(minSamples=minSamples, maxDepth=maxDepth) self.decisionTrees = [Tree() for _ in range(usedTrees + 1)] self.learningRate = learningRate
def init_tree() -> Tree: """ Generates a tree that looks like 6 / \ 5 8 /\ /\ 2 7 9 /\ /\ 1 3 10 /\ 4 """ tree = Tree() children = [6, 8, 9, 5, 2, 1, 3, 7, 10, 4] [tree.add_child(child) for child in children] return tree
def buildTree(): #start = raw_input("Please enter the log file name: ") myFile = file("log.txt", "r") lines = myFile.readlines() myFile.close() t = Tree() for l in lines: tokens = l.split() if tokens[0] == "folder": t.create_node(tokens[1], tokens[0]) else: t.create_node(tokens[1], tokens[0], tokens[2]) return t
def read_root_tree(self): try: self.read_whitespace() if not TreeReader.is_left_paren(self.peek()): return None return Tree(ROOT_LABEL, [self.read_tree(False)]) except IOError: raise Exception("Error reading tree: %s\n" % self.ff.name)
def read_tree(self, is_root): self.read_left_paren() label = self.read_label() if len(label) == 0 and is_root: label = ROOT_LABEL children = self.read_children() self.read_right_paren() return Tree(label, children)
def __init__(self, minSamples=5, maxDepth=5, usedTrees=5, percentageOfDatapointsPerTree=0.7): super().__init__(minSamples=minSamples, maxDepth=maxDepth) self.decisionTrees = [Tree() for _ in range(usedTrees)] self.percentageOfDatapointsPerTree = percentageOfDatapointsPerTree
def __init__(self, alignment_file, gene_to_orlg_file, cdna, # Data input tree_newick, DupLosList, # Tree input x_js, pm_model, IGC_pm, rate_variation, # JSModel input node_to_pos, terminal_node_list, # Configuration input save_file, # Auto save file force=None, # Parameter value constraint seq_index_file=None, # Seq index file nsites=None): self.tree = Tree(tree_newick, DupLosList, terminal_node_list, node_to_pos) self.data = Data(alignment_file, gene_to_orlg_file, seq_index_file=seq_index_file, cdna=cdna) # added new variable for jsmodel conf_list = count_process(self.tree.node_to_conf) accessible_orlg_pair = get_accessible_orlg_pair(conf_list) self.jsmodel = JSModel(self.tree.n_js, x_js, pm_model, self.tree.n_orlg, IGC_pm, rate_variation, accessible_orlg_pair, force) self.node_to_pos = node_to_pos self.terminal_node_list = terminal_node_list self.root_by_dup = self.tree.is_duplication_node(self.tree.phylo_tree.root.name) self.save_file = save_file self.force = force if os.path.isfile(self.save_file): self.initialize_by_save() print('Loaded paramters from ' + self.save_file) else: if self.root_by_dup: self.x = np.concatenate((x_js, np.log([0.01] * len(self.tree.edge_list)))) else: self.x = np.concatenate((x_js, np.log([0.01] * (len(self.tree.edge_list) - 1)))) self.unpack_x(self.x) assert (self.jsmodel.n_orlg == self.tree.n_orlg) # make sure n_orlg got updated self.ll = None # used to store log likelihood self.ExpectedGeneconv = None # Used to store expectedNumGeneconv self.auto_save = 0 # used to control auto save frequency self.nsites = nsites self.iid_observations = None # Store iid_observations which only needs one time calculation self.observable_nodes = None self.observable_axes = None self.is_mle = False assert (self.self_check())
class TreeIterator: def __init__(self): self.__tree__ = Tree() self.__currentNode__ = Node() self.__isFirst = True def setTree(self,tree): self.__tree__=tree def next(self): tempNode=Node() if self.__tree__ == None: return False if self.__tree__.getRoot() == None: return False if self.__isFirst: self.__isFirst = False if not self.__tree__.getRoot().getLeft() == None: self.__currentNode__ = self.getLeftMostChild(self.__tree__.getRoot().getLeft()) else: self.__currentNode__ = self.__tree__.getRoot() else: if not self.__currentNode__.getRight() == None: self.__currentNode__=self.getLeftMostChild(self.__currentNode__.getRight()) elif self.__currentNode__.getParent() == None: return False elif self.__currentNode__ == self.__currentNode__.getParent().getLeft(): self.__currentNode__ = self.__currentNode__.getParent() elif self.__currentNode__ == self.__currentNode__.getParent().getRight(): tempNode=self.__currentNode__ while not tempNode == None: if tempNode == tempNode.getParent().getLeft(): self.__currentNode__ = tempNode.getParent() return self.__currentNode__ else: tempNode = tempNode.getParent() else: return False return self.__currentNode__ def getLeftMostChild(self,node): if not node.getLeft() == None: return self.getLeftMostChild(node.getLeft()) else: return node
def construct_tree(in_order, pre_order, start_index, end_index): #Ensure no index error if start_index > end_index: return None #Constructing node node = Tree(pre_order[construct_tree.starter]) #Updating starting index construct_tree.starter += 1 #When list ends returns current node if start_index == end_index: return node #calculating dividing index based on pre-order list index = search_value(in_order, start_index, end_index, node.getValue()) #Creating left subtree node.setLeft(construct_tree(in_order, pre_order, start_index, index-1)) #Creating right subtree node.setRight(construct_tree(in_order, pre_order, index+1, end_index)) #return the root node return node
def test(self): tree = Tree() root = Node(label="root") A = Node(label="a") B = Node(label="b") C = Node(label="c") D = Node(label="d") D.add_child(A) D.add_child(B) root.add_child(D) root.add_child(C) A.set_height(0.0) B.set_height(0.0) C.set_height(0.0) D.set_height(1.0) root.set_height(2.0) tree.set_root(root) if (tree.get_leaf_count() == 3): print("True") else: print(tree.get_leaf_count()) if (tree.get_newick() == "((a:1.0,b:1.0)d:1.0,c:2.0)root:0.0;"): print("True")
def main(): # Read data and split into train, cross-test and test as 3:1:1 datafile = "./Sogou_data/Sogou_webpage.mat" data = scio.loadmat(datafile) doclabel = data['doclabel'] wordMat = data['wordMat'] doc_number = wordMat.shape[0] key_number = wordMat.shape[1] traindata = [wordMat[i] for i in range(doc_number) if i % 5 == 0 or i % 5 == 1 or i % 5 == 2] trainlabel = [doclabel[i] for i in range(doc_number) if i % 5 == 0 or i % 5 == 1 or i % 5 == 2] crossdata = [wordMat[i] for i in range(doc_number) if i % 5 == 3] crosslabel = [doclabel[i] for i in range(doc_number) if i % 5 == 3] testdata = [wordMat[i] for i in range(doc_number) if i % 5 == 4] testlabel = [doclabel[i] for i in range(doc_number) if i % 5 == 4] time_start = time.time() T = Tree(traindata, trainlabel, 0) de_threshold = 0.001 depth_threshold = 100 T.Impurity() T.GenerateTree(de_threshold, depth_threshold) T.Prune(crossdata, crosslabel) accuracy = T.Decision(testdata, testlabel) accuracy_train = T.Decision(traindata, trainlabel) time_end = time.time() print("超参数(de_threshold={0}, depth_threshold={1})下的训练集正确率为{2},测试集正确率为{3},耗时{4}s".format(de_threshold, depth_threshold, accuracy_train, accuracy, time_end - time_start))
def HiddenScript(): filepath = os.getcwd( ) #note to self: this is how you get a file's location (most of the time, at least) while True: t = Tree(filepath) try: break except IndexError: filepath = os.path.dirname(filepath)
def Run(self, rawData, target, source): self.ProcessRawInput(rawData) self._tree = Tree(self._productBank) self._tree.SetRoot(self.InsertIntoTree(self._tree, target, None)) def NodeVisitorFunc(node): NodeVisitorFunc.productionBank = self._productBank nodeName = node.GetName() if (nodeName not in NodeVisitorFunc.productionBank.keys()): NodeVisitorFunc.productionBank[nodeName] = (0, 0, 0) self._tree._nodeVisitedFunc = NodeVisitorFunc #self._tree.PrintTree(200, [self._tree._root]) self.TraverseOnce(self._tree._root) oreNeeded = self.CalculateOre(self._tree) print(f"Ore needed for 1 fuel: {oreNeeded}")
def __init__( self, treeSize, z, segmentSize, maxStashSize ): # grow/shrink triggered by ratio (buckets * z) / (# of segments) self._z = z self._tree = Tree( treeSize, z, self._A, segmentSize ) #changed to fix the existing constructor on the tree class I (akiva) wrote self._stash = Stash.Stash(z) self._posMap = PosMap.PosMap() self._c = maxStashSize self._segCounter = 0 self.useVCache = True self.debug = False self.VCacheCounter = 0 self.totalCounter = 0
def solve(self): # instancia classe de arvore t = Tree() # preenche a fila com pos ordem t.postOrder(self.tree, self.queue) # caminha na fila for i in self.queue: # verifica se é um operador if t.isOperator(i): # se for empilha ele self.stack.append(i) # e faz a operação self.verifyOperation() else: # senão, apenas empilha self.stack.append(i) # no fim retorna o resultado return self.stack[0]
def solve_it(input_data): read(input_data) root = Tree(0, int(capacity), estimate(items), None) makeTree(items, root, []) #root.printPreorder(root,'') traverse(root) ancestors(root, solution()) print(output()) return
def aStarSearch(self, board): # Node(Parent Node, List of children nodes, heuristic value, depth value, board object, index, totalHeuristic) h = heuristicValue(board, heuristicOption) head = Node(None, [], h, 1, board, "0", h + 1) tree = Tree(head) self.touchOptions = self.createTouchOptions(board) tree.openlist.append(head) return self.startSearch(tree)
def generateTrees(self): for nodeDict in self.allNodes: for nodeIndex in nodeDict: nodeDict[nodeIndex].findParent(nodeDict) for node in self.rootTreeNode.children: for treeRoot in node.children: t = Tree(treeRoot) self.allTrees.append(t) return self.allTrees
def dfsSearch(self, board): # Node(Parent Node, List of children nodes, heuristic value, depth value, board object) # The first Node does not have a parent, no children for now, DFS does not have a heuristic, # a depth of 1, the initial state of the board and an empty move. head = Node(None, [], 0, 1, board, "0", 0) tree = Tree(head) self.touchOptions = self.createTouchOptions(board) tree.openlist.append(head) return self.startSearch(tree)
def setUp(self): self.treeIterator=TreeIterator() tree=Tree() node1=Node() node2=Node() node3=Node() node4=Node() node5=Node() node6=Node() node7=Node() node8=Node() node9=Node() node12=Node() node2.setValue(2) node3.setValue(3) node1.setValue(1) node4.setValue(4) node5.setValue(5) node6.setValue(6) node7.setValue(7) node8.setValue(8) node9.setValue(9) node12.setValue(12) tree.setRoot(node12) node12.setLeft(node1) node12.setRight(node9) node9.setLeft(node2) node9.setRight(node4) node2.setRight(node8) node8.setLeft(node5) node8.setRight(node6) node4.setLeft(node3) node4.setRight(node7) node3.setParent(node4) node7.setParent(node4) node4.setParent(node9) node9.setParent(node12) node1.setParent(node12) node2.setParent(node9) node8.setParent(node2) node5.setParent(node8) node6.setParent(node8) self.treeIterator.setTree(tree)
def __init__(self, alignment_file, gene_to_orlg_file, # Data input seq_index_file, cdna, allow_same_codon, # Data input tree_newick, DupLosList, # Tree input x_js, pm_model, IGC_pm, rate_variation, # PSJSModel input node_to_pos, terminal_node_list, # Configuration input save_file, log_file, # Auto save files # root_by_dup = False, # JSModel input force = None, # PSJS Parameter value constraint nsites = None, space_list = None ): self.tree = Tree(tree_newick, DupLosList, terminal_node_list, node_to_pos) self.data = Data(alignment_file, gene_to_orlg_file, seq_index_file = seq_index_file, two_sites = True, space_list = space_list, cdna = cdna, allow_same_codon = allow_same_codon) self.psjsmodel = PSJSModel(x_js, pm_model, self.tree.n_orlg, IGC_pm, rate_variation, force) self.node_to_pos = node_to_pos self.terminal_node_list = terminal_node_list self.root_by_dup = self.tree.is_duplication_node(self.tree.phylo_tree.root.name) self.save_file = save_file self.log_file = log_file self.force = force self.x = None if os.path.isfile(self.save_file): self.initialize_by_save() print ('Loaded paramters from ' + self.save_file) else: if self.root_by_dup: self.x = np.concatenate((x_js, np.log([0.01] * len(self.tree.edge_list)))) else: self.x = np.concatenate((x_js, np.log([0.01] * (len(self.tree.edge_list) - 1)))) assert(self.psjsmodel.n_orlg == self.tree.n_orlg) # make sure n_orlg got updated self.ll = None # used to store log likelihood self.ExpectedGeneconv = None # Used to store expectedNumGeneconv self.auto_save = 0 # used to control auto save frequency self.nsites = nsites self.iid_observations = None # Store iid_observations which only needs one time calculation self.observable_nodes = None self.observable_axes = None assert(self.self_check())
def transform_tree(cls, tree): label = tree.label children = tree.children while len(children) == 1 and not children[0].is_leaf() \ and label == children[0].label: children = children[0].children transformed_children = [] for child in children: transformed_children.append(XOverXRemover.transform_tree(child)) return Tree(label, transformed_children)
def bestFirstSearch(self, board): # Node(Parent Node, List of children nodes, heuristic value, depth value, board object, index, totalHeuristic) h = heuristicValue(board, heuristicOption) # Since BFS doesnt care about the position in the search space, total f = h head = Node(None, [], h, 1, board, "0", h) tree = Tree(head) self.touchOptions = self.createTouchOptions(board) tree.openlist.append(head) return self.startSearch(tree)
def parse_xml(xml_content): xml_content = xml_content.strip() if xml_content == '': return [] elif not ('<' in xml_content and '>' in xml_content): return [Tree(xml_content)] # print('--------------') # print(xml_content[:100]) assert xml_content[0] == '<', xml_content[:100] res = [] idx = 0 # for idx, char in xml_content: # while idx < len(xml_content): para = re.search('>', xml_content) if para is None: return Node(xml_content) else: idx = para.start() # print(idx, char) # print(xml_content[1:idx]) node = parse_xml_tag(xml_content[1:idx].strip()) # print(node) # print(node.datum) if node.datum[0] in ['?', '!'] or xml_content[idx - 1] == '/': res.append(Tree(node)) res.extend(parse_xml(xml_content[idx + 1:])) else: m = re.search('</%s>' % node.datum, xml_content[idx:]) # print(xml_content[idx:100]) # print('</%s>'%node.datum) # print(m) end, new_start = m.start(), m.end() # print(end, new_start) # print(xml_content[idx+end:idx+new_start+1]) # if xml_content[idx+1:end-1] != '': children = parse_xml(xml_content[idx + 1:idx + end]) res.append(Tree(node, children)) # else: # res.append(Tree(node)) res.extend(parse_xml(xml_content[idx + new_start + 1:])) return res
def createMap(n, m): tree = Tree(n, m) graph = tree.create_graph() graph_ = nx.algorithms.tree.mst.minimum_spanning_tree(graph) array = lines_to_array(tree.graph_to_lines(graph_), n, m) # tree.visualize_all(graph_, array, field_width, field_height) plt.imshow(array, interpolation='none', cmap='gray') plt.xlim(0, field_width) plt.ylim(0, field_height) plt.grid(True) plt.show() return array
def createTree(depth, memoryLength): funcNodes = ['AND', 'OR', 'NOT', 'XOR'] agents = ['P', 'O'] tree_list = [] # Initialize a tree tree = Tree() if depth == 1: # Obtain the two things needed to make a leaf agent = random.choice(agents) num = random.randrange(1, (memoryLength + 1)) # The termination node created leaf = agent + str(num) # Set the value equal to the created leaf tree.add(leaf) tree_list.append(leaf) else: for level in range(depth): if level == 0: value = random.choice(funcNodes) tree.add(value) tree_list.append(value) elif level is not (depth - 1): for node in range(2**level): value = random.choice(funcNodes) tree.add(value) tree_list.append(value) else: for node in range(2**level): agent = random.choice(agents) num = random.randrange(1, (memoryLength + 1)) leaf = agent + str(num) tree.add(leaf) tree_list.append(leaf) return tree, tree_list
class QuadTreeCodec: def __init__(self, quad_tree_size, min_cell_snr, debug=False): self.quad_tree_size = quad_tree_size self.min_cell_snr = min_cell_snr self.debug = debug self.tree = None # TODO Comment def get_codec_shape(self): return [self.quad_tree_size, self.quad_tree_size] # TODO Comment def compress(self, image: np.ndarray): root = QuadTreeNode( image, Rect(0, 0, self.quad_tree_size, self.quad_tree_size)) self.tree = Tree(root) leaf_factory = CompressedLeafFactory(self.min_cell_snr) self.tree.top_down(leaf_factory) # TODO Comment # noinspection PyMethodMayBeStatic def uncompress(self, cell: np.ndarray): self.tree.draw(cell, self.debug) # TODO Comment def encode(self, stream: BitStream): self.encode_node(self.tree.root, stream) return stream # TODO Comment def encode_node(self, node, stream: BitStream): is_leaf = node.is_leaf() stream.write(is_leaf) if is_leaf: node.get_leaf_data().encode(stream) else: for child in node.get_children(): self.encode_node(child, stream) return stream # TODO Comment def decode(self, stream: BitStream): return stream
def setUp(self): self.bfs = BFS() tree = Tree() node1 = Node() node1.setValue(1) node2 = Node() node2.setValue(2) node3 = Node() node3.setValue(3) node4 = Node() node4.setValue(4) node5 = Node() node5.setValue(5) node1.addChild(node2) node1.addChild(node3) node2.addChild(node4) node3.addChild(node5) node4.addChild(node2) tree.setRoot(node1) self.bfs.setTree(tree)