## write json file data_line = "{" + nodes + "," + links + "}" output_file = open("data.json", "w") output_file.write(data_line) output_file.close() ##------------## ## TEST SPACE ## ##------------## grid = network.Network("test", 3) node_list = [] a = node.Node("tardis", 5) b = node.Node("picvert", 4) c = node.Node("choucroute", 6) d = node.Node("falcon", 1) e = node.Node("machine", 2) f = node.Node("cheesecake", 9) node_list.append(a) node_list.append(b) node_list.append(c) node_list.append(d) node_list.append(e) node_list.append(f) truc = generate_random_nodes(20) machin = order_nodes(truc, 4)
def _readNodes(self): self.nodelist = {} config = ConfigParser.SafeConfigParser() if not config.read(self.nodecfg): util.error("cannot read '%s'" % self.nodecfg) manager = False proxy = False worker = False standalone = False file = self.nodecfg counts = {} for sec in config.sections(): node = node_mod.Node(sec) self.nodelist[sec] = node for (key, val) in config.items(sec): key = key.replace(".", "_") if not key in node_mod.Node._keys: util.warn("%s: unknown key '%s' in section '%s'" % (file, key, sec)) continue if key == "type": if val == "manager": if manager: util.error("only one manager can be defined") manager = True elif val == "proxy": proxy = True elif val == "worker": worker = True elif val == "standalone": standalone = True else: util.error("%s: unknown type '%s' in section '%s'" % (file, val, sec)) node.__dict__[key] = val try: addrinfo = socket.getaddrinfo(node.host, None, 0, 0, socket.SOL_TCP) if len(addrinfo) == 0: util.error( "%s: no addresses resolved in section '%s' for host %s" % (file, sec, node.host)) addr_str = addrinfo[0][4][0] # zone_id is handled manually, so strip it if it's there node.addr = addr_str.split('%')[0] except AttributeError: util.error("%s: no host given in section '%s'" % (file, sec)) except socket.gaierror, e: util.error("%s: unknown host '%s' in section '%s' [%s]" % (file, node.host, sec, e.args[1])) # Each node gets a number unique across its type. type = self.nodelist[sec].type try: counts[type] += 1 except KeyError: counts[type] = 1 node.count = counts[type] if node.lb_procs: try: numprocs = int(node.lb_procs) if numprocs < 1: util.error( "%s: value of lb_procs must be at least 1 in section '%s'" % (file, sec)) except ValueError: util.error( "%s: value of lb_procs must be an integer in section '%s'" % (file, sec)) if not node.lb_method: util.error( "%s: no load balancing method given in section '%s'" % (file, sec)) if node.lb_method not in ("pf_ring", "myricom", "interfaces"): util.error( "%s: unknown load balancing method given in section '%s'" % (file, sec)) if node.lb_method == "interfaces": if not node.lb_interfaces: util.error( "%s: no list of interfaces given in section '%s'" % (file, sec)) # get list of interfaces to use, and assign one to each node netifs = node.lb_interfaces.split(",") if len(netifs) != int(node.lb_procs): util.error( "%s: number of interfaces does not match value of lb_procs in section '%s'" % (file, sec)) node.interface = netifs.pop().strip() # node names will have a numerical suffix node.name = "%s-1" % sec for num in xrange(2, int(node.lb_procs) + 1): newnode = copy.deepcopy(node) # only the node name and count need to be changed newname = "%s-%d" % (sec, num) newnode.name = newname self.nodelist[newname] = newnode counts[type] += 1 newnode.count = counts[type] if newnode.lb_method == "interfaces": newnode.interface = netifs.pop().strip()
def __init__(self): self.head = node.Node() self.length = 0
def rrt(start_coords, goal_coords, radius, clearance): x_start, y_start = start_coords x_goal, y_goal = goal_coords start_node = node.Node(current_coords=start_coords, parent_coords=None, distance=None) goal_node = node.Node(current_coords=goal_coords, parent_coords=None, distance=None) print(start_node.printNode()) print(goal_node.printNode()) tree = [] path = [] # tree.append(start_node) tree.append([0, start_node.current_coords, (0, 0)]) N = 0 while (N < MAX_ITER): print("N:", N) x_random = (np.random.uniform(X_LIM[0], X_LIM[1]), np.random.uniform(Y_LIM[0], Y_LIM[1])) # print("x_random", x_random) ########################################## #put a check if x_random is repeated ########################################## # print("<<<<<<<<<<<<Before updating the distance<<<<") # print("tree", tree) # print("<<<<<<<<<<<<After updating the distance<<<<<") for i in tree: # while True: distance = utils.euclideanDistance(point_1=i[1], point_2=x_random) i[0] = distance # print("tree", i) heapq.heapify(tree) # Finding the node in the tree which is the nearest to the x_random min_node = heapq.heappop(tree) # print("len(tree)", len(tree)) heapq.heappush(tree, [min_node[0], min_node[1], min_node[2]]) # sys.exit(0) # print("min node", min_node) # print("next_node", next_node) # print("distance", distance) # path.append(add_node) # tree.append([min_node[0], x_random, min_node[1]]) # print("<<<<<<<<<<<After apending the latest x random<<<<<") # print("tree", tree) # if the random node is within the step size if min_node[0] <= STEP_SIZE: # create a node with this value and add it to the path obstacle_status = obstacles.withinObstacleSpace( point=min_node[1], radius=radius, clearance=clearance) if (obstacle_status == False): add_node = node.Node(current_coords=x_random, parent_coords=min_node[1], distance=min_node[0]) path.append(add_node) # print("<<<<<<<<<<<<<_before<<<<<<<<<,") # print("len(tree)", len(tree)) heapq.heappush(tree, [ add_node.distance, add_node.current_coords, add_node.parent_coords ]) # print("<<<<<<<<<<<<after<<<<<<<<<<,") # print("len(tree)", len(tree)) # tree.append([add_node.distance, add_node.current_coords, add_node.parent_coords]) else: # Find an intermediate point in between a and b x1, y1 = min_node[1] x2, y2 = x_random slope = (y2 - y1) / (x2 - x1) theta = math.atan(slope) x_near = (x1 + (STEP_SIZE * math.cos(theta)), y1 + (STEP_SIZE * math.sin(theta))) obstacle_status = obstacles.withinObstacleSpace( point=min_node[1], radius=radius, clearance=clearance) if (obstacle_status == False): add_node = node.Node(current_coords=x_near, parent_coords=min_node[1], distance=STEP_SIZE) # print("<<<<<<<<<<<<<_before<<<<<<<<<,") # print("len(tree)", len(tree)) path.append(add_node) heapq.heappush(tree, [ add_node.distance, add_node.current_coords, add_node.parent_coords ]) # print("<<<<<<<<<<<<<_before<<<<<<<<<,") # print("len(tree)", len(tree)) # tree.append([add_node.distance, add_node.current_coords, add_node.parent_coords]) goal_status = utils.goal_reached( current_node=add_node, goal_node=goal_node, goal_reach_threshold=GOAL_REACH_THRESH) if (goal_status): print("Reached Goal!") return path, goal_node # break N += 1 # print("-------------------") # print(path) return path, goal_node
c.configPath = args.c or "/etc/fail2ban-p2p" c.privkey = os.path.join(c.configPath, 'private.pem') c.pubkey = os.path.join(c.configPath, 'public.pem') if c.loadConfig() == False: raise OSError #, 'Config error, check log.' logger = log.initialize_logging("fail2ban-p2p") if args.K: crypto.create_keys() exit() # make sure the keys exist if not os.path.isfile(c.privkey) or not os.path.isfile(c.pubkey): logger.warning('Private or public key not found, creating them') crypto.create_keys() n = None try: n = node.Node() n.loadConfig() n.getFriends() n.requestBanlist() n.cleanBanlist() n.openSocket() except (KeyboardInterrupt): logger.info("Keyboard Interrupt received, going down") n.cleanBanlistStop() n.closeSocket() logger.info("kthxbai!")
def solve8PuzzleProblem(input_data_matrix): input_data = node.Node(data_matrix=input_data_matrix, current_idx=0, parent_idx=-1) if not input_data.isSolvable(): print( "Sorry but this configuration is not solvable! Try some other configuration." ) sys.exit(0) is_visited = [] Q = [] Q.append(input_data) Q_idx = 0 curr_idx = 1 while (Q_idx < len(Q)): is_visited.append(input_data) if Q[Q_idx].reachedGoalState(): utils.printSolutionPath(Q, Q_idx) utils.writeNodeIdxInformation(node_list=Q, node_info_filename="./NodesInfo.txt") utils.writeNodeStates(node_list=Q, node_state_filename="./Nodes.txt") return (utils.getSolutionPath(Q, Q_idx)) new_state = actions.actionMoveLeft(Q[Q_idx]) if (new_state is not None) and (new_state not in is_visited): new_state.current_idx = curr_idx curr_idx += 1 new_state.parent_idx = Q_idx Q.append(new_state) new_state = actions.actionMoveRight(Q[Q_idx]) if (new_state is not None) and (new_state not in is_visited): new_state.current_idx = curr_idx curr_idx += 1 new_state.parent_idx = Q_idx Q.append(new_state) new_state = actions.actionMoveUp(Q[Q_idx]) if (new_state is not None) and (new_state not in is_visited): new_state.current_idx = curr_idx curr_idx += 1 new_state.parent_idx = Q_idx Q.append(new_state) new_state = actions.actionMoveDown(Q[Q_idx]) if (new_state is not None) and (new_state not in is_visited): new_state.current_idx = curr_idx curr_idx += 1 new_state.parent_idx = Q_idx Q.append(new_state) Q_idx += 1 print( "I am really sorry but I could not find a solution. This is weird because as per my logic the solution exists." ) return None
_STRUCTURE = 0 # 0 -> black # 1 -> white # 2 -> blue # 3 -> green # 4 -> red _COLOR = WHITE ############################################### ## ## Geometric Types - INIT ##################################################### #Nodes Example nodeA_ForLine = node.Node(5, 5) nodeB_ForLine = node.Node(10, 10) #Dots Example _nodes = list() #Lines example _lines = list() #Circle Example _circles = list() #Polygon Example _polygons = list() #Polyline Example
import sys import tree_reader2 import tree_utils import node if __name__ == "__main__": if len(sys.argv) != 3: print "python " + sys.argv[0] + " infile.trees outfile.tre" sys.exit(0) trees = [] maintree = node.Node() for i in tree_reader2.read_tree_file_iter(sys.argv[1]): trees.append(i) lvsnms = set() for i in trees: for l in i.lvsnms(): lvsnms.add(l) for i in lvsnms: nd = node.Node() nd.label = i maintree.add_child(nd) for i in trees: mr = tree_utils.get_mrca_wnms(i.lvsnms(), maintree) mvnds = set() for j in mr.children: if len(set(j.lvsnms()).intersection(set(i.lvsnms()))) > 0: mvnds.add(j)
x_lon = np.zeros((len(shape.points), 1)) y_lat = np.zeros((len(shape.points), 1)) for ip in range(len(shape.points)): x_lon[ip] = shape.points[ip][0] y_lat[ip] = shape.points[ip][1] x_min = x_lon.min() x_max = x_lon.max() y_min = y_lat.min() y_max = y_lat.max() bitmap = [] row = [] x_range = np.arange(x_min, x_max, 0.0001) y_range = np.arange(y_min, y_max, 0.0001) for i in range(0, len(x_range)): row.clear() for j in range(0, len(y_range)): point = None if polygon.contains(Point(x_range[i], y_range[j])): plt.scatter(x_range[i], y_range[j], s=.5, c='b') point = node.Node(x_range[i], y_range[j], True) else: plt.scatter(x_range[i], y_range[j], s=.5, c='r') point = node.Node(x_range[i], y_range[j], False) row.append(point) bitmap.append(row) plt.show() data = np.array(bitmap) print(data.shape)
# @app.route('/forceminetrigger', methods = ['GET']) # def force_mine(): # force_result = _node.force_mine() # if force_result == 0: # return jsonify(status="did something") # else: # return jsonify(status="all work done") @app.route('/chain', methods=['GET']) def chain_send(): chain = _node.chain return jsonify(chain=chain) if __name__ == '__main__': from argparse import ArgumentParser parser = ArgumentParser() parser.add_argument('-p', default=5000, help='port to listen on') parser.add_argument('-diff', default=4, help='set difficulty of POW') parser.add_argument('-ip', help='ip to listen on') parser.add_argument('-bip', help='bootstrap ip, -1 if bootstrap') parser.add_argument('-bport', help='bootstrap port, -1 if bootstrap') args = parser.parse_args() config.difficulty = int(args.diff) port = args.p _node = node.Node(args.ip, args.p, args.bip, args.bport) app.run(host='0.0.0.0', port=port, threaded=True)
def __init__(self, num_i_elem, num_j_elem, p, mesh_properties): """Constructor for the Quadrilateral Mesh Will generate a quadrilateral mesh (rectangular) of certain order elements. The mesh will initially be "structured" however it will be stored in memory as an unstructured mesh. Then, we will work with the unstructured mesh to do all solving and adaptation. Args: num_i_elem (int): Number of elements to initialize along the i direction num_j_elem (int): Number of elements to initialize along the j direction p (int): The order of the basis functions mesh_properties (dict): Dictionary holding the following parameters "x_range": List with the lower and upper x limits of the mesh (for rectangular case) "y_range": List with the lower and upper y limits of the mesh (for rectangular case) "dirichlet_bc_flag": The function for setting the dirichlet bc """ # =========================== # Setup # =========================== # x and y limits of the rectangular mesh self.x_range = mesh_properties.get("x_range") self.y_range = mesh_properties.get("y_range") # Order of the mesh self.p = p # Generate the initial mesh by creating equal dimension elements on a # num_i_elem x num_j_elem grid. # Spacing of the elements dx_elem, dy_elem = float(self.x_range[1] - self.x_range[0])/num_i_elem, \ float(self.y_range[1] - self.y_range[0])/num_j_elem # =========================== # Vertices Generation # =========================== # Generate the grid of vertex points vertex_points_grid = [] for i in range(num_i_elem + 1): col = [] for j in range(num_j_elem + 1): x_pt, y_pt = i * dx_elem, j * dy_elem vertex_pt = vertex.Vertex(x_pt, y_pt) col.append(vertex_pt) vertex_points_grid.append(col) # =========================== # Element/DOF Generation # =========================== # As we are initially creating a structured mesh, exploit this fact # to be able to quickly determine the connectivity between the elements element_matrix = [] for i in range(num_i_elem): col = [] for j in range(num_j_elem): # Get the range of the element on the physical domain elem_x_range = [ i * dx_elem + self.x_range[0], (i + 1) * dx_elem + self.x_range[0] ] elem_y_range = [ j * dy_elem + self.y_range[0], (j + 1) * dy_elem + self.y_range[0] ] # The matrix of points for the vertices for this element vertex_pt_matrix = [[None, None], [None, None]] for i_vertex in range(2): for j_vertex in range(2): vertex_pt_matrix[i_vertex][ j_vertex] = vertex_points_grid[i + i_vertex][j + j_vertex] # Create the element with these vertices col.append( quad_finite_element.QuadFiniteElement( self.p, elem_x_range, elem_y_range, vertex_pt_matrix, 0)) element_matrix.append(col) # Set the neigbors of the elements for i in range(num_i_elem): for j in range(num_j_elem): elem_ij = element_matrix[i][j] if i == 0: elem_ij.set_neighbor([element_matrix[i + 1][j]], 1, [3]) elif i == num_i_elem - 1: elem_ij.set_neighbor([element_matrix[i - 1][j]], 3, [1]) else: elem_ij.set_neighbor([element_matrix[i + 1][j]], 1, [3]) elem_ij.set_neighbor([element_matrix[i - 1][j]], 3, [1]) if j == 0: elem_ij.set_neighbor([element_matrix[i][j + 1]], 2, [0]) elif j == num_j_elem - 1: elem_ij.set_neighbor([element_matrix[i][j - 1]], 0, [2]) else: elem_ij.set_neighbor([element_matrix[i][j + 1]], 2, [0]) elem_ij.set_neighbor([element_matrix[i][j - 1]], 0, [2]) # Now, with all the neighbors set, we place all the elements in a list self.element_list = [] for i in range(num_i_elem): for j in range(num_j_elem): self.element_list.append(element_matrix[i][j]) # Set the dofs for the elements. Exploit the structured data for now to # create the shared dofs node_points_grid = [] for i in range(num_i_elem + 1): col = [] for j in range(num_j_elem + 1): x_pt, y_pt = i * dx_elem, j * dy_elem node_pt = node.Node("dof", x_pt, y_pt) col.append(node_pt) node_points_grid.append(col) for i in range(num_i_elem): for j in range(num_j_elem): elem_ij = element_matrix[i][j] i_dof_min = i j_dof_min = j for i_node_elem in range(2): for j_node_elem in range(2): elem_ij.node_matrix[i_node_elem][j_node_elem] = \ node_points_grid[i_dof_min + i_node_elem][j_dof_min + j_node_elem] self.set_node_to_element_connectivity() # Summary: # - At this point in the mesh generation, we now have a list of # elements. This list makes it such that we can effectively handle # an unstructured mesh of elements. # - All nodes have been generated # =========================== # Dirichlet BC Setup # =========================== # Set the Dirichlet BC on the mesh and its nodes self.dirichlet_bc_flag_function = mesh_properties["dirichlet_bc_flag"] self.set_dirichlet_boundary_condition() # =========================== # Global DOF List # =========================== # Set the list of dofs for this mesh. This will be used for the system solve self.dof_list = [] self.set_dof_list() self.dirichlet_bc_list = [] self.set_dirichlet_bc_list() # Set the list of hanging nodes for this mesh. Will be needed during h-refinement self.hanging_node_list = [] self.set_hanging_node_list()
def create_server_node(server_node_ip_enum): return node.Node(server_node_ip_enum)
def criarServidor(): self.master.intr.no = node.Node("", int(self.porta.get())) self.master.intr.no.servidor(self.master.intr)
def a_star(self, heuristic): start_node = node.Node(self.position[0], self.position[1], None, heuristic, "START", g=1, direction='north') # creates start node options_per_node = ["FORWARD", "LEFT", "RIGHT", "BASHING"] # choices per node VISITED = list() OPEN = list() OPEN.append(start_node) while len(OPEN) > 0: # print(len(OPEN)) curr = min(OPEN, key=lambda x: x.f) # get lowest f-score # print(f"{curr} : {curr.parent}") if self.board.get_cost( curr.row, curr.col ) == -1: # check if goal reached. if reached print path len_of_path = -1 # print("GOAL REACHED\n\n\n") goal_info = self._get_path(curr) path = goal_info[0] actions = goal_info[1] nodes_expanded = 0 score = 0 for step in path[::-1]: len_of_path += 1 nodes_expanded = len(VISITED) score = 100 - (curr.f + 1) # print(step) return score, len_of_path, nodes_expanded, actions OPEN.remove(curr) VISITED.append(curr) for option in options_per_node: # print(f"{option} from {curr.row}, {curr.col}") if option == "FORWARD": forward = self._move(curr_pos=[curr.row, curr.col], curr_dir=curr.direction) new_pos = forward[0] cost_of_move = forward[1] if cost_of_move == 0: continue new_heuristic = self.calc_heuristic(heuristic, new_pos) curr.add_edge( node.Node(new_pos[0], new_pos[1], curr, new_heuristic, "FORWARD", g=curr.g + cost_of_move, direction=curr.direction)) continue elif option == "LEFT": if curr.how_we_got_here == "BASH" or curr.how_we_got_here == "RIGHT": continue left = self._turn([curr.row, curr.col], "LEFT", curr.direction) if left: new_pos = left[0] cost_of_move = left[1] new_heuristic = self.calc_heuristic(heuristic, new_pos) curr.add_edge( node.Node(new_pos[0], new_pos[1], curr, new_heuristic, "LEFT", g=curr.g + cost_of_move, direction=left[2])) continue elif option == "RIGHT": if curr.how_we_got_here == "BASH" or curr.how_we_got_here == "LEFT": continue right = self._turn([curr.row, curr.col], "RIGHT", curr.direction) if right: new_pos = right[0] cost_of_move = right[1] new_heuristic = self.calc_heuristic(heuristic, new_pos) curr.add_edge( node.Node(new_pos[0], new_pos[1], curr, new_heuristic, "RIGHT", g=curr.g + cost_of_move, direction=right[2])) continue elif option == "BASHING": if curr.how_we_got_here == "BASH": continue bash = self._bash(curr_pos=[curr.row, curr.col], curr_dir=curr.direction) new_pos = bash[0] cost_of_move = bash[1] if cost_of_move == 0: continue new_heuristic = self.calc_heuristic(heuristic, new_pos) curr.add_edge( node.Node(new_pos[0], new_pos[1], curr, new_heuristic, "BASH", g=curr.g + cost_of_move, direction=curr.direction)) continue for e in curr.edges: if (e not in VISITED and e not in OPEN) or e.f > curr.f: OPEN.append(e)
def GenerateNode(filepath, nodeID = 0): # Create a new node Node = node.Node(id = nodeID) try: # Parse file and extract dictionary of EDS entry eds_dict = ParseEDSFile(filepath) # Extract Profile Number from Device Type entry ProfileNb = eds_dict[0x1000].get("DEFAULTVALUE", 0) & 0x0000ffff # If profile is not DS-301 or DS-302 if ProfileNb not in [0, 301, 302]: # Compile Profile name and path to .prf file ProfileName = "DS-%d"%ProfileNb ProfilePath = os.path.join(os.path.split(__file__)[0], "config/%s.prf"%ProfileName) # Verify that profile is available if os.path.isfile(ProfilePath): try: # Load Profile execfile(ProfilePath) Node.SetProfileName(ProfileName) Node.SetProfile(Mapping) Node.SetSpecificMenu(AddMenuEntries) except: pass # Read all entries in the EDS dictionary for entry, values in eds_dict.iteritems(): # All sections with a name in keynames are escaped if entry in SECTION_KEYNAMES: pass else: # Extract informations for the entry entry_infos = Node.GetEntryInfos(entry) # If no informations are available, then we write them if not entry_infos: # First case, entry is a DOMAIN or VAR if values["OBJECTTYPE"] in [2, 7]: if values["OBJECTTYPE"] == 2: values["DATATYPE"] = values.get("DATATYPE", 0xF) if values["DATATYPE"] != 0xF: raise SyntaxError, _("Domain entry 0x%4.4X DataType must be 0xF(DOMAIN) if defined")%entry # Add mapping for entry Node.AddMappingEntry(entry, name = values["PARAMETERNAME"], struct = 1) # Add mapping for first subindex Node.AddMappingEntry(entry, 0, values = {"name" : values["PARAMETERNAME"], "type" : values["DATATYPE"], "access" : ACCESS_TRANSLATE[values["ACCESSTYPE"].upper()], "pdo" : values.get("PDOMAPPING", 0) == 1}) # Second case, entry is an ARRAY or RECORD elif values["OBJECTTYPE"] in [8, 9]: # Extract maximum subindex number defined max_subindex = max(values["subindexes"].keys()) # Add mapping for entry Node.AddMappingEntry(entry, name = values["PARAMETERNAME"], struct = 3) # Add mapping for first subindex Node.AddMappingEntry(entry, 0, values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False}) # Add mapping for other subindexes for subindex in xrange(1, int(max_subindex) + 1): # if subindex is defined if subindex in values["subindexes"]: Node.AddMappingEntry(entry, subindex, values = {"name" : values["subindexes"][subindex]["PARAMETERNAME"], "type" : values["subindexes"][subindex]["DATATYPE"], "access" : ACCESS_TRANSLATE[values["subindexes"][subindex]["ACCESSTYPE"].upper()], "pdo" : values["subindexes"][subindex].get("PDOMAPPING", 0) == 1}) # if not, we add a mapping for compatibility else: Node.AddMappingEntry(entry, subindex, values = {"name" : "Compatibility Entry", "type" : 0x05, "access" : "rw", "pdo" : False}) ## # Third case, entry is an RECORD ## elif values["OBJECTTYPE"] == 9: ## # Verify that the first subindex is defined ## if 0 not in values["subindexes"]: ## raise SyntaxError, "Error on entry 0x%4.4X:\nSubindex 0 must be defined for a RECORD entry"%entry ## # Add mapping for entry ## Node.AddMappingEntry(entry, name = values["PARAMETERNAME"], struct = 7) ## # Add mapping for first subindex ## Node.AddMappingEntry(entry, 0, values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False}) ## # Verify that second subindex is defined ## if 1 in values["subindexes"]: ## Node.AddMappingEntry(entry, 1, values = {"name" : values["PARAMETERNAME"] + " %d[(sub)]", ## "type" : values["subindexes"][1]["DATATYPE"], ## "access" : ACCESS_TRANSLATE[values["subindexes"][1]["ACCESSTYPE"].upper()], ## "pdo" : values["subindexes"][1].get("PDOMAPPING", 0) == 1, ## "nbmax" : 0xFE}) ## else: ## raise SyntaxError, "Error on entry 0x%4.4X:\nA RECORD entry must have at least 2 subindexes"%entry # Define entry for the new node # First case, entry is a DOMAIN or VAR if values["OBJECTTYPE"] in [2, 7]: # Take default value if it is defined if "PARAMETERVALUE" in values: value = values["PARAMETERVALUE"] elif "DEFAULTVALUE" in values: value = values["DEFAULTVALUE"] # Find default value for value type of the entry else: value = GetDefaultValue(Node, entry) Node.AddEntry(entry, 0, value) # Second case, entry is an ARRAY or a RECORD elif values["OBJECTTYPE"] in [8, 9]: # Verify that "Subnumber" attribute is defined and has a valid value if "SUBNUMBER" in values and values["SUBNUMBER"] > 0: # Extract maximum subindex number defined max_subindex = max(values["subindexes"].keys()) Node.AddEntry(entry, value = []) # Define value for all subindexes except the first for subindex in xrange(1, int(max_subindex) + 1): # Take default value if it is defined and entry is defined if subindex in values["subindexes"] and "PARAMETERVALUE" in values["subindexes"][subindex]: value = values["subindexes"][subindex]["PARAMETERVALUE"] elif subindex in values["subindexes"] and "DEFAULTVALUE" in values["subindexes"][subindex]: value = values["subindexes"][subindex]["DEFAULTVALUE"] # Find default value for value type of the subindex else: value = GetDefaultValue(Node, entry, subindex) Node.AddEntry(entry, subindex, value) else: raise SyntaxError, _("Array or Record entry 0x%4.4X must have a \"SubNumber\" attribute")%entry return Node except SyntaxError, message: return _("Unable to import EDS file\n%s")%message
def get_node(self,name): if name not in self.nodes: self.nodes[name] = node.Node(name) return self.nodes[name]
def sew_it2(ML_val, branches, bip_hash, test, gene_count_hash): maintree = node.Node() names = [] #get the names names = tree_stuff.get_tips(bip_hash.itervalues().next()) lvs = set(names) trees = [] trees_r = [] temp = [] temp_r = [] #put trees into an array for i in branches: if test == "2_con" or test == "2_con_gene" or test == "con_b": nd = node.Node() nd = tree_stuff.build(bip_hash[i]) temp, temp_r = get_left(nd, lvs) else: nd = node.Node() nd = tree_stuff.build(bip_hash[branches[i]]) temp, temp_r = get_left(nd, lvs) if test == "tree_dist": diffval = ML_val - float(i) elif test == "constraint_label": diffval = branches[i] elif test == "2_con" or test == "2_con_gene" or test == "con_b": diffval = branches[i] elif test == "blank": diffval = "" elif test == "conflict": diffval = gene_count_hash[branches[i]] temp = "(" + ",".join(temp) + ")" + str(diffval) + ";" temp_r = "(" + ",".join(temp_r) + ")" + str(diffval) + ";" x = tree_stuff.build(temp) trees.append(x) x = tree_stuff.build(temp_r) trees_r.append(x) #print trees #print trees_r #get the tip names as an tree structures lvsnms = set() for i in trees: #print i for l in i.lvsnms(): lvsnms.add(l) for i in trees_r: for l in i.lvsnms(): lvsnms.add(l) #Create a star tree with all tips being tree structures for i in lvsnms: nd = node.Node() nd.label = i maintree.add_child(nd) for i in range(0, len(trees)): ilvs = trees[i].lvsnms() bp1 = tree_stuff.get_mrca_wnms(trees[i].lvsnms(), maintree) bp2 = tree_stuff.get_mrca_wnms(trees_r[i].lvsnms(), maintree) if bp1 == maintree and bp2 != maintree: bp = bp2 ilvs = trees_r[i].lvsnms() #bp.label = trees_r[i].label else: bp = bp1 #bp.label = trees[i].label mvnds = set() for j in bp.children: if len(set(j.lvsnms()).intersection(set(ilvs))) > 0: mvnds.add(j) nd = node.Node() lab = trees_r[i].label for j in mvnds: #print "Here is j:" + str(j) bp.remove_child(j) nd.add_child(j) if nd.label == "": nd.label = lab bp.add_child(nd) print maintree.get_newick_repr(False) + ";"
import node print(node.Node('../samples/Physics.cfg').variables) print() print(node.Node('../samples/mvp.craft').variables)
def test_basics(self): empty_b = Bucket(MAX_RNODES) # Get empty superbucket log_distance = self.my_node.log_distance(tc.SERVER_NODE) sbucket = self.rt.get_sbucket(log_distance) m_bucket = sbucket.main r_bucket = sbucket.replacement eq_(m_bucket, empty_b) eq_(r_bucket, empty_b) ok_(r_bucket.there_is_room()) eq_(m_bucket.get_rnode(tc.SERVER_NODE), None) ok_(m_bucket.there_is_room(MAX_RNODES)) ok_(not m_bucket.there_is_room(MAX_RNODES + 1)) eq_(self.rt.num_rnodes, 0) # empty eq_(self.rt.get_main_rnodes(), []) # Add server_node to main bucket m_bucket.add(tc.SERVER_NODE) self.rt.update_lowest_index(log_distance) self.rt.num_rnodes += 1 ok_(m_bucket.there_is_room()) ok_(not m_bucket.there_is_room(MAX_RNODES)) eq_(m_bucket.rnodes, [tc.SERVER_NODE]) eq_(m_bucket.get_rnode(tc.SERVER_NODE), tc.SERVER_NODE) # Check updated table eq_(self.rt.num_rnodes, 1) eq_(self.rt.get_main_rnodes(), [tc.SERVER_NODE]) sbucket = self.rt.get_sbucket(log_distance) m_bucket = sbucket.main r_bucket = sbucket.replacement # Let's add a node to the same bucket new_node = node.Node(tc.SERVER_NODE.addr, tc.SERVER_NODE.id.generate_close_id(1)) m_bucket.add(new_node) self.rt.update_lowest_index(log_distance) self.rt.num_rnodes += 1 # full bucket ok_(not m_bucket.there_is_room()) eq_(m_bucket.rnodes, [tc.SERVER_NODE, new_node]) eq_(m_bucket.get_rnode(new_node), new_node) # Trying to add to the bucket will raise exception assert_raises(AssertionError, sbucket.main.add, tc.NODES[0]) eq_(self.rt.num_rnodes, 2) eq_(self.rt.get_main_rnodes(), [tc.SERVER_NODE, new_node]) ld_to_server = tc.SERVER_ID.log_distance(tc.CLIENT_ID) eq_(self.rt.get_closest_rnodes(ld_to_server, 1, True), [tc.SERVER_NODE]) eq_(self.rt.get_closest_rnodes(ld_to_server, 8, False), [tc.SERVER_NODE, new_node, tc.CLIENT_NODE]) eq_(self.rt.get_closest_rnodes(ld_to_server, 8, False), [tc.SERVER_NODE, new_node, tc.CLIENT_NODE]) eq_(self.rt.get_closest_rnodes(ld_to_server, 8, True), [tc.SERVER_NODE, new_node]) sbucket = self.rt.get_sbucket(log_distance) m_bucket = sbucket.main m_bucket.remove(new_node) self.rt.update_lowest_index(log_distance) print '>>>' print self.rt.get_main_rnodes() print '>>>' self.rt.num_rnodes -= 1 # there is one slot in the bucket ok_(m_bucket.there_is_room()) ok_(m_bucket.get_rnode(new_node) is None) eq_(m_bucket.rnodes, [tc.SERVER_NODE]) eq_(m_bucket.get_rnode(tc.SERVER_NODE), tc.SERVER_NODE) eq_(self.rt.num_rnodes, 1) eq_(self.rt.get_main_rnodes(), [tc.SERVER_NODE]) eq_(self.rt.get_closest_rnodes(ld_to_server, 8, True), [tc.SERVER_NODE])
def a_star(start_rc, goal_rc, orientation, rpm1=10, rpm2=20, clearance=0.2, viz_please=False): """ A-star algorithm given the start and the goal nodes. :param start_rc: The start position :type start_rc: tuple :param goal_rc: The goal position :type goal_rc: tuple :param orientation: The orientation :type orientation: number :param rpm1: The rpm 1 :type rpm1: number :param rpm2: The rpm 2 :type rpm2: number :param clearance: The clearance :type clearance: number :param viz_please: Whether to visualize or not :type viz_please: boolean :returns: Returns path nodes and the list of visited nodes. :rtype: tuple """ """ Inputs """ start_node = node.Node(current_coords=start_rc, parent_coords=None, orientation=0, parent_orientation=None, action=None, movement_cost=0, goal_cost=utils.euclideanDistance( start_rc, goal_rc)) print("-----------------------") print("Start Node:") start_node.printNode() print("-----------------------") goal_node = node.Node(current_coords=goal_rc, parent_coords=None, orientation=None, parent_orientation=None, action=None, movement_cost=None, goal_cost=0) """ Initializations """ action_set = [(0, rpm1), (rpm1, 0), (0, rpm2), (rpm2, 0), (rpm1, rpm2), (rpm2, rpm1), (rpm1, rpm1), (rpm2, rpm2)] min_heap = [((start_node.movement_cost + start_node.goal_cost), start_node) ] heapq.heapify(min_heap) visited = {} visited.update({ (utils.getKey(start_rc[0], start_rc[1], start_node.orientation)): start_node }) visited_viz_nodes = [start_node] """ Initialize the plot figures if the visualization flag is true. Also mark the start and the goal nodes. """ if viz_please: fig, ax = plt.subplots() ax.set(xlim=(an.MIN_COORDS[0], an.MAX_COORDS[0]), ylim=(an.MIN_COORDS[1], an.MAX_COORDS[1])) # ax.set(xlim=(-5, 5), ylim=(-5, 5)) ax.set_aspect('equal') obstacles.generateMap(plotter=ax) viz.markNode(start_node, plotter=ax, color='#00FF00', marker='o') viz.markNode(goal_node, plotter=ax, color='#FF0000', marker='^') plt.ion() """ Run the loop for A-star algorithm till the min_heap queue contains no nodes. """ while (len(min_heap) > 0): _, curr_node = heapq.heappop(min_heap) # Consider all the action moves for all the selected nodes. for action in action_set: new_node = an.actionMove(current_node=curr_node, next_action=action, goal_position=goal_rc, clearance=clearance) # Check if all the nodes are valid or not. if (new_node is not None): """ Check if the current node is a goal node. """ if new_node.goal_cost < GOAL_REACH_THRESH: print("Reached Goal!") print("Final Node:") new_node.printNode() visited_viz_nodes.append(new_node) path = an.backtrack(new_node, visited) print("------------------------") if viz_please: viz.plot_curve(new_node, plotter=ax, color="red") viz.plotPath(path, rev=True, pause_time=0.5, plotter=ax, color="lime", linewidth=4) plt.ioff() plt.show() return (path, visited_viz_nodes) """ Mark node as visited, Append to min_heap queue, Update if already visited. """ node_key = (utils.getKey(new_node.current_coords[0], new_node.current_coords[1], new_node.orientation)) if node_key in visited: if new_node < visited[node_key]: visited[node_key] = new_node min_heap.append( ((new_node.movement_cost + new_node.goal_cost), new_node)) else: if viz_please: viz.plot_curve(new_node, plotter=ax, color="red") plt.show() plt.pause(0.001) visited.update({node_key: new_node}) min_heap.append( ((new_node.movement_cost + new_node.goal_cost), new_node)) visited_viz_nodes.append(new_node) # Heapify the min heap to update the minimum node in the list. heapq.heapify(min_heap)
def extractInfo(): with open('app//app.info', "r") as fp: contents = fp.readlines() for content in contents: [a, b] = content.rstrip('\n').split(':') nd.Node()
def setUp(self): self.nodes = {} for i in range(1, 4): self.nodes[i] = node.Node(i)
def print_dict(data): for index, values in data.items(): print(f' --{hex(index)}') if type(values) == list: for val in values: print(f' > {val}') else: print(f' > {values}') parser = argparse.ArgumentParser(description='Print object') parser.add_argument('-f', '--file', action='store', dest='file') args = parser.parse_args() node = node.Node() node.load_from_file(args.file) print(f'OD File for {node.Name}') print(f' Type: {node.Type}') print(f' ID: {node.ID}') print(f' Description: {node.Description}') print(f' Profile Name: {node.ProfileName}') print(f' Profile: {node.Profile}') print(f' Dictionary:') print_dict(node.Dictionary) print(f' ParamsDictionary:')
def __init__(self, rootval): if rootval == None: self.root = None else: self.root = node.Node(rootval) self.traversecount = 0
current_node.add_transaction_to_block(transaction) return "Transaction OK" , 200 else: return "Transaction is Not Valid", 400 @app.route('/node/sendChain', methods=['GET']) def Chain(): return {'chain': jsonpickle.encode(current_node.chain.blockchain)} @app.route('/chain/print', methods=['GET']) def print_blockchain(): current_node.chain.print_chain() return jsonify({}),200 if __name__ == '__main__': from argparse import ArgumentParser parser = ArgumentParser() parser.add_argument('-p', '--port' ,type=int, help='port to listen on') parser.add_argument('-ip', '--ipaddress' ,type=str, help='port to listen on') parser.add_argument('-cap', '--capacity' ,type=int, help='the capacity of the block') parser.add_argument('-diff', '--difficulty' ,type=int, help='the block difficulty, number of "0" the hash starts with') args = parser.parse_args() port = args.port ip = args.ipaddress block_capacity = args.capacity block_difficulty = args.difficulty current_node = node.Node(ip,port,5000,'127.0.0.1',block_capacity, block_difficulty) app.run(host = '127.0.0.1', port = port)
def test_rootIsNodeOnly(self): root = node.Node(1) self.assertEqual(1, node.lowestCommonAncestor(root, 1, 1))
def addToFront(self, val): n = node.Node() n.sett(val) n.next = self.head.next self.head.next = n
# Print network graph def printNetwork(): plt.figure(1) nx.draw_networkx_nodes(graph, pos) nx.draw_networkx_labels(graph, pos, labels) nx.draw_networkx_edges(graph, pos, arrows=True, connectionstyle='arc3,rad=0.2') plt.show() # Generate nodes with id appropriate to their position for row in range(1, rows + 1): for column in range(1, columns + 1): node_list.append(node.Node("{}:{}".format(row, column), buffer_size)) # Generate adequate horizontal links with alternating directions for row in range(1, rows + 1): for column in range(1, columns): if row % 2 == 1: link_list.append( link.Link(uuid.uuid1(), getNode(row, column).id, getNode(row, column + 1).id)) else: link_list.append( link.Link(uuid.uuid1(), getNode(row, column + 1).id, getNode(row, column).id)) if row % 2 == 1:
arguments = p.parse_args(sys.argv[1:]) nickname = arguments.nickname lost = arguments.lost port = arguments.port if lost < 0 or lost > 100: print("Значение процента потерь должно быть от 0 до 100!!!") exit(1) if len(nickname) > 20: print("Никнейм должен быть не длиннее 20 символов") exit(1) parent_address = None parent_port = None if arguments.parent_address or arguments.parent_port: parent_address = arguments.parent_address parent_port = arguments.parent_port ROOT = False if not (parent_address or parent_port): print( "Если передавать адрес родителя, то нужно передавать и адрес, и порт," " либо вообще ничего не передавать!!!") exit(1) print(nickname, lost, port, parent_address, parent_port) if ROOT: node = node.Node(nickname, port, lost) else: node = node.Node(nickname, port, lost, (parent_address, parent_port))
y_lat[ip] = shape.points[ip][1] #plt.plot(x_lon, y_lat) x_min, y_min, x_max, y_max = polygon.bounds bitmap = [] row = [] x_range = np.arange(x_min, x_max, 0.0001) y_range = np.arange(y_min, y_max, 0.0001) for j in range(0, len(y_range)): row = [] for i in range(0, len(x_range)): point = None if polygon.contains(Point(x_range[i], y_range[j])): plt.scatter(x_range[i], y_range[j], s=.5, c='blue') point = node.Node(x_range[i], y_range[j], "In") else: plt.scatter(x_range[i], y_range[j], s=.5, c='yellow') point = node.Node(x_range[i], y_range[j], "Out") row.append(point) bitmap.append(row) shape = np.array(bitmap).shape # for x in range(0, shape[0]): # for y in range(0, shape[1]): # if bitmap[x][y].get_state() == "Out": # try: # if bitmap[x+1][y].get_state() == "In": # if (bitmap[x+1][y-1].get_state() == "In" and bitmap[x][y-1].get_state() == "In") or (bitmap[x+1][y+1].get_state() == "In" and bitmap[x][y+1].get_state() == "In"): # bitmap[x][y].set_state("Partial")