def STATEMENT(current, G): t = tree("STATEMENT") s = {} if current.name == "ID": current, child, s1 = ASSIGNMENT(current, G) #make sure ASSIGNMENT is returning next(G) t.children.append(child) s.update(s1) return current, t, s #current should be a ; elif current.name == "READ": t.children.append(tree("READ")) current = next(G) if not current.name == "LPAREN": raise ParserError("READ token is not followed by a (" + getTokenLineInfo(current)) current, child, s1 = ID_LIST(next(G), G) #should be returning a ) t.children.append(child) #child should be the ID_LIST tree s.update(s1) if not current.name == "RPAREN": raise ParserError("Missing closing ) in READ statement" + getTokenLineInfo(current)) return next(G), t, s #next(G) should be a ; elif current.name == "WRITE": t.children.append(tree("WRITE")) current = next(G) if not current.name == "LPAREN": raise ParserError("WRITE token is not followed by a (" + getTokenLineInfo(current)) current, child, s1 = EXPR_LIST(next(G), G) #should be returning a ) t.children.append(child) s.update(s1) if not current.name == "RPAREN": raise ParserError("Missing closing ) in WRITE statement" + getTokenLineInfo(current)) return next(G), t, s #next(G) should be a ; else: raise ParserError("Inappproriate token to start a statement" + getTokenLineInfo(current))
def main(): MUSIC_FORMATS = ['mp3', 'flac', 'waw', 'm4a'] yes = set(['yes','y', 'ye', '']) no = set(['no','n']) args = unparse_arguments(MUSIC_FORMATS) empty_dirs = find_folders_not_containing(args.path, MUSIC_FORMATS) for folder in empty_dirs: if args.tree: tree.tree(folder, ' ', True) else: print(folder) if empty_dirs: print("Do you want to delete listed directories? [yes/no]") choice = input().lower() if (choice in yes): print("Deleting dirs") delete_dirs(empty_dirs) else: print("You have canceled this action") else: print("Your music library is already clean")
def init_plat_tree(): # Create /api end point as root node r_api = tree("api", data = get_node_api()) # Add /api/spb to represent side plane board r_spb = tree("spb", data = get_node_spb()) r_api.addChild(r_spb) # Add servers /api/server[1-max] num = pal_get_num_slots() for i in range(1, num+1): r_server = populate_server_node(i) if r_server: r_api.addChild(r_server) # TODO: Need to add /api/nic to represent NIC Mezz Card # Add /api/spb/fruid end point r_temp = tree("fruid", data = get_node_fruid("spb")) r_spb.addChild(r_temp) # /api/spb/bmc end point r_temp = tree("bmc", data = get_node_bmc()) r_spb.addChild(r_temp) # /api/spb/sensors end point r_temp = tree("sensors", data = get_node_sensors("spb")) r_spb.addChild(r_temp) return r_api
def IDENT(current, G,): global varName1 t = tree('IDENT') if current.name == "REFERENCE": current = next(G) current.pattern = "ref-" + current.pattern if current.name != 'ID': raise ParserError("Syntax Error: Error when parsing IDENT: " \ + current.line) tmp = tree('ID') tmp.val = current.pattern t.append(tmp) g = "" try: g = dict_[current.pattern][0] except: pass gt = typeOfVar try: gt = dict_[current.pattern][1] except: pass dict_[current.pattern] = (g, gt) #add symbol to symbol table, will use different values later. varScopeDict[scope_variate] = {current.pattern:(g, gt)} return t, next(G)
def FUNCTIONLST(current, G): global scope_variate t1 = tree("FUNCLIST") while(True): t = tree("FUNCTION") if current.name != "FUNCTION": break type = next(G) funcReturn = tree(type.name) funcReturn.val = type.pattern t.append(funcReturn) name = next(G) funcName = tree(name.name) funcName.val = name.pattern t.append(funcName) funcDict[name.pattern] = type.name scope_variate = name.pattern current = next(G) if current.name == "LPAREN": holder = False current = next(G) while(True): if current.name == "RPAREN": break if current.name == "COMMA": current = next(G) t1, current, holder = STATEMENT(current, G) t.append(t1) current = next(G) tt, current = PROGRAM(current, G) t.append(tt) t1.append(t) return t1, current
def TERM2(current, G): t = tree("TERM2") s = {} # assumes sign returns useful current current, child, s1 = SIGN(current, G) t.children.append(child) s.update(s1) current, child, s1 = FACT2(current, G) t.children.append(child) s.update(s1) while current.name == "TIMES" or current.name == "DIVIDE" or current.name == "MODULO": if current.name == "TIMES": t.children.append(tree("TIMES")) elif current.name == "DIVIDE": t.children.append(tree("DIVIDE")) else: # current.name == "MODULO" t.children.append(tree("MODULO")) current, child, s1 = SIGN(next(G), G) t.children.append(child) s.update(s1) # Assumes FACT2 returns useful current current, child, s1 = FACT2(current, G) t.children.append(child) s.update(s1) return current, t, s
def rearrange_tree(t): '''Take a tree, and rearrange either a tree or a child. Return the rearranged tree.''' if t.size() == 3: return do_rearrange(t) lsize = t.left.size() rsize = t.right.size() if lsize < 3 and rsize < 3: return do_rearrange(t) elif lsize < 3: rand = random.randrange(rsize - 1) if rand == 0: return do_rearrange(t) else: return tree.tree(children=(t.left, rearrange_tree(t.right))) elif rsize < 3: rand = random.randrange(lsize - 1) if rand == 0: return do_rearrange(t) else: return tree.tree(children=(rearrange_tree(t.left), t.right)) else: rand = random.randrange(lsize + rsize - 3) if rand == 0: return do_rearrange(t) elif rand < lsize - 1: return tree.tree(children=(rearrange_tree(t.left), t.right)) else: return tree.tree(children=(t.left, rearrange_tree(t.right)))
def branchnbound_search(cm): '''Do an exhaustive search on all possible trees in the char matrix using branch-and-bound methods.''' global best_length taxa = cm.taxon_set() outgroup = cm.get_outgroup() taxa.remove(outgroup) outgroup_tree = tree.tree(id=outgroup) trees = all_trees_rec_bb(taxa, cm, outgroup_tree) best_tree = None ntrees = 0 for a_tree in trees: ntrees += 1 real_tree = tree.tree(children=(outgroup_tree, a_tree)) tree_len = real_tree.length(cm) if best_length == None or tree_len < best_length: best_tree = [real_tree] best_length = tree_len elif tree_len == best_length: best_tree.append(real_tree) print "Total trees examined: %d" % ntrees print "Length of best tree(s): %d" % best_length print "Number of best tree(s): %d" % len(best_tree) return best_tree
def IDENT(current, G): t = tree("IDENT") s = {current.pattern: None} if not current.name == "ID": raise ParserError("Invalid identifier" + getTokenLineInfo(current)) t.children.append(tree("ID")) return next(G), t, s
def ARITH_OP(current, G): # process the ARITHOP here when building tree before returning the next (G) if current.name == "PLUS": return next(G), tree("PLUS") if current.name == "MINUS": return next(G), tree("MINUS") else: #this should never happen because only way to get to this function is if current is an arith op raise ParserError("Invalid ARITH_OP" + getTokenLineInfo(current))
def IDENT(current, G): t = tree('IDENT') if current.name != 'ID': raise ParserError("Syntax Error: Error when parsing IDENT: " + current.line) tmp = tree('ID') tmp.val = current.pattern t.append(tmp) dict[current.pattern] = ""; #add symbol to symbol table, will use different values later. return t, next(G)
def do_rearrange(t): '''Perform a rearrangement on a tree''' if t.left.is_terminal: child1, child2 = t.right, t.left elif t.right.is_terminal: child1, child2 = t.left, t.right else: child1, child2 = t.children() gchild1, gchild2 = child1.children() return tree.tree(children=(gchild1, tree.tree(children=(gchild2, child2))))
def IDENT(current, G, vartype="notype"): t = tree("IDENT") s = {} if not vartype == "notype": s = {current.pattern: [vartype, 0, 0]} #vartype, decl flag, init flag if not current.name == "ID": raise ParserError("Syntax Error: Invalid identifier" + getTokenLineInfo(current)) t.val = current.pattern t.children.append(tree("ID", val=current.pattern)) return next(G), t, s
def getData(f,words): data = open(f,'r') lines = data.readlines() examples = [] for i in lines: i=i.strip() if(len(i) > 0): i=i.split('\t') if len(i) >= 2: e = (tree(i[0]), tree(i[1])) examples.append(e) return examples
def R(current, G): t = tree("R") if(current.name == 'GREATEREQUAL') | (current.name == 'LESSEQUAL') |\ (current.name == 'EQUAL') | (current.name == 'LESSTHAN') | \ (current.name == 'GREATERTHAN') | (current.name == 'NOTEQUAL'): t.append(tree(current.name)) current = next(G) t2, current = EXP2(current, G) t.append(t2) return t, current else: return t, current
def PROGRAM(current, G): t = tree("PROGRAM") if current.name == "BEGIN": t1 = tree("BEGIN") t.append(t1) t2, current = STATEMENT_LIST(next(G), G) t.append(t2) if current.name == "END": t.append(tree("END")) return t, next(G) raise ParserError("Syntax Error: No 'end' at line: " + current.line) raise ParserError("Syntax Error: No 'begin' at line: " + current.line)
def TYPE(current, G): t = tree("TYPE") s = {} if current.name == "INT": t.children.append(tree("INT")) return next(G), t, s, "INT" elif current.name == "BOOL": t.children.append(tree("BOOL")) return next(G), t, s, "BOOL" elif current.name == "STRING": t.children.append(tree("STRING")) return next(G), t, s, "STRING"
def trees_adding_bb(t, taxon, cm, og): '''Yield all the trees that can be obtained from adding taxon to the tree t''' new_tree = tree.tree(children=(t, tree.tree(id=taxon))) if best_length == None or tree.tree(children=(og, new_tree)).length(cm) < best_length: yield new_tree if not t.is_terminal: l, r = t.left, t.right for a_tree in r.all_trees_left(trees_adding_bb(l, taxon, cm, og)): yield a_tree for a_tree in l.all_trees_right(trees_adding_bb(r, taxon, cm, og)): yield a_tree
def PRIMARY(current, G): global counter t = tree('PRIMARY') if current.pattern in funcDict.keys(): tmp = tree("FUNCCALL") tmp.val = current.pattern paren = next(G) current = next(G) if current.name == "RPAREN": pass else: t1, current = ID_LIST(current, G) if current.name != "RPAREN": raise ParserError("not matching parens") tmp.append(t1) t.append(tmp) return t, next(G) if current.name == 'INTLIT': tmp = tree('INTLIT') tmp.val = current.pattern tuple1 = ("False", typeOfVar) dict_[varName1] = tuple1 #do we need this? t.append(tmp) return t, next(G) if current.name == 'BOOLLIT': tmp = tree('BOOLLIT') tmp.val = current.pattern tuple1 = ("False", typeOfVar) dict_[varName1] = tuple1 #do we need this? t.append(tmp) return t, next(G) if current.name == 'LPAREN': t1, current = EXPRESSION(next(G), G) if current.name != 'RPAREN': raise ParserError("Syntax Error: Expected rparen is missing: " \ + current.line) t.append(t1) return t, next(G) if current.name == "STRING": #unsure tstrlit = tree("STRING") tstrlit.val = current.pattern t.append(tstrlit) # valOfVar = current.pattern tuple1 = (current.pattern, "STRING") tname = "lit%i" % counter strDict[tname] = tuple1 counter = counter + 1 ct = next(G) return t, ct t2, current = IDENT(current, G) t.append(t2) return t, current
def SIGN(current, G): t = tree("SIGN") s = {} if current.t_class == "ARITHOP": if current.name == "MINUS": t.children.append(tree("MINUS")) return next(G), t, s else: raise ParserError( "Syntax Error: Invalid sign for number." + getTokenLineInfo(current)) else: t.children.append(tree("LAMBDA")) return current, t, s
def EXPRESSION(current, G): t = tree("EXPRESSION") t1, current = PRIMARY(current, G) t.append(t1) while True: if (current.name == 'PLUS') | (current.name == 'MINUS'): #May have to add ARITHOP in future t.append(tree(current.name)) current = next(G) t2, current = PRIMARY(current, G) t.append(t2) if (current.name != 'PLUS') & (current.name != 'MINUS'): return t, current
def TERM3(current, G): t = tree("TERM3") t1, current = FACT2(current, G) t.append(t1) while True: if (current.name == 'MULTIPLICATION'): #May have to add ARITHOP in future t.append(tree(current.name)) current = next(G) t2, current = FACT2(current, G) t.append(t2) if (current.name != 'MULTIPLICATION'): return t, current
def FACT3(current, G): t = tree("FACT3") t1, current = PRIMARY(current, G) t.append(t1) while True: if (current.name == 'REMAINDER'): #May have to add ARITHOP in future t.append(tree(current.name)) current = next(G) t2, current = PRIMARY(current, G) t.append(t2) if (current.name != 'REMAINDER'): return t, current
def EXPRESSION(current, G): t = tree("EXPRESSION") t1, current = TERM1(current, G) t.append(t1) while True: if (current.name == 'OR'): #May have to add ARITHOP in future t.append(tree(current.name)) current = next(G) t2, current = TERM1(current, G) t.append(t2) if (current.name != 'OR'): return t, current
def FACT2(current, G): t = tree("FACT2") t1, current = FACT3(current, G) t.append(t1) while True: if (current.name == 'DIVISION'): #May have to add ARITHOP in future t.append(tree(current.name)) current = next(G) t2, current = FACT3(current, G) t.append(t2) if (current.name != 'DIVISION'): return t, current
def TERM1(current, G): t = tree("TERM1") t1, current = FACT1(current, G) t.append(t1) while True: if (current.name == 'AND'): #May have to add ARITHOP in future t.append(tree(current.name)) current = next(G) t2, current = FACT1(current, G) t.append(t2) if (current.name != 'AND'): return t, current
def TERM1(current, G): t = tree("TERM1") s = {} current, child, s1 = FACT1(current, G) t.children.append(child) s.update(s1) while current.name == "AND": t.children.append(tree("AND")) current = next(G) # move to token after "and" current, child, s1 = FACT1(current, G) t.children.append(child) s.update(s1) return current, t, s # current should be in {),;}
def TERM2(current, G): t = tree("TERM2") t1, current = TERM3(current, G) t.append(t1) while True: if (current.name == 'MINUS'): #May have to add ARITHOP in future t.append(tree(current.name)) current = next(G) t2, current = TERM3(current, G) t.append(t2) if (current.name != 'MINUS'): return t, current
def getPPDBData(f,words): data = open(f,'r') lines = data.readlines() examples = [] for i in lines: i=i.strip() if(len(i) > 0): i=i.split('\t') if len(i) == 2: e = (tree(i[0], words), tree(i[1], words)) examples.append(e) else: print i return examples
def RELATION(current, G): t = tree("RELATION") s = {} if current.t_class == "RELATIONOP": t.val = current.pattern t.children.append(tree("RELATIONOP", val=current.pattern)) # assume exp2 returns a useful current current, child, s1 = EXP2(next(G), G) t.children.append(child) s.update(s1) return current, t, s else: t.children.append(tree("LAMBDA")) return current, t, s
def backtracking_multiple_with_DTK2(table, cell, k_best, distributed_vector, dtk_generator=None, level=1): """ table is a table of list of tuples (rules, coordinates) coord is a pair of triple of numbers (i,j,k) recursively find the k best parse trees (is this a beam search?) """ if dtk_generator is None: #print ("none") dtk_generator = dtk.DT(dimension=4096, operation=operation.random_op) def sorting_func(t): if t in cache: return numpy.dot(cache[t], distributed_vector) else: cache[t] = dtk_generator.dt(t) return numpy.dot(cache[t], distributed_vector) def sorting_func_distance_from_1(t): if t in cache: return 1 / numpy.abs(1 - numpy.dot(cache[t], distributed_vector)) else: tt = dtk_generator.dt(t) cache[t] = tt return 1 / numpy.abs(1 - numpy.dot(cache[t], distributed_vector)) #sorting_func = lambda t: numpy.dot(dtk_generator.dt(t) , distributed_vector) first_k = sorted(table[cell], key=sorting_func, reverse=True)[:min(level, k_best)] l = [] for regola, coord in first_k: if coord is None: word = regola.right[0] rule_ = rule(word, ("__STOP__", )) child = tree(rule_, None) t = tree(regola, [child]) #t = tree(regola, None) l.append(t) #return l else: c1, c2 = coord for child1 in backtracking_multiple_with_DTK2( table, c1, k_best, distributed_vector, dtk_generator=dtk_generator, level=level + 1): for child2 in backtracking_multiple_with_DTK2( table, c2, k_best, distributed_vector, dtk_generator=dtk_generator, level=level + 1): t = tree(regola, [child1, child2]) #print (t, sorting_func_distance_from_1(t)) l.append(t) #print (l[0]) l = sorted(l, key=sorting_func, reverse=True)[:k_best] # for i in l: # print(i, sorting_func(i)) # print("-") return l
def top_down_reconstruction2(table, cell=None, k_best=5, distributed_vector=None, dtk_generator=None, lista=None): #global listone """non so se non funziona per bug o il codice è giusto ma concettualmente non puo funzionare""" def scorer(t): return numpy.dot(dtk_generator.dt(t), distributed_vector) if lista is None: #se non ho una lista di partenza la costruisco a partire dalla lista dei nodi di partenza lista_ = [] first = table[cell] r, c = first[0] rule_ = tree(r.left, None) score = scorer(rule_) rule_.coord = cell #print (t, t.coord) lista_.append((rule_, score)) else: lista_ = lista #print ("prima: ", [str(x[0]) for x in lista]) lista_ = sorted(lista_, key=lambda x: x[1], reverse=True) #print ([(str(x[0]), x[1]) for x in lista_]) #random.shuffle(lista) lista_copy = lista_[:] lista_totale = [] #listone.extend(lista_totale) for (t, score) in lista_: lista_albero = [] #lista delle possibili espansioni di QUEL'allbero #numero_terminali = len(list(t.allTerminalNodes())) for index, node in enumerate(t.allTerminalNodes()): #print (index, node) c1 = node.coord if c1 is None: continue cell = table[c1] for elem in cell: #print (elem) if elem[1] is None: children = [tree(root=elem[0].right[0], children=None)] children[0].coord = None tt = tree(root=node.root, children=children) tt.coord = None ttt = t.add(tt, index) score = scorer(ttt) lista_albero.append((ttt, score)) continue cell1 = elem[1][0] cell2 = elem[1][1] #xx = tree(table[cell1][0][0].left) xx = tree(elem[0].right[0]) xx.coord = cell1 #yy = tree(table[cell2][0][0].left) yy = tree(elem[0].right[1]) yy.coord = cell2 children = [xx, yy] tt = tree(root=node.root, children=children) ttt = t.add(tt, index) #print (ttt) score = scorer(ttt) lista_albero.append((ttt, score)) #lista_albero = list(set(lista_albero)) #lista_albero = sorted(lista_albero, key=lambda x: x[1]) #print ([str(x[0]) for x in lista_albero]) lista_totale.extend(lista_albero) lista_totale = list(set(lista_totale)) #listone.extend(lista_totale) lista_totale = sorted(lista_totale, key=lambda x: x[1], reverse=True)[:k_best] #print ([str(x[0]) for x in lista_totale]) #random.shuffle(sorted(lista_totale, key=lambda x: x[1])) #lista_totale = lista_totale[:k_best] if lista_totale: #for x in lista_totale: # print (x[0]) return top_down_reconstruction2(table, None, k_best, distributed_vector, dtk_generator, lista_totale) else: return lista_copy
def setup_board_routes(app: Application, write_enabled: bool): # Create /api end point as root node r_api = tree("api", data=get_node_api()) # Add /api/spb to represent side plane board r_spb = tree("spb", data=get_node_spb()) r_api.addChild(r_spb) # Add /api/mezz to represent Network Mezzaine card r_mezz = tree("mezz", data=get_node_mezz()) r_api.addChild(r_mezz) # Add servers /api/server[1-max] num = pal_get_num_slots() for i in range(1, num + 1): populate_server_node(r_api, i) # Add /api/spb/fruid end point r_temp = tree("fruid", data=get_node_fruid("bmc")) r_spb.addChild(r_temp) # /api/spb/bmc end point r_temp = tree("bmc", data=get_node_bmc()) r_spb.addChild(r_temp) # /api/spb/sensors end point r_temp = tree("sensors", data=get_node_sensors("bmc")) r_spb.addChild(r_temp) # Add /api/spb/fans end point r_temp = tree("fans", data=get_node_fans()) r_spb.addChild(r_temp) # /api/spb/logs end point r_temp = tree("logs", data=get_node_logs("bmc")) r_spb.addChild(r_temp) # Add /api/mezz/fruid end point r_temp = tree("fruid", data=get_node_fruid("nic")) r_mezz.addChild(r_temp) # /api/mezz/sensors end point r_temp = tree("sensors", data=get_node_sensors("nic")) r_mezz.addChild(r_temp) # /api/mezz/logs end point r_temp = tree("logs", data=get_node_logs("nic")) r_mezz.addChild(r_temp) r_api.setup(app, write_enabled)
def KruskalAlgorithm(g): ''' Kruskal algorithm Kruskal algorithm is a way of using greedy algorithm to find the minimum spanning tree of a connected network. The essence of this algorithm is to add arched into the mst until all vertexes have been added ''' if isinstance(g, network) == False: print('ERROR: please input a connected network!') return if g.mark in ['dg','ug']: print('ERROR: please input a connected network!') return mst = tree() vertexGroup = list(range(len(g.vertexes))) usedVertexes = []# used for showing the tree vertexesAdd = []# used for showing the tree for i in range(len(g.vertexes)): usedVertexes.append(0) vertexesAdd.append(-1) cost = 0 while len(set(vertexGroup)) > 1: minDist = g._network__INFINITY s = 0 e = 0 for i in range(len(g.vertexes)): for j in range(len(g.vertexes)): if g.adjMat[i][j] < minDist and vertexGroup[i] != vertexGroup[j]: minDist = g.adjMat[i][j] s = i e = j if minDist == g._network__INFINITY: print('ERROR: the network is not a connected network!') return # be careful here ! # when a vertex is set to a new group # all the vertexes that belong to the same group with this vertex should be included, too target = vertexGroup[s] origin = vertexGroup[e] for i in range(len(vertexGroup)): if vertexGroup[i] == origin: vertexGroup[i] = target if mst.root == -1: mst.root = mst.makeNode() mst.nodes[mst.root].value = g.vertexes[s] usedVertexes[mst.root] = 1 vertexesAdd[mst.root] = mst.root if usedVertexes[s] == 0: parentAdd = mst.makeNode() mst.nodes[parentAdd].value = g.vertexes[s] vertexesAdd[s] = parentAdd usedVertexes[s] = 1 if usedVertexes[e] == 0: childAdd = mst.makeNode() mst.nodes[childAdd].value = g.vertexes[e] vertexesAdd[e] = childAdd usedVertexes[e] = 1 childAdd = vertexesAdd[e] parentAdd = vertexesAdd[s] newChild = mst.nodes[parentAdd].lchild if newChild == -1: mst.nodes[parentAdd].lchild = childAdd mst.nodes[childAdd].parent = parentAdd else: while mst.nodes[newChild].rchild != -1: newChild = mst.nodes[newChild].rchild mst.nodes[newChild].rchild = childAdd mst.nodes[childAdd].parent = newChild cost += minDist print('the minimum cost is :', cost) print('minimum spanning tree is as following:') mst.Show()
def populate_server_node(num): prsnt = pal_is_fru_prsnt(num) if prsnt == None or prsnt == 0: return None r_server = tree("server", data=get_node_server(num)) r_fruid = tree("fruid", data=get_node_fruid("server")) r_sensors = tree("sensors", data=get_node_sensors("server")) r_logs = tree("logs", data=get_node_logs("server")) r_config = tree("config", data=get_node_config("server")) r_bios = tree("bios", data=get_node_bios("server")) r_server.addChildren([r_fruid, r_sensors, r_logs, r_config, r_bios]) r_boot_order_trunk = tree("boot-order", data=get_node_bios_boot_order_trunk("server")) r_postcode_trunk = tree("postcode", data=get_node_bios_postcode_trunk("server")) r_plat_info_trunk = tree("plat-info", data=get_node_bios_plat_info_trunk("server")) r_pcie_port_config_trunk = tree( "pcie-port-config", data=get_node_bios_pcie_port_config_trunk("server")) r_bios.addChildren([ r_boot_order_trunk, r_postcode_trunk, r_plat_info_trunk, r_pcie_port_config_trunk, ]) r_boot_mode = tree("boot_mode", data=get_node_bios_boot_mode("server")) r_clear_cmos = tree("clear_cmos", data=get_node_bios_clear_cmos("server")) r_force_boot_bios_setup = tree( "force_boot_bios_setup", data=get_node_bios_force_boot_setup("server")) r_boot_order = tree("boot_order", data=get_node_bios_boot_order("server")) r_boot_order_trunk.addChildren( [r_boot_mode, r_clear_cmos, r_force_boot_bios_setup, r_boot_order]) return r_server
from lex import tokenize import tree from code_gen import compile_all file = "source.txt" code = open(file).read() tokens = tokenize(code) ast = tree.tree(tokens) # ast.display() c_code = compile_all(ast) f = open('output.c', 'w').write(c_code) # print(tree.name_types)
def labeled_fscore(t1, t2): p = labeled_precision(t1, t2) r = labeled_recall(t1, t2) return 2 * (p * r / (p + r)) def crossbracketing(): pass if __name__ == '__main__': s1 = "(S (NP (NNS futures) (NNS traders)) (VP (VP say) (SBAR (SBAR (NP (DT the) (NNP s&p)) (VP (VBD was) (VP (VBG signaling) (SBAR (IN that) (S (NP (DT the) (NNP dow)) (VP (MD could) (VP (VB fall) (NP (RB as) (JJ much))))))))) (SBAR (RB as) (FRAG (NP (CD 200) (NNS points)) (. .))))))" s2 = "(S (@S (NP (NNS futures) (NNS traders)) (VP (VBP say) (SBAR (NP (DT the) (NNP s&p)) (VP (VBD was) (VP (VBG signaling) (SBAR (IN that) (S (NP (DT the) (NNP dow)) (VP (MD could) (VP (VB fall) (NP (NP (RB as) (JJ much)) (PP (IN as) (NP (CD 200) (NNS points))))))))))))) (. .))" s1 = "(W (X a) (Y b) (Z (c) (d)))" s2 = "(W (X a) (Y (Z b) (V (c) (d))))" t1 = tree(string=s1) t2 = tree(string=s2) p = precision(t1, t2) r = recall(t1, t2) f = fscore(t1, t2) print("precision: ", p, "recall: ", r, "fscore: ", f) print("lp: ", labeled_precision(t1, t2)) print("lr: ", labeled_recall(t1, t2)) print("lf: ", labeled_fscore(t1, t2))
build = "g++" options = "-std=c++11" Name = "EM-MAGIC" from tree import tree import os #call([build,"main.cpp",options,"-o "+name]) cwd = os.getcwd() files = tree(cwd + "/src") include = tree(cwd + "/headers", "d") buildScript = "" linking = "" for i in range(len(include)): buildScript += "mkdir -p " + "\"" + include[i].replace( "/headers", "/build") + "\"" + '\n' include[i] = "-I" + "\"" + include[i] + "\"" for item in files: name = item name = name.replace("/src", "/build") name = name.replace(".cpp", ".o") if not (os.path.exists(name) and os.path.getmtime(item) < os.path.getmtime(name)): buildScript += (" ".join([build, "-c", "\"" + item + "\"", options] + include + ["-o " + "\"" + name + "\""])) + '\n' linking += "\"" + name + "\" " buildFile = open(cwd + "/scripts/build", 'w') buildFile.write(buildScript) buildFile.write(build + " " + linking + options + " -o " + Name + '\n') buildFile.close()
def display(cls): for line in render_lines(tree(cls)): print(line)
def parser_with_reconstruction3(sentence, grammar, k_best, distributed_vector=None, dtk_generator=None, referenceTable=None, rule_filter=2): #uso la grammatica nuova (grammar_2 ) words = sentence.split() n = len(words) #initialize TABLE P = numpy.zeros((n, n), dtype=object) for i, _ in numpy.ndenumerate(P): P[i] = [] #unit production for i, word in enumerate(words): # to prevent uncovered words we create rule of the form X -> w # for each symbol X in the grammar and for each word w in the sentence for symbol in grammar.symbols: rule = gramm.Rule(symbol,[word]) # create a new rule rt = rule.toTree() # and transform into tree score = numpy.dot(dtk_generator.sn(rt), distributed_vector) ## NORMALIZATION score = score/numpy.sqrt(numpy.dot(dtk_generator.sn(rt), dtk_generator.sn(rt))) rt.score = score #P[i][0].append(((rule, None),(rt, score))) P[i][0].append(rt) #P[i][0] = sorted(P[i][0], key=lambda x: x[1][1], reverse=True)[:2] P[i][0] = sorted(P[i][0], key = lambda x: x.score, reverse=True)[:2] #non terminal rules numero_dtk = 0 #count iterations for debugging purpose for i in range(2, n + 1): #TODO: #add a check if numero_dtk is too high and break returning "not parsed" # total_size = len(dtk_generator.dt_cache) + len(dtk_generator.sn_cache) + len(dtk_generator.dtf_cache) # total_size_mbytes = (total_size*8*dtk_generator.dimension)/1048576 # print (i, total_size_mbytes) if psutil.virtual_memory().percent > 95: return False, None, P for j in range(1, n - i + 2): for k in range(1, i): # look for combination of a tree in leftCell with a tree in rightCell leftCell = P[j - 1][k - 1] rightCell = P[j + k - 1][i - k - 1] for (subtree1, subtree2) in itertools.product(leftCell, rightCell): stringa = subtree1.root + " " + subtree2.root for rule in grammar.nonterminalrules[stringa]: #FILTER on rules with too low score passed, ruleScore = filterRule(rule, dtk_generator, distributed_vector, rule_filter) if passed: rtt = tree(root=rule.left, children=[subtree1, subtree2]) score = numpy.dot(dtk_generator.sn(rtt), distributed_vector) ## NORMALIZATION score = score/ruleScore rtt.score = score P[j-1][i-1].append(rtt) numero_dtk = numero_dtk + 1 #sort rules #P[j-1][i-1] = sorted(P[j-1][i-1], key=lambda x: x[1][1], reverse=True) P[j-1][i-1] = sorted(P[j-1][i-1], key=lambda x: x.score, reverse=True) #another k_best rules where the root is different than the first rule selected before #lista_diversi = [x for x in P[j-1][i-1] if x[0][0].left != P[j-1][i-1][0][0][0].left][:k_best] lista_diversi = [x for x in P[j-1][i-1] if x.root != P[j-1][i-1][0].root][:k_best] P[j-1][i-1] = P[j-1][i-1][:k_best] #if the new rules weren't already selected, add them if lista_diversi: for a in lista_diversi: if a not in P[j-1][i-1]: P[j-1][i-1].append(a) #PARTE DI DEBUG #se ho una reference, stampo la lista di regole che ho nella casella dopo aver trimmato e la casella corrispettiva #al primo errore ritorno Pp (stampata bene per confrontarla con referenceTable) if referenceTable is not None: if P[j-1][i-1] and referenceTable[i-1][j-1]: lista_alberi = [x[0][0] for x in P[j-1][i-1]] if referenceTable[i-1][j-1] not in lista_alberi: #rule = P[j-1][i-1][0][0][0] print ("cella: ", (i-1, j-1)) print ([x[0][0] for x in P[j-1][i-1]], referenceTable[i-1][j-1]) # <- questo caso è FAIL #albero_sbagliato = P[j-1][i-1][0][1][0] #score1 = P[j-1][i-1][0][1][1] alberi_sbagliati = [x[1][0] for x in P[j-1][i-1]] dtk_generator.dt_cache = {} print ("SN: ") for albero_sbagliato in alberi_sbagliati: rtt = tree(root = referenceTable[i-1][j-1].left, children=alberi_sbagliati[0].children) score1 = numpy.dot(dtk_generator.sn(albero_sbagliato), distributed_vector) print (score1, albero_sbagliato) score2 = numpy.dot(dtk_generator.sn(rtt), distributed_vector) print (score2, rtt) dtk_generator.dtf_cache = {} print ("DTF: ") for albero_sbagliato in alberi_sbagliati: score1 = numpy.dot(dtk_generator.dtf(albero_sbagliato), distributed_vector) regola = tree(root=albero_sbagliato.root, children=[tree(albero_sbagliato.children[0].root, None),tree(albero_sbagliato.children[1].root, None)]) print ("punteggio regola: ", numpy.dot(dtk_generator.dtf(regola), distributed_vector), regola) print (score1, albero_sbagliato) score2 = numpy.dot(dtk_generator.dtf(rtt), distributed_vector) print (score2, rtt) #return False, None, P else: if referenceTable[i-1][j-1]: # e P[][] è vuota pass #print (P[j-1][i-1],referenceTable[i-1][j-1] ) # <- questo caso è FAIL #return False, None, P if P[j-1][i-1]: # e referenceTable è 0 pass #print ("ok?", P[j-1][i-1],referenceTable[i-1][j-1] ) # <- questo caso può andar bene #FINE DEBUG #print (numero_dtk) #number of iteration #list of tree in the final cell of the table finalList = P[0][-1] if finalList: #final sort (by DTK) finalList = sorted(finalList, key=lambda x: numpy.dot(dtk_generator.dt(x),distributed_vector), reverse=True) return True, finalList , P else: #treeToCYKMatrix.printCYKMatrix(simpleTable(P)) return False, None, P
fit_group = train_stats['fit_group'] # mutate fit group into a new generation forest = [] for t in fit_group[:, 0]: # make two copies of each model and mutate them #new_tree_1 = tree(rand_gen=True, size=np.random.randint(tree_size_range[0], tree_size_range[-1])) new_tree_1 = copy.copy(t) new_tree_1.mutate() forest.append(new_tree_1) # scheme 1: second tree will be another mutant of the fit group #new_tree_2 = copy.copy(t) #new_tree_2.mutate() # scheme 2: second tree will be randomly generated new_tree_2 = tree(rand_gen=True, size=np.random.randint(tree_size_range[0], tree_size_range[-1])) forest.append(new_tree_2) # simulate new generation and get scores scores = [] for df in data: scores.append([t.basic_simulation(df, freq_weighted_scoring=True) for t in forest]) scores = np.mean(np.array(scores), axis=0) nans = np.isnan(scores) scores[nans] = 0 eval_forest = [] for t, s in zip(forest, scores): eval_forest.append([t, s]) eval_forest = np.array(eval_forest)
def parser_with_reconstruction(sentence, grammar, k_best, distributed_vector=None, dtk_generator=None, albero=None): #uso la grammatica nuova e i tree giusti #also, uso una seconda matrice B[n,n,r] di backpointers tk = TK(LAMBDA=0.4) words = sentence.split() n = len(words) r = len(grammar.symbols) #initialization of a chart with empty lists P = numpy.zeros((n, n, r), dtype=object) #B = numpy.zeros((n, n, r), dtype=object) for i, _ in numpy.ndenumerate(P): P[i] = [] #B[i] = [] #unit production for i, word in enumerate(words): try: rules = grammar.terminalrules[word] except KeyError: print("la parola ", word, " non appare nelle regole") for rule in rules: #print (rule, rule.toTree()) rt = rule.toTree() index = grammar.symbols[rule.left] P[i][0][index].append(((rule, None), (rt, 1))) #B[i][0][index].append(None) for k in range(r): P[i][0][k] = P[i][0][k][:k_best] #if len(P[i][0][k]) > 0: # print (len(P[i][0][k])) #non terminal rules numero_dtk = 0 for i in range(2, n + 1): for j in range(1, n - i + 2): for k in range(1, i): for rule in grammar.nonterminalrules: a = grammar.symbols[rule.left] b = grammar.symbols[rule.right[0]] c = grammar.symbols[rule.right[1]] if P[j - 1][k - 1][b] and P[j + k - 1][i - k - 1][c]: #rt = rule.toTree() #print (rt) #print (len(P[j - 1][k - 1][b]), " * ", len(P[j + k - 1][i - k - 1][c])) for x, y in itertools.product( P[j - 1][k - 1][b], P[j + k - 1][i - k - 1][c]): subtree1 = x[1][0] subtree2 = y[1][0] rtt = tree(root=rule.left, children=[subtree1, subtree2]) #print (rtt) score = numpy.dot(dtk_generator.dt(rtt), distributed_vector) #score = tk.evaluate(rtt, albero) numero_dtk = numero_dtk + 1 #P[j - 1][i - 1][a].append(((rule, ((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))), (rtt, score))) P[j - 1][i - 1][a].append( ((rule, ((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))), (rtt, score))) #P[j - 1][i - 1].append(((rule, ((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))), (rtt, score))) #print (P[j - 1][k - 1][a]) #B[j - 1][i - 1][a].append(((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))) P[j - 1][i - 1][a] = sorted(P[j - 1][i - 1][a], key=lambda x: x[1][1], reverse=True)[:k_best] print(numero_dtk) #find the coordinate of the cell with the final "S" fc = None if P[0][-1][grammar.start_symbol_index]: fc = grammar.start_symbol_index if fc is not None: return True, P[0][-1][fc] else: return False, None
def init_plat_tree(): # Create /api end point as root node r_api = tree("api", data = get_node_api()) # Add /api/fcb to represent fan control board r_fcb = tree("fcb", data = get_node_fcb()) r_api.addChild(r_fcb) # Add /api/pdpb to represent fan control board r_pdpb = tree("pdpb", data = get_node_pdpb()) r_api.addChild(r_pdpb) # Add /api/peb to represent fan control board r_peb = tree("peb", data = get_node_peb()) r_api.addChild(r_peb) #Add /api/fcb/fans end point r_temp = tree("fans", data = get_node_fans()) r_fcb.addChild(r_temp) #Add /api/fcb/fruid end point r_temp = tree("fruid", data = get_node_fruid("fcb")) r_fcb.addChild(r_temp) #Add /api/fcb/sensors end point r_temp = tree("sensors", data = get_node_sensors("fcb")) r_fcb.addChild(r_temp) #Add /api/fcb/logs end point r_temp = tree("logs", data = get_node_logs("fcb")) r_fcb.addChild(r_temp) #Add /api/pdpb/sensors end point r_temp = tree("sensors", data = get_node_sensors("pdpb")) r_pdpb.addChild(r_temp) #Add /api/pdpb/flash end point r_temp = tree("flash", data = get_node_flash()) r_pdpb.addChild(r_temp) #Add /api/pdpb/fruid end point r_temp = tree("fruid", data = get_node_fruid("pdpb")) r_pdpb.addChild(r_temp) #Add /api/pdpb/logs end point r_temp = tree("logs", data = get_node_logs("pdpb")) r_pdpb.addChild(r_temp) #Add /api/peb/fruid end point r_temp = tree("fruid", data = get_node_fruid("peb")) r_peb.addChild(r_temp) #Add /api/peb/sensors end point r_temp = tree("sensors", data = get_node_sensors("peb")) r_peb.addChild(r_temp) #Add /api/peb/bmc end point r_temp = tree("bmc", data = get_node_bmc()) r_peb.addChild(r_temp) #Add /api/peb/health end point r_temp = tree("health", data = get_node_health()) r_peb.addChild(r_temp) #Add /api/peb/logs end point r_temp = tree("logs", data = get_node_logs("peb")) r_peb.addChild(r_temp) return r_api
##########Parsing program inputs########## inps = parse() indata = gamma_reader.gamma_reader(inps.dem_par_name, inps.I_name, inps.theta_name, inps.phi_name, inps.cor_name) indata.read_igram(scale=inps.scale, flip=inps.flipvert, mult=inps.mult) #indata.read_geom(az = inps.useaz, defgeom = inps.usedefgeom, flip = inps.flipvert) #FIXME az not found indata.read_geom(flip=inps.flipvert) #FIXME az not found indata.read_coherence(flip=inps.flipvert) indata.mask_igram_by_threshold(inps.corthresh) sampler = tree.tree(inps.minsize, inps.maxsize, inps.thresh, inps.minres, method=inps.usevar) sampler.resample(indata) sampler.write(inps.out_name, rsp=inps.rsp) npts = len(sampler.xi) ########Plot data if inps.plot: plt.figure('Decomposition') plt.jet() orgax = plt.subplot(221) plt.imshow(indata.phs) tks = np.linspace(np.nanmin(indata.phs), np.nanmax(indata.phs), num=5) orgax.set_ylabel('Pixels') orgax.set_xticklabels([])
from tree import tree as tree from initialization import make_galaxy import matplotlib.pyplot as plt import numpy as np import matplotlib.animation as animation G = 0.0044995611 dt = 1 # Myrs universe_size = 50 theta = 1. N = 50 chi = 10. #softening bodies = make_galaxy(N, chi, G) sys = tree(bodies, G, universe_size, dt, theta, chi) fig, (ax) = plt.subplots(1, 1) ax.set_xlim(-universe_size / 2., universe_size / 2.) ax.set_ylim(-universe_size / 2., universe_size / 2.) ax.set_title('N =' + str(N)) points = ax.plot(*([[], []] * N), marker="o", color='black', markersize=1) #change the size def init(): for j in range(N): points[j].set_data([], []) return (points)
# coding: utf-8 import binary_tree import tree x=tree.tree(1000) y=tree.tree(2000) z=tree.tree(3000) w=tree.tree(6) v=tree.tree(7) r = tree.tree(8) u = tree.tree(2) x.AddSuccessor(y) x.AddSuccessor(z) c=tree.tree(5) z.AddSuccessor(c) y.AddSuccessor(w) y.AddSuccessor(v) w.AddSuccessor(r) y.AddSuccessor(u) test = binary_tree.binary_tree(100) test2 = binary_tree.binary_tree(200) test3 = binary_tree.binary_tree(300) test4 = binary_tree.binary_tree(400) test5 = binary_tree.binary_tree(500) test6 = binary_tree.binary_tree(600) test7 = binary_tree.binary_tree(7) test.AddLeft(test2)
def calculExecution(): ''' Construction of technology and intervention matrices with uncertainties informations Construction of Caracterisation facteurs matrix ''' runButton.config(state="disabled") global pb_hD system_filename = os.path.join(path, "programme", "..", "databases", database) #export from Simapro infoFrame1 = Frame(informationsFrame) infoFrame1.pack() Label(infoFrame1, text="Reading the database and constructing the matrices...").pack( side=LEFT) (system_meta_info, UP_meta_info, UP_list, EF_list, all_flow, technology_matrix, intervention_matrix, CF_matrices, CF_categories, CF_units, EF_unit, unit_converter, infrastructure_rescale, uncertainty_info) = SimaPro_reader(system_filename, impact_method) Label(infoFrame1, text="Done").pack() CF_matrix = CF_matrices[impact_method] CF_categories = CF_categories[impact_method] CF_units = CF_units[impact_method] CF_categories_name = [re.sub("\W", "_", cat) for cat in CF_categories] EF_by_number = {} for (compartment, substance, subcompartment) in EF_list: EF = [compartment, substance, subcompartment] EF_number = EF_list.index(EF) EF = (compartment, substance, subcompartment) EF_by_number[EF_number] = EF ###Transformation of the technology and intervention matrices for testing the fonctionnality of the algorithme. infoFrame2 = Frame(informationsFrame) infoFrame2.pack() Label(infoFrame2, text="transformating matrices for tests ...").pack(side=LEFT) (technology_matrix, intervention_matrix, uncertainty_info, UP_list, CF_transformed) = transformation_matrices(technology_matrix, intervention_matrix, uncertainty_info, UP_list, CF_matrix) Label(infoFrame2, text="Done").pack() print_results(path + project_name, project_name, UP_list, EF_list, database, impact_method, CF_categories, CF_units, iterations, disaggregation_criterion, uncertainty_info, CF_matrix) ###Calculation of the determinists scores infoFrame3 = Frame(informationsFrame) infoFrame3.pack() Label(infoFrame3, text="Calculating deterministic scores ...").pack(side=LEFT) t0 = time.time() #inverse_technology_matrix=spsolve(technology_matrix, identity(technology_matrix.shape[0])) inverse_technology_matrix = inv(technology_matrix.todense()) tinv = time.time() - t0 #print "temps d'inversion : "+str(tinv) Z = (identity(len(technology_matrix.todense())) - technology_matrix) inverse_technology_matrix = fix_inverse(Z, inverse_technology_matrix) intensity_matrix = matrix( intervention_matrix.dot(inverse_technology_matrix)) all_system_scores, all_unit_scores = calculate_all_scores( identity(len(technology_matrix.todense())), intensity_matrix, intervention_matrix, CF_matrix) Label(infoFrame3, text="Done").pack() if correlatedMC.get(): ###Monte-Carlo in the correlated case and storage of the matrices (laws'parameters) Label( informationsFrame, text="Uncertainty analysis under a fully-correlated assumption..." ).pack() pb_hD.pack() essai = 0 while 1: try: os.mkdir( os.path.join(path, project_name, "correlated_impacts" + str(essai))) break except: essai += 1 (variables_technologique, variables_intervention) = MC_correlated_preparation( technology_matrix, intervention_matrix, uncertainty_info['technology'], uncertainty_info['intervention']) MC(variables_technologique, variables_intervention, CF_matrix, CF_categories_name, iterations, UP_list, "all", os.path.join(path, project_name, "correlated_impacts" + str(essai)), [], progress) infoFrame4 = Frame(informationsFrame) infoFrame4.pack() Label(infoFrame4, text="Printing parameters and covariances ...").pack(side=LEFT) sigma_correlated, mu_correlated, sign_correlated = calcul_parameters( UP_list, os.path.join(path, project_name, "correlated_impacts"), len(CF_categories)) results_cor = csv.writer( open( os.path.join(path, project_name, "Monte-Carlo_results_correle.csv"), "wb")) results_cor.writerow( ["index", "processus"] + ["impact " + category for category in CF_categories] + ["sign " + category for category in CF_categories] + ["mu " + category for category in CF_categories] + ["sigma " + category for category in CF_categories]) for up in range(len(UP_list) - 4): results_cor.writerow( [up, UP_list[up]] + [impact[0] for impact in all_system_scores[:, up].tolist()] + [ssign[0] for ssign in sign_correlated[:, up].tolist()] + [mmu[0] for mmu in mu_correlated[:, up].tolist()] + [sigma[0] for sigma in sigma_correlated[:, up].tolist()]) ###Calculation of the cariance-covariance matrices calcul_vcv(UP_list, impact_method, CF_categories_name, os.path.join(path, project_name)) Label(infoFrame4, text="Done").pack() if nocorrelatedMC.get(): sigma_correlated, mu_correlated, sign_correlated = calcul_parameters( UP_list, os.path.join(path, project_name, "correlated_impacts"), len(CF_categories)) essai = 0 while 1: try: os.mkdir( os.path.join(path, project_name, "nocorrelated_impacts" + str(essai))) break except: essai += 1 ###Monte-Carlo in the correlated case and storage of the matrices (laws'parameters) Label( informationsFrame, text="Uncertainty analysis under a fully-uncorrelated assumption..." ).pack() full_results_UP = {} full_results_EF = {} level_reached = {} system_scores = {} child_list = {} score_list_EF = {} coefficient_list = {} link_UP_EF_full_result = {} systems = [] for proc in UP_list: systems.append({proc: 1}) processRunned = Label(informationsFrame, text="") processRunned.pack() for system_number in range(nocorrBegin.get(), max(nocorrEnd.get(), len(UP_list) - 4)): #disaggregation for every system processRunned.config(text="Process " + str(system_number)) pb_hD.pack() full_results_UP = {} full_results_EF = {} level_reached = {} system_scores = {} child_list = {} score_list_EF = {} coefficient_list = {} link_UP_EF_full_result = {} final_demand_vector = build_final_demand_vector( systems[system_number], UP_list) start_time = time.time() full_results_UP = {} level_reached = {} #Desagregation of the system full_results_UP, level_reached, system_scores = systematic_disaggregation_UP( disaggregation_criterion, full_results_UP, level_reached, system_scores, UP_meta_info, UP_list, EF_list, technology_matrix, intervention_matrix, CF_matrix, CF_categories, EF_unit, uncertainty_info, intensity_matrix, Z, all_system_scores, all_unit_scores, impact_method, final_demand_vector, system_number, systems) UP_list_desag = construct_UP_list_desag(full_results_UP, UP_list) tree(UP_list_desag, UP_meta_info, impact_method, CF_categories, all_system_scores, all_unit_scores, CF_units, os.path.join(path, project_name, "trees")) (variables_technologique, variables_intervention) = MC_nocorrelated_preparation( technology_matrix, intervention_matrix, uncertainty_info['technology'], uncertainty_info['intervention'], UP_list, UP_list_desag, mu_correlated, sign_correlated, sigma_correlated) MC( variables_technologique, variables_intervention, CF_transformed, CF_categories_name, iterations, UP_list_desag, system_number, os.path.join(path, project_name, "nocorrelated_impacts" + str(essai)), systems, progress) infoFrame5 = Frame(informationsFrame) infoFrame5.pack() Label(infoFrame5, text="Printing parameters ...").pack(side=LEFT) sigma_nocorrelated, mu_nocorrelated, sign_nocorrelated = calcul_parameters( UP_list[:-4], os.path.join(path, project_name, "correlated_impacts"), len(CF_categories)) results_nocor = csv.writer( open( os.path.join(path, project_name, "Monte-Carlo_results_nocorrele.csv"), "wb")) results_nocor.writerow( ["index", "processus"] + ["impact " + category for category in CF_categories] + ["sign " + category for category in CF_categories] + ["mu " + category for category in CF_categories] + ["sigma " + category for category in CF_categories]) for up in range(len(UP_list) - 4): results_nocor.writerow( [up, UP_list[up]] + [impact[0] for impact in all_system_scores[:, up].tolist()] + [ssign[0] for ssign in sign_nocorrelated[:, up].tolist()] + [mmu[0] for mmu in mu_nocorrelated[:, up].tolist()] + [sigma[0] for sigma in sigma_nocorrelated[:, up].tolist()]) Label(infoFrame5, text="Done").pack(side=LEFT)
def setup_board_routes(app: Application, write_enabled: bool): # Create /api end point as root node r_api = tree("api", data=get_node_api()) # Add /api/mezz to represent Mezzanine Card r_mezz = tree("nic", data=get_node_mezz()) r_api.addChild(r_mezz) # Add /api/iom to represent IO Module r_iom = tree("iom", data=get_node_iom()) r_api.addChild(r_iom) # Add /api/dpb to represent Drive Plan Board r_dpb = tree("dpb", data=get_node_dpb()) r_api.addChild(r_dpb) # Add /api/scc to represent Storage Controller Card r_scc = tree("scc", data=get_node_scc()) r_api.addChild(r_scc) # Add servers /api/slot[1-max] num = pal_get_num_slots() for i in range(1, num + 1): r_server = populate_server_node(i) if r_server: r_api.addChild(r_server) # Add /api/mezz/sensors end point r_temp = tree("sensors", data=get_node_sensors("nic")) r_mezz.addChild(r_temp) # Add /api/mezz/logs end point r_temp = tree("logs", data=get_node_logs("nic")) r_mezz.addChild(r_temp) # Add /api/iom/fruid end point r_temp = tree("fruid", data=get_node_fruid("iom")) r_iom.addChild(r_temp) # Add /api/iom/sensors end point r_temp = tree("sensors", data=get_node_sensors("iom")) r_iom.addChild(r_temp) # Add /api/iom/logs end point r_temp = tree("logs", data=get_node_logs("iom")) r_iom.addChild(r_temp) # Add /api/iom/bmc end point r_temp = tree("bmc", data=get_node_bmc()) r_iom.addChild(r_temp) # Add /api/iom/health end point r_temp = tree("health", data=get_node_health()) r_iom.addChild(r_temp) # Add /api/iom/identify end point r_temp = tree("identify", data=get_node_identify("iom")) r_iom.addChild(r_temp) # Add /api/dpb/fruid end point r_temp = tree("fruid", data=get_node_fruid("dpb")) r_dpb.addChild(r_temp) # Add /api/dpb/sensors end point r_temp = tree("sensors", data=get_node_sensors("dpb")) r_dpb.addChild(r_temp) # Add /api/dpb/logs end point r_temp = tree("logs", data=get_node_logs("dpb")) r_dpb.addChild(r_temp) # Add /api/dpb/fans end point r_temp = tree("fans", data=get_node_fans()) r_dpb.addChild(r_temp) # Add /api/dpb/hdd-status end point r_tmp = tree("hdd-status", data=get_node_enclosure_hdd_status()) r_dpb.addChild(r_tmp) # Add /api/dpb/error end point r_tmp = tree("error", data=get_node_enclosure_error()) r_dpb.addChild(r_tmp) # Add /api/dpb/flash-health end point r_tmp = tree("flash-health", data=get_node_enclosure_flash_health()) r_dpb.addChild(r_tmp) # Add /api/dpb/flash-status end point r_tmp = tree("flash-status", data=get_node_enclosure_flash_status()) r_dpb.addChild(r_tmp) # Add /api/scc/fruid end point r_temp = tree("fruid", data=get_node_fruid("scc")) r_scc.addChild(r_temp) # Add /api/scc/sensors end point r_temp = tree("sensors", data=get_node_sensors("scc")) r_scc.addChild(r_temp) # Add /api/scc/logs end point r_temp = tree("logs", data=get_node_logs("scc")) r_scc.addChild(r_temp) r_api.setup(app, write_enabled)
ROOT.gROOT.SetBatch() ROOT.TMVA.Tools.Instance() ROOT.TMVA.PyMethodBase.PyInitialize() outFile = ROOT.TFile.Open(options.output, "RECREATE") files = [] xmlTree = ET.parse(options.xml) for s in xmlTree.findall('sample'): if s.get('id') == options.sample and s.get('tag') == options.tag: for child in s: files.append(child.text) elecPrompt = tr.tree('elecPrompt') elecNonPrompt = tr.tree('elecNonPrompt') muonPrompt = tr.tree('muonPrompt') muonNonPrompt = tr.tree('muonNonPrompt') gtr = ROOT.TChain(c.treeName) for f in files: print f gtr.Add(f) nEntries = gtr.GetEntries() print 'Number of events:', nEntries # dl = mva.mva(gtr, options.model, 'xgb') # tmva = mva.mva(gtr, options.model, 'tmva')
def run(level_cnt, grid_step, N, eps): grid_dim = 2**(level_cnt-1) # Should remain power of two for easy life src_list = [] for i in range(N): src_list.append(source.source(grid_dim * np.random.random(),grid_dim *\ np.random.random(), np.random.random())) # Map src to nearest lower left grid pnt src_list[i].grid = (int(np.floor(src_list[i].x/grid_step)), \ int(np.floor(src_list[i].y/grid_step))) print("Building Tree...") my_tree = tree.tree(src_list, level_cnt) my_tree.build() print("Filling Interaction Lists...") interactions = interaction.interaction(level_cnt, my_tree) interactions.fill_list() leaf_start = 2**(2*(level_cnt-1)) leaf_end = 2*leaf_start for obs_idx in range(leaf_start, leaf_end): for src_idx in range(leaf_start, leaf_end): G = interactions.build_G(my_tree.tree[obs_idx], \ my_tree.tree[src_idx]) if (my_tree.tree[src_idx] == []) or (my_tree.tree[obs_idx] == []): U, V = np.array([]), np.array([]) else: U,V = utils.uv_decompose(G, eps) srcs = np.array([src_list[i] for i in my_tree.tree[src_idx]]) obs_ids = my_tree.tree[obs_idx] src_vec = np.array([src.weight for src in srcs]) interactions.src_vecs[obs_idx][src_idx] = src_vec interactions.obs_vecs[obs_idx] = obs_ids interactions.uv_list[obs_idx][src_idx] = (U,V) print('Computing UV Decompositions...') for lvl in range(level_cnt-2, 1, -1): lb = 2**(2*lvl) ub = 2*lb for obs_idx in range(lb,ub): for src_idx in interactions.list[obs_idx]: # for src_idx in range(lb,ub): n = my_tree.get_children(obs_idx,lvl) #rows of merging m = my_tree.get_children(src_idx,lvl) #cols of merging uv = [[0,0],[0,0]] # index as [row][col] for i in range(2): for j in range(2): U1, V1 = interactions.uv_list[n[2*i]][m[2*j]] U2, V2 = interactions.uv_list[n[2*i+1]][m[2*j]] U3, V3 = interactions.uv_list[n[2*i]][m[2*j+1]] U4, V4 = interactions.uv_list[n[2*i+1]][m[2*j+1]] U12,V12 = utils.merge(U1, V1, U2, V2, eps) U34,V34 = utils.merge(U3, V3, U4, V4, eps) # Horizontal merge uv[i][j] = utils.merge(U12, V12, U34, V34, eps, 1) Um1,Vm1 = utils.merge(uv[0][0][0], uv[0][0][1],\ uv[1][0][0], uv[1][0][1], eps) Um2,Vm2 = utils.merge(uv[0][1][0], uv[0][1][1], \ uv[1][1][0], uv[1][1][1], eps) src_vec = np.array([]) obs_ids = [] for box_idx in m: srcs = np.array([src_list[i] for i in my_tree.tree[box_idx]]) src_vec = np.hstack((src_vec, np.array([src.weight \ for src in srcs]))) for box_idx in n: obss = np.array([src_list[i] for i in my_tree.tree[box_idx]]) obs_ids = obs_ids + my_tree.tree[box_idx] U,V = utils.merge(Um1, Vm1, Um2, Vm2, eps, 1) interactions.src_vecs[obs_idx][src_idx] = src_vec interactions.obs_vecs[obs_idx] = obs_ids interactions.uv_list[obs_idx][src_idx] = (U, V) fast_time = 0 print("Computing Fast Interactions...") for obs_box_idx in range(len(interactions.list)): obs_srcs_near = my_tree.tree[obs_box_idx] obs_srcs_far = interactions.obs_vecs[obs_box_idx] obs_pot_near = np.zeros(len(obs_srcs_near)) obs_pot_far = np.zeros(len(obs_srcs_far)) for src_box_idx in interactions.list[obs_box_idx]: # src_srcs = my_tree.tree[src_box_idx] src_vec = interactions.src_vecs[obs_box_idx][src_box_idx] # src_vec = np.array([src_list[idx].weight for idx in src_srcs]) U, V = interactions.uv_list[obs_box_idx][src_box_idx] if np.size(U) != 0: s = time.clock() obs_pot_far += np.dot(U, np.dot(V, src_vec)) fast_time += time.clock() - s #near field interacitons obs_pot_near += interactions.compute_near(obs_box_idx) for i, obs in enumerate(obs_srcs_near): s = time.clock() interactions.potentials[obs] += obs_pot_near[i] fast_time += time.clock() - s for i, obs in enumerate(obs_srcs_far): s = time.clock() interactions.potentials[obs] += obs_pot_far[i] fast_time += time.clock() - s #Direct Computation print("Computing Direct Interactions...") idxs = [i for i in range(N)] G = interactions.build_G(idxs, idxs) src_vec = np.array([src.weight for src in src_list]) s = time.clock() direct_potentials = np.dot(G, src_vec) slow_time = time.clock() - s # error = (lg.norm(interactions.potentials) - lg.norm(direct_potentials))\ / lg.norm(direct_potentials) print('Error: ', error) print('Fast Time: ', fast_time) print('Slow Time: ', slow_time) return(fast_time, slow_time, error) ## old testing code but saving it just incase ### #lvl = 2 #obs_idx = 16 #src_idx = 25 #n = my_tree.get_children(obs_idx,lvl) #rows of merging #m = my_tree.get_children(src_idx,lvl) #cols of merging #rank = 1 #uv = [[0,0],[0,0]] # index as [row][col] #for i in range(2): # for j in range(2): # print(i,j) # U1, V1 = interactions.uv_list[n[2*i]][m[2*j]] # U2, V2 = interactions.uv_list[n[2*i+1]][m[2*j]] # U3, V3 = interactions.uv_list[n[2*i]][m[2*j+1]] # U4, V4 = interactions.uv_list[n[2*i+1]][m[2*j+1]] # # U12,V12 = utils.merge(U1, V1, U2, V2, eps) # U34,V34 = utils.merge(U3, V3, U4, V4, eps) # # Horizontal merge # uv[i][j] = utils.merge(U12, V12, U34, V34, eps, 1) # #Um1,Vm1 = utils.merge(uv[0][0][0], uv[0][0][1],\ # uv[1][0][0], uv[1][0][1], eps) #Um2,Vm2 = utils.merge(uv[0][1][0], uv[0][1][1], \ # uv[1][1][0], uv[1][1][1], eps) # #U,V = utils.merge(Um1, Vm1, Um2, Vm2, eps, 1)
def pseudotime(data, cells, var_explained=0.99, m=None, k=None, resid_factor=1.0, max_iter=1, eps=1e-5, sig=0.1, gam=1.0, verbose=False): x = data.copy().astype(np.float64) if m is None: pca_evrcs = PCA().fit(x.T).explained_variance_ratio_.cumsum() m = (pca_evrcs < var_explained).sum() m = max(2, m) pca = PCA(n_components=m) x = pca.fit_transform(x.T).T ev = pca.explained_variance_ratio_.cumsum()[m - 1] if verbose: print 'pca, n_components =', m, 'var explained', round(ev, 3) shift = x.mean(1)[:, np.newaxis] x -= shift scale = np.abs(x).max(1)[:, np.newaxis] x /= scale # k means n = max(x.shape) start = time.time() if k is None: k = n c = KMeans(n_clusters=k).fit(x.T).cluster_centers_.T if verbose: print 'k-means, k =', k, round(time.time() - start, 2), 's' for it in range(max_iter): last_x = x.copy() last_c = c.copy() c, stree = rge(x, c, eps=eps, sig=sig, gam=gam, verbose=verbose) e_idx = np.stack(np.where(stree)) e = c[:, e_idx] x2 = (x * x).sum(0)[:, np.newaxis] d = x2 - 2.0 * x.T.dot(e[:, 0]) + (e[:, 0]**2).sum(0) d += x2 - 2.0 * x.T.dot(e[:, 1]) + (e[:, 1]**2).sum(0) idx = d.argmin(1) a = np.diff(e[..., idx], axis=1).squeeze() b = x - e[:, 0, idx] proj = [] for i, (ai, bi) in enumerate(zip(a.T, b.T)): proj.append(ai.dot(bi) / ai.dot(ai)) r = bi - proj[-1] * ai bi -= resid_factor * r x[:, i] = bi + e[:, 0, idx[i]] proj = np.array(proj) e = e_idx[:, idx].T c_err = ((c - last_c)**2).sum(0) / (c**2).sum(0) x_err = ((x - last_x)**2).sum(0) / (x**2).sum(0) if verbose: print it, c_err.mean(), x_err.mean() if c_err.mean() < eps and x_err.mean() < eps: break stree = np.array(stree) x, c = scale * x, scale * c x, c = shift + x, shift + c x = pca.inverse_transform(x.T).T c = pca.inverse_transform(c.T).T if verbose: fig = plt.figure(figsize=(8, 8)) ax = plt.gca() pca = PCA(n_components=2).fit(np.hstack((x, c)).T) x_pca = pca.transform(x.T) c_pca = pca.transform(c.T) ax.scatter(*x_pca.T, color='k') idxs = np.stack(np.where(stree), 1) for idx1, idx2 in idxs: x1, y1 = c_pca[idx1] x2, y2 = c_pca[idx2] ax.plot([x1, x2], [y1, y2], 'k-', lw=0.5) ax.scatter(*c_pca.T, color='k', s=2) ax.axis('off') plt.show() tr = tree.tree(c, stree) stem_cell_data = data[:, cells == 'stem'] tr.set_root(stem_cell_data) tr.get_pseudotime() t = [] for ie, ei in enumerate(e): v1, v2 = ei t1, t2 = tr.t[v1], tr.t[v2] t.append(t1 + proj[ie] * (t2 - t1)) t = np.array(t) t -= t.min() t /= t.max() return t, tr
def __init__(self, model, sentence, ids): self.sentence = sentence self.tree = tree(model, ids, sentence)
if __name__ == "__main__": #PARAMETER DEFINITION: #-grammar: #g = grammar(rules) #G = grammar.Grammar_(rules) distributed = dtk.DT(dimension=1024, LAMBDA=0.4, operation=operation.shuffled_convolution) ss = "(S (@S (NP (@NP (@NP (NP (NNP Pierre)(NNP Vinken))(, ,))(ADJP (NP (CD 61)(NNS years))(JJ old)))(, ,))(VP (MD will)(VP (@VP (@VP (VB join)(NP (DT the)(NN board)))(PP (IN as)(NP (@NP (DT a)(JJ nonexecutive))(NN director))))(NP (NNP Nov.)(CD 29)))))(. .))" l = tree(string=ss) l = tree.binarize(l) l = tree.normalize(l) sent = tree.sentence(l) print(l) rules = [grammar.fromTreetoRule(x) for x in l.allRules()] g = grammar.Grammar(rules) _, p, P = parser_with_reconstruction3(sent, g, 1, distributed.dt(l), distributed) T = treeToCYKMatrix.treeToCYKMatrix(l) M = simpleTable(P)
def parser_with_reconstruction2(sentence, grammar, k_best, distributed_vector=None, dtk_generator=None): #uso la grammatica nuova e i tree giusti #also, uso una seconda matrice B[n,n,r] di backpointers words = sentence.split() n = len(words) r = len(grammar.symbols) #P = n*[n*[r*[[]]]] #initialization of a chart with empty lists P = numpy.zeros((n, n), dtype=object) for i, _ in numpy.ndenumerate(P): P[i] = [] #B[i] = [] #unit production for i, word in enumerate(words): try: rules = grammar.terminalrules[word] except KeyError: print("la parola ", word, " non appare nelle regole") for rule in rules: #print (rule, rule.toTree()) rt = rule.toTree() #score = numpy.dot(dtk_generator.dt(rt), distributed_vector) P[i][0].append(((rule, None), (rt, 1))) P[i][0] = sorted(P[i][0], key=lambda x: x[1][1], reverse=True) #non terminal rules numero_dtk = 0 for i in range(2, n + 1): for j in range(1, n - i + 2): for k in range(1, i): for rule in grammar.nonterminalrules: a = grammar.symbols[rule.left] b = grammar.symbols[rule.right[0]] c = grammar.symbols[rule.right[1]] lista_b = [ x for x in P[j - 1][k - 1] if x[0][0].left == rule.right[0] ] lista_c = [ x for x in P[j + k - 1][i - k - 1] if x[0][0].left == rule.right[1] ] if lista_b and lista_c: #print (lista_b) #print (lista_c) #rt = rule.toTree() #print (rt) #print (len(P[j - 1][k - 1][b]), " * ", len(P[j + k - 1][i - k - 1][c])) for x, y in itertools.product(lista_b, lista_c): subtree1 = x[1][0] subtree2 = y[1][0] rtt = tree(root=rule.left, children=[subtree1, subtree2]) #score = numpy.dot(dtk_generator.sn(rtt), distributed_vector) score = numpy.dot(dtk_generator.dt(rtt), distributed_vector) numero_dtk = numero_dtk + 1 #P[j - 1][i - 1][a].append(((rule, ((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))), (rtt, score))) #P[j - 1][i - 1][a].append(((rule, ((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))), (rtt, score))) P[j - 1][i - 1].append( ((rule, ((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))), (rtt, score))) #P[j - 1][i - 1] = P[j - 1][i - 1][:k_best] #print (P[j - 1][k - 1][a]) #B[j - 1][i - 1][a].append(((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))) P[j - 1][i - 1] = sorted(P[j - 1][i - 1], key=lambda x: x[1][1], reverse=True)[:k_best] print(numero_dtk) #print (P[0][-1]) #for i, l in enumerate(P): # print (i, l) #find the coordinate of the cell with the final "S" fc = None lista_s = [x for x in P[0][-1] if x[0][0].left == "S"] if lista_s: return True, [t[1][0] for t in lista_s] else: return False, None
def setup_board_routes(app: Application, write_enabled: bool): # Create /api end point as root node r_api = tree("api", data=get_node_api()) # Add /api/sled to represent entire SLED r_sled = tree("sled", data=get_node_sled()) r_api.addChild(r_sled) # Add mb /api/sled/mb r_mb = tree("mb", data=get_node_server_2s(1, "mb")) r_sled.addChild(r_mb) # Add /api/sled/mb/fruid end point r_temp = tree("fruid", data=get_node_fruid("mb")) r_mb.addChild(r_temp) # /api/sled/mb/bmc end point r_temp = tree("bmc", data=get_node_bmc()) r_mb.addChild(r_temp) # /api/sled/mb/sensors end point r_temp = tree("sensors", data=get_node_sensors("mb")) r_mb.addChild(r_temp) # /api/sled/mb/logs end point r_temp = tree("logs", data=get_node_logs("mb")) r_mb.addChild(r_temp) # Add /api/sled/mezz0 to represent Network Mezzaine card r_mezz = tree("mezz0", data=get_node_mezz()) r_sled.addChild(r_mezz) # Add /api/mezz/fruid end point r_temp = tree("fruid", data=get_node_fruid("nic0")) r_mezz.addChild(r_temp) # /api/mezz/sensors end point r_temp = tree("sensors", data=get_node_sensors("nic0")) r_mezz.addChild(r_temp) # /api/mezz/logs end point r_temp = tree("logs", data=get_node_logs("nic0")) r_mezz.addChild(r_temp) # Add /api/sled/mezz1 to represent Network Mezzaine card r_mezz1 = tree("mezz1", data=get_node_mezz()) r_sled.addChild(r_mezz1) # Add /api/mezz1/fruid end point r_temp = tree("fruid", data=get_node_fruid("nic1")) r_mezz1.addChild(r_temp) # /api/mezz1/sensors end point r_temp = tree("sensors", data=get_node_sensors("nic1")) r_mezz1.addChild(r_temp) # /api/mezz1/logs end point r_temp = tree("logs", data=get_node_logs("nic1")) r_mezz1.addChild(r_temp) r_api.setup(app, write_enabled)
def parser_with_reconstruction3(sentence, grammar, k_best, distributed_vector=None, dtk_generator=None): #uso la grammatica nuova (grammar_2 ) words = sentence.split() n = len(words) r = len(grammar.symbols) P = numpy.zeros((n, n), dtype=object) for i, _ in numpy.ndenumerate(P): P[i] = [] #unit production for i, word in enumerate(words): try: rules = grammar.terminalrules[word] except KeyError: print("la parola ", word, " non appare nelle regole") if rules == []: for symbol in grammar.symbols: #print (rule, rule.toTree()) rule = grammar.rule(symbol, [word]) rt = rule.toTree() score = numpy.dot(dtk_generator.dt(rt), distributed_vector) P[i][0].append(((rule, None), (rt, score))) else: for rule in rules: #print (rule, rule.toTree()) rt = rule.toTree() score = numpy.dot(dtk_generator.dt(rt), distributed_vector) P[i][0].append(((rule, None), (rt, score))) P[i][0] = sorted(P[i][0], key=lambda x: x[1][1], reverse=True)[:k_best] #non terminal rules numero_dtk = 0 for i in range(2, n + 1): for j in range(1, n - i + 2): for k in range(1, i): #da qui devo cambiare # a = grammar.symbols[rule.left] # b = grammar.symbols[rule.right[0]] # c = grammar.symbols[rule.right[1]] # celle da analizzare, contengono una lista di regole: [ 'VP': [@S -> NP VP, VP -> MD VP] , ... ] # creo combinazioni di regole con primo simbolo dalla prima cella, secondo dalla seconda # cella_sinistra = P[j - 1][k - 1] cella_destra = P[j + k - 1][i - k - 1] stringhe = [] if cella_sinistra and cella_destra: for x, y in itertools.product(cella_sinistra, cella_destra): #print (x, y) b = x[0][0].left c = y[0][0].left stringhe.append(b + " " + c) stringhe = list(set(stringhe)) if stringhe: pass for stringa in stringhe: if rules: pass #print ("rules: ", len(grammar.nonterminalrules[stringa])) for rule in grammar.nonterminalrules[stringa]: subtree1 = cella_sinistra[0][1][0] subtree2 = cella_destra[0][1][0] rtt = tree(root=rule.left, children=[subtree1, subtree2]) #print (rtt) #score = numpy.dot(dtk_generator.sn(rtt), distributed_vector) score = numpy.dot(dtk_generator.dt(rtt), distributed_vector) numero_dtk = numero_dtk + 1 #P[j - 1][i - 1][a].append(((rule, ((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))), (rtt, score))) #P[j - 1][i - 1][a].append(((rule, ((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))), (rtt, score))) P[j - 1][i - 1].append( ((rule, ((j - 1, k - 1, None), (j + k - 1, i - k - 1, None))), (rtt, score))) #P[j - 1][i - 1] = P[j - 1][i - 1][:k_best] #print (P[j - 1][k - 1][a]) #B[j - 1][i - 1][a].append(((j - 1, k - 1, b), (j + k - 1, i - k - 1, c))) P[j - 1][i - 1] = sorted(P[j - 1][i - 1], key=lambda x: x[1][1], reverse=True)[:k_best] #print (numero_dtk) #number of iteration #print (P[0][-1]) #for i, l in enumerate(P): # print (i, l) #find the coordinate of the cell with the final "S" fc = None lista_s = [x for x in P[0][-1] if x[0][0].left == "S"] if lista_s: return True, [t[1][0] for t in lista_s], P else: return False, None
__author__ = 'Roland' from tree import tree, parseTree, ExpressionError from tokenizer import token, Tokenizer pT = parseTree() tok = Tokenizer() assert (pT.buildParseTree(tok.tokenize("1+2")) == tree('+', '1', '2')) assert (pT.buildParseTree(tok.tokenize("(x+(y*z+2))-3*((5+x)/2-4)")) == tree( '-', tree('+', 'x', tree('+', tree('*', 'y', 'z'), '2')), tree('*', '3', tree('-', tree('/', tree('+', '5', 'x'), '2'), '4')))) assert (pT.buildParseTree(tok.tokenize("sin(x)+ln(y)*3")) == tree( '+', tree('sin', 'x'), tree('*', tree('ln', 'y'), '3'))) assert (pT.buildParseTree(tok.tokenize('x^y*2-3')) == tree( '-', tree('*', tree('^', 'x', 'y'), '2'), '3')) assert (pT.buildParseTree(tok.tokenize('x=y=5*3-20*sin(x+y)')) == tree( '=', 'x', tree( '=', 'y', tree('-', tree('*', '5', '3'), tree('*', '20', tree('sin', tree('+', 'x', 'y'))))))) try: # teste pentru erori Tree = pT.buildParseTree(tok.tokenize('x***y')) assert (False) except ExpressionError: assert (True) try: Tree = pT.buildParseTree(tok.tokenize('x===y')) assert (False) except ExpressionError: assert (True) try:
def coeffs(params, output=None, order=1): ''' Returns the results the turbulence code. Automatically selects the integration dimension based on the number of supplied parameters. Accepts as input an optional argument 'output'. If this is None then all quantities are computed and output. Otherwise it must be an array of integers of shape (6,6) with 1's in the positions where outputs are desired and 0's otherwise. ''' if output is None: if len(params) == 9: params = [params[4]] + list(params) r = coeffs2spherical(*params, order=order) elif len(params) == 10: params = list(params) r = coeffs2spherical(*params, order=order) elif len(params) == 12: params = [params[7]] + list(params) r = coeffs3spherical(*params, order=order) elif len(params) == 13: params = list(params) r = coeffs3spherical(*params, order=order) else: raise NotImplementedError( 'Number of parameters does not match any known specification.') else: output2 = [0 for _ in range(36)] for i in range(6): for j in range(6): if output[i, j]: output2[6 * i + j] = 1 if len(params) == 10: params2 = [output2, params[4]] + list(params) mins = [0., 0.] maxs = [np.pi, 2 * np.pi] co = lambda x: coeffs2sphericalSpecificBox(*x, order=order) elif len(params) == 11: params2 = [output2] + list(params) mins = [0., 0.] maxs = [np.pi, 2 * np.pi] co = lambda x: coeffs2sphericalSpecificBox(*x, order=order) elif len(params) == 13: params2 = [output2, params[7]] + list(params) mins = [0., 0., 0.] maxs = [1., np.pi, 2 * np.pi] co = lambda x: coeffs3sphericalSpecificBox(*x, order=order) elif len(params) == 14: params2 = [output2] + list(params) mins = [0., 0., 0.] maxs = [1., np.pi, 2 * np.pi] co = lambda x: coeffs3sphericalSpecificBox(*x, order=order) else: raise NotImplementedError( 'Number of parameters does not match any known specification.') def f(x): c = None if len(params) == 10 or len(params) == 11: c = correlator(1., x[0], x[1], 0, 0, 0, params[0], params[1], params[2], params[3], params[4], params[5], params[6], order=order) elif len(params) == 13 or len(params) == 14: c = correlator(x[0], x[1], x[2], params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9], order=order) else: raise NotImplementedError( 'Number of parameters does not match any known specification.' ) if np.sum(np.abs(c[2:, 2:])) > 1e-13: return np.sum(np.abs(c[2:, 2:])) else: return 0 t = tree(mins, maxs, f) t.allSplit(1000) r = np.zeros((6, 6, 2)) # For determining the number of evals est = sum([c.mean * c.volume for c in t.nonzero]) vol = sum([c.volume for c in t.nonzero]) print(vol / (2 * np.pi * np.pi)) if vol / (2 * np.pi * np.pi) > 0.1: params3 = [mins, maxs] + params2 r = co(params3) else: for c in t.nonzero: params3 = [c.mins, c.maxs] + params2 params3[-2] = 10 + int(params3[-2] * c.mean * c.volume / est) res = co(params3) r += res return r
def init_plat_tree(): # Create /api end point as root node r_api = tree("api", data=get_node_api()) # Add /api/sled to represent entire SLED r_sled = tree("sled", data=get_node_sled()) r_api.addChild(r_sled) # Add mb /api/sled/mb r_mb = tree("mb", data=get_node_server_2s(1, "mb")) r_sled.addChild(r_mb) # Add /api/sled/mb/fruid end point r_temp = tree("fruid", data=get_node_fruid("mb")) r_mb.addChild(r_temp) # /api/sled/mb/bmc end point r_temp = tree("bmc", data=get_node_bmc()) r_mb.addChild(r_temp) # /api/sled/mb/sensors end point r_temp = tree("sensors", data=get_node_sensors("mb")) r_mb.addChild(r_temp) # /api/sled/mb/logs end point r_temp = tree("logs", data=get_node_logs("mb")) r_mb.addChild(r_temp) # Add /api/sled/mezz to represent Network Mezzaine card r_mezz = tree("mezz", data=get_node_mezz()) r_sled.addChild(r_mezz) # Add /api/mezz/fruid end point r_temp = tree("fruid", data=get_node_fruid("nic")) r_mezz.addChild(r_temp) # /api/mezz/sensors end point r_temp = tree("sensors", data=get_node_sensors("nic")) r_mezz.addChild(r_temp) # /api/mezz/logs end point r_temp = tree("logs", data=get_node_logs("nic")) r_mezz.addChild(r_temp) return r_api
def toUnrootedTree(self): ''' Return the tree object of the unrooted version of this topology. ''' return tree.tree(self.toUnrootedNewick())