def graph_search(nx_graph, target_species): """Search nodal graph and generate list of species to exclude Parameters ---------- nx_graph : obj networkx graph object of solution\ target_species : list List of target species to search from Returns ------- essential_nodes : str String containing names of essential species """ if len(target_species) > 1: essential_nodes = list() for target in target_species: essential = list(nx.dfs_preorder_nodes(nx_graph, target)) for sp in essential: if sp not in essential_nodes: essential_nodes.append(sp) else: essential_nodes = list(nx.dfs_preorder_nodes(nx_graph, target_species[0])) return essential_nodes
def convert_location_type(location, source_type, desired_type): """ Converts the provided location into the desired location_type This will perform a DFS on the location graph to find connected components to the supplied node and then filter by the desired location_type. Basically if we consider our datacenter layout a DAG, then this method will search any nodes connected to the source location looking for the proper type. Examples: Assume available_location_types() is ['ecosystem', 'region', 'habitat'], and the location graph is: - prod - uswest1-prod - uswest1aprod - uswest1bprod # convert a habitat to the containing ecosystem convert_location_type('uswest1aprod', 'habitat', 'ecosystem') -> ['prod'] # convert a region to the member habitats convert_location_type('uswest1-prod', 'region', 'habitat') -> ['uswest1aprod', 'uswest1bprod'] :param location: A string that represents a location, e.g. "devc" :param source_type: A string that should exist inside the list returned by available_location_types. This is the type of the provided location and is optional. This exists because the names in the DAG may not be unique across all levels, and providing this type will disambiguate between which "devc" you mean (ecosystem or habitat). :param desired_type: A string that should exist inside the list returned by available_location_types. This is the desired type that the caller wants. :returns: locations, A list of locations that are of the location_type. These will be connected components filtered by type. Note that these results are sorted for calling consistency before returning. :rtype: list of strings """ search_node = '{0}_{1}'.format(location, source_type) direction = compare_types(desired_type, source_type) candidates = set() if direction < 0: # We are converting "up", and have to walk the tree backwards reversed_graph = nx.reverse(location_graph()) candidates |= set(nx.dfs_preorder_nodes(reversed_graph, search_node)) else: candidates |= set(nx.dfs_preorder_nodes(location_graph(), search_node)) # Only return results that are of the correct type result = filter(lambda x: x.endswith('_' + desired_type), candidates) return sorted([loc[:loc.rfind('_')] for loc in result])
def _validate_comp_pre(RG): ''' validates connection at a certain level ''' # use topological sort to find root. root = nx.topological_sort(RG)[0] # try to solve each node. for p in nx.dfs_preorder_nodes(RG, source=root): # dive down. if RG.node[p]['graph'] != None: _validate_comp_pre(RG.node[p]['graph']) # skip if child. if len(RG.successors(p)) == 0: continue # check children. for q in RG.successors(p): # get sets. pcomp = RG.node[p]['comp'] qcomp = RG.node[q]['comp'] # compute cuts. cutGIVEN = RG[p][q]['cut'] cutTEST = pcomp.intersection(qcomp) # test cut. if cutGIVEN != cutTEST: print "bad cut" print cutGIVEN, cutTEST print n, parent sys.exit()
def triangulate_rectangular_contours(landscape): """ Given an enumerated contour landscape tree, returns a list of the triangles in the landscape metaphor. """ root_node = [n for n in landscape if landscape.in_degree(n) == 0][0] triangles = [] # handle the root node child_node = landscape.successors(root_node)[0] outer_inds = landscape.node[root_node]["contour"].indices inner_inds = landscape.node[child_node]["contour"].indices triangles.extend(triangulate_nested_rectangle(outer_inds, inner_inds)) # now work through the remaining nodes dfs_nodes = nx.dfs_preorder_nodes(landscape, root_node) dfs_nodes.next() for node in dfs_nodes: # we only do something if this is not a leaf is_leaf = landscape.out_degree(node) == 0 if not is_leaf: outer_saddle_contour = landscape.node[node]["contour"] for inner_saddle_contour in outer_saddle_contour.children: child = inner_saddle_contour.child child_contour = landscape.node[child]["contour"] inner_saddle_indices = inner_saddle_contour.indices child_indices = child_contour.indices if child_contour.type == "leaf": triangles.extend(triangulate_nested_point(inner_saddle_indices, child_indices[0])) else: triangles.extend(triangulate_nested_rectangle(inner_saddle_indices, child_indices)) return triangles return np.array(points)
def reachable(self, source, observed): """ Finds a set of reachable (in the sense of d-separation) nodes in graph. :param self: target graph :param source: source node name :param observed: a sequence of observed nodes :return: a set of reachable nodes """ V = nx.number_of_nodes(self) A = set(sum([list(nx.dfs_preorder_nodes(self.reverse(), z)) for z in observed], [])) Z = observed L = [(source, 'up')] V = set() result = set() while len(L) > 0: x, d = L.pop() if (x, d) in V: continue if x not in Z: result.add((x, d)) V.add((x, d)) if d == 'up' and x not in Z: for y in self.predecessors_iter(x): L.append((y, 'up')) for y in self.successors_iter(x): L.append((y, 'down')) elif d == 'down': if x in A: for y in self.predecessors_iter(x): L.append((y, 'up')) if x not in Z: for y in self.successors_iter(x): L.append((y, 'down')) result = set([x[0] for x in result]) return result - {source}
def process_boosters(dag): dag_nx = utils.dag_to_nx(dag) processed_dag = dict() sub_dags = [] for k, spec in dag.items(): if spec[1][0] == 'booBegin': input_name = spec[0] for node in nx.dfs_preorder_nodes(dag_nx, k): node_type = dag[node][1][0] if node == k: continue if node_type == 'booster': sub_dags.append(dag[node][1][2]) if node_type == 'booEnd': sub_dags = [normalize_dag(sd) for sd in sub_dags] processed_dag[k] = (input_name, ['booster', {'sub_dags': sub_dags}], dag[node][2]) sub_dags = [] break elif spec[1][0] in ['booster', 'booEnd']: continue else: processed_dag[k] = spec return processed_dag
def calc_ProjFeatures(self): #Add edges to projection Graph for node in self.gM.nodes(): neighbours=self.G.neighbors(node) for item in neighbours: if self.gM.has_node(item): try: if node!=item: self.gM.add_edge(node,item) except: pass #Initialize and Calculate features closed=[];self.gM_connComp=0; self.gM_maxDeg=0;self.gM_sizeMaxComp=0 for node in self.gM.nodes(): if node not in closed: x=nx.dfs_preorder_nodes(self.gM,node) pre=list(x) closed=closed +pre self.gM_connComp= self.gM_connComp+1 if len(pre)>self.gM_sizeMaxComp: self.gM_sizeMaxComp=len(pre) if self.gM_maxDeg < self.gM.degree(node): self.gM_maxDeg=self.gM.degree(node) return
def _get_node_to_pset_same_transition_matrix(T, root, P, node_to_allowed_states=None): T_bfs = nx.bfs_tree(T, root) preorder_nodes = list(nx.dfs_preorder_nodes(T, root)) sorted_states = sorted(P) # Put the tree into sparse boolean csr form. tree_csr_indices, tree_csr_indptr = _digraph_to_bool_csr( T_bfs, preorder_nodes) # Put the transition matrix into sparse boolean csr form. trans_csr_indices, trans_csr_indptr = _digraph_to_bool_csr( P, sorted_states) # Define the state mask. state_mask = _define_state_mask( node_to_allowed_states, preorder_nodes, sorted_states) # Update the state mask. pyfelscore.mcy_get_node_to_pset( tree_csr_indices, tree_csr_indptr, trans_csr_indices, trans_csr_indptr, state_mask) # Convert the updated state mask into a node_to_pset dict. node_to_pset = _state_mask_to_dict( state_mask, preorder_nodes, sorted_states) # Return the node_to_pset dict. return node_to_pset
def transitive_closure(G): """ Returns transitive closure of a directed graph The transitive closure of G = (V,E) is a graph G+ = (V,E+) such that for all v,w in V there is an edge (v,w) in E+ if and only if there is a non-null path from v to w in G. Parameters ---------- G : NetworkX DiGraph Graph Returns ------- TC : NetworkX DiGraph Graph Raises ------ NetworkXNotImplemented If G is not directed References ---------- .. [1] http://www.ics.uci.edu/~eppstein/PADS/PartialOrder.py """ TC = nx.DiGraph() TC.add_nodes_from(G.nodes()) TC.add_edges_from(G.edges()) for v in G: TC.add_edges_from((v, u) for u in nx.dfs_preorder_nodes(G, source=v) if v != u) return TC
def _retrieve_skycoords(V): coords_l = [] # Accessing the borders one by one. At this step, V_subgraphs contains a list of cycles # (i.e. one describing the external border of the MOC component and several describing the holes # found in the MOC component). V_subgraphs = nx.connected_component_subgraphs(V) for v in V_subgraphs: # Compute the MST for each cycle v = nx.convert_node_labels_to_integers(v) mst = nx.minimum_spanning_tree(v) # Get one end of the span tree by looping over its node and checking if the degree is one src = None for (node, deg) in mst.degree(): if deg == 1: src = node break # Get the unordered lon and lat ra = np.asarray(list(nx.get_node_attributes(v, 'ra').values())) dec = np.asarray(list(nx.get_node_attributes(v, 'dec').values())) coords = np.vstack((ra, dec)).T # Get the ordering from the MST ordering = np.asarray(list(nx.dfs_preorder_nodes(mst, src))) # Order the coords coords = coords[ordering] # Get a skycoord containing N coordinates computed from the Nx2 `coords` array coords = SkyCoord(coords, unit="deg") coords_l.append(coords) return coords_l
def descendants(G, x): """ Set of all descendants of node in a graph, not including itself. :param G: target graph :param x: target node :return: set of descendants """ return set(nx.dfs_preorder_nodes(G, x)) - {x}
def recalculateDependent(self, node, returnResult=False): if self.dependencyGraph.has_node(node): generator = dfs_preorder_nodes(self.dependencyGraph, node) next(generator ) # skip the first, that is us nodelist = list(generator) # make a list, we need it twice result = [ self.recalculateNode(node) for node in nodelist ] return (nodelist, result) if returnResult else nodelist # return which ones were re-calculated, so gui can be updated return (list(), list()) if returnResult else list()
def propose(self): self.oldgraph = self.graph.copy() self.memo_entropy = None g = self.graph if g.edges(): scheme = np.random.randint(3) else: scheme = np.random.randint(2) nodes = g.nodes() if scheme == 0: # Perturb probabilities n1 = np.random.randint(len(nodes)) if g.predecessors(n1): g.node[n1]['delta'] = st.beta.rvs(0.4,0.4) g.node[n1]['eta'] = st.beta.rvs(0.4,0.4) g.node[n1]['marginal'] = np.nan else: g.node[n1]['delta'] = np.nan g.node[n1]['eta'] = np.nan g.node[n1]['marginal'] = np.random.rand() if scheme == 1: # Add or change edge 'backwards' while True: random.shuffle(nodes) #inefficient n0 = nodes[0] n1 = nodes[1] if g.predecessors(n1): g.remove_edge(g.predecessors(n1)[0], n1) g.add_edge(n0, n1) if nx.is_directed_acyclic_graph(g): break else: g = self.graph = self.oldgraph.copy() g.node[n1]['delta'] = st.beta.rvs(0.4,0.4) g.node[n1]['eta'] = st.beta.rvs(0.4,0.4) g.node[n1]['marginal'] = np.nan if scheme == 2: # Remove edge edges = g.edges() edge = edges[np.random.randint(len(edges))] n1 = edge[1] g.remove_edge(*edge) g.node[n1]['delta'] = np.nan g.node[n1]['eta'] = np.nan g.node[n1]['marginal'] = np.random.rand() #print len(g.edges()) trav = nx.dfs_preorder_nodes(g,n1) # FIXME, this may be a problem, dfs_preorder # was not what I thought it was before trav.next() for node in trav: g.node[node]['marginal'] = np.nan #invalidate downstream cached marginals
def kosaraju_strongly_connected_components(G, source=None): """Generate nodes in strongly connected components of graph. Parameters ---------- G : NetworkX Graph An directed graph. Returns ------- comp : generator of sets A genrator of sets of nodes, one for each strongly connected component of G. Raises ------ NetworkXNotImplemented: If G is undirected. Examples -------- Generate a sorted list of strongly connected components, largest first. >>> G = nx.cycle_graph(4, create_using=nx.DiGraph()) >>> nx.add_cycle(G, [10, 11, 12]) >>> [len(c) for c in sorted(nx.kosaraju_strongly_connected_components(G), ... key=len, reverse=True)] [4, 3] If you only want the largest component, it's more efficient to use max instead of sort. >>> largest = max(nx.kosaraju_strongly_connected_components(G), key=len) See Also -------- connected_components weakly_connected_components Notes ----- Uses Kosaraju's algorithm. """ with nx.utils.reversed(G): post = list(nx.dfs_postorder_nodes(G, source=source)) seen = set() while post: r = post.pop() if r in seen: continue c = nx.dfs_preorder_nodes(G, r) new = {v for v in c if v not in seen} yield new seen.update(new)
def order_intervals(intervals, start): """ computes the intersection graph of the intervals, takes the data attribute of the intervals as nodes, hence intervals belonging to the same segment correspond to one node in the graph. returns a traversal starting from start. """ G = dict(((i.data, []) for i in intervals)) #right to left sweep according to left endpoints #linear time with proper sorting stack = [] for i in sorted(intervals, reverse = True, key = lambda i: i.endpoints): l, r = i.endpoints while stack and r>stack[-1].endpoints[1]: i2 = stack.pop() if stack and r>= stack[-1].endpoints[0]: G[i.data].append(stack[-1].data) G[stack[-1].data].append(i.data) stack.append(i) #left to right sweep according to right endpoints stack = [] for i in sorted(intervals, key = lambda i: (i.endpoints[1], i.endpoints[0])): l, r = i.endpoints while stack and l<stack[-1].endpoints[0]: i2 = stack.pop() if stack and l<= stack[-1].endpoints[1]: G[i.data].append(stack[-1].data) G[stack[-1].data].append(i.data) stack.append(i) order = list(nx.dfs_preorder_nodes(G,start)) if not len(order) == len(G): seen = set(order) for v in G: if v in seen: continue raise IntervalException(list(nx.dfs_preorder_nodes(G,v))) return order
def getStructure(self): nodes = [] for n in nx.dfs_preorder_nodes(self.structure, self.root): p = self.structure.in_edges(n) if len(p) == 0: p = "" else: p = p[0][0] nodes.append((n, self.structure.node[n]['name'], p)) return nodes
def transitiveReduction(g): ''' from http://stackoverflow.com/questions/17078696/im-trying-to-perform-the-transitive-reduction-of-directed-graph-in-python''' for n1 in g.nodes_iter(): if g.has_edge(n1, n1): g.remove_edge(n1, n1) for n2 in g.successors(n1): for n3 in g.successors(n2): for n4 in nx.dfs_preorder_nodes(g, n3): if g.has_edge(n1, n4): g.remove_edge(n1, n4)
def describe(self, data_type): G = self.hierarchy df = self.get_data(data_type) for n in nx.dfs_postorder_nodes(G, 'all'): G.node[n]['cnt'] = len(df[df['area']==n].index) + pl.sum([G.node[c]['cnt'] for c in G.successors(n)]) G.node[n]['depth'] = nx.shortest_path_length(G, 'all', n) for n in nx.dfs_preorder_nodes(G, 'all'): if G.node[n]['cnt'] > 0: print ' *'*G.node[n]['depth'], n, int(G.node[n]['cnt'])
def _find_ship_and_adjacents(self, i): """DFS work to find adjacent ships comprising the new larger ship.""" ship, adj_decks, adj_ships = [i], [], [] for adj_tile in self._adjacent_tiles(i): if adj_tile in self._decks: adj_decks.append(adj_tile) adj_ship = list(networkx.dfs_preorder_nodes(self._decks, adj_tile)) adj_ships.append(adj_ship) ship.extend(adj_ship) return sorted(ship), adj_decks, adj_ships
def _esd_get_node_to_set(T, root, node_to_allowed_states=None, P_default=None): # Construct the bfs tree, preserving transition matrices on the edges. T_bfs = nx.DiGraph() for na, nb in nx.bfs_edges(T, root): T_bfs.add_edge(na, nb) edge_object = T[na][nb] P = edge_object.get('P', None) if P is not None: T_bfs[na][nb]['P'] = P # Get the ordered list of nodes in preorder. preorder_nodes = list(nx.dfs_preorder_nodes(T, root)) # Get the set of all states in all transition matrices. state_set = set() for na, nb in T_bfs.edges(): edge_object = T_bfs[na][nb] P = edge_object.get('P', P_default) state_set.update(set(P)) sorted_states = sorted(state_set) # Put the tree into sparse boolean csr form. tree_csr_indices, tree_csr_indptr = _digraph_to_bool_csr( T_bfs, preorder_nodes) # Define the state mask. state_mask = _define_state_mask( node_to_allowed_states, preorder_nodes, sorted_states) # Construct the edge-specific transition matrix as an ndim-3 numpy array. esd_transitions = _get_esd_transitions( T_bfs, preorder_nodes, sorted_states, P_default=P_default) # Backward pass to update the state mask. pyfelscore.mcy_esd_get_node_to_pset( tree_csr_indices, tree_csr_indptr, esd_transitions, state_mask) # Forward pass to update the state mask. pyfelscore.esd_get_node_to_set( tree_csr_indices, tree_csr_indptr, esd_transitions, state_mask) # Convert the updated state mask into a node_to_set dict. node_to_set = _state_mask_to_dict( state_mask, preorder_nodes, sorted_states) # Return the node_to_set dict. return node_to_set
def __init__(self,w): g=nx.DiGraph() g0=nx.Graph() n=math.factorial(w) self.n = n perms = [] self.perms=perms for p in itertools.permutations(list(range(w))): perms.append(p) for x in range(0,w) : for y in range(x+1,w+1): d = y-x for i in range(n): for j in range(n): match=True #print d,x,y,i,j,w-d,"####" for k in range(w-d): #print d,x,y,i,j,k,k+d if not perms[i][k]+d == perms[j][k+d]: match=False if match: g.add_edge((x,i),(y,j),weight=d*d ) g0.add_edge((x,i),(y,j),weight=d*d ) #print (x,i),(y,j),d,"z" # for e in g.edges(): #print "e:",e n_backlinks=0 backlinks={} for i in range(n): backlinks[i]=[] nn = nx.dfs_preorder_nodes(g,(0,i)) #print "#",str((0,i))#,list(nn) sg = g0.subgraph(nn) #print "#",list(sg.nodes()) t = nx.minimum_spanning_tree(sg) for a,b in t.edges(): if b<a: c=b b=a a=c if a==(0,i): #print "x:",b[0]-a[0],a,b,perms[b[1]],perms[a[1]] n_backlinks+=1 backlinks[i].append( (b[0]-a[0],b[1]) ) self.backlinks = backlinks self.n_backlinks=n_backlinks
def describe(self, data_type): G = self.hierarchy df = self.get_data(data_type) for n in nx.dfs_postorder_nodes(G, "all"): G.node[n]["cnt"] = len(df[df["area"] == n].index) + pl.sum([G.node[c]["cnt"] for c in G.successors(n)]) G.node[n]["depth"] = nx.shortest_path_length(G, "all", n) for n in nx.dfs_preorder_nodes(G, "all"): if G.node[n]["cnt"] > 0: print " *" * G.node[n]["depth"], n, int(G.node[n]["cnt"])
def edges2oo(f): g=nx.Graph() ll={} scaffolds={} scaffold={} while True: l = f.readline() if not l: break if l[:6]=="#edge:": #continue c = l.strip().split() v=eval(" ".join(c[3:])) if v['contig']: ll[c[1][:-2]]=v['length'] g.add_edge(c[1],c[2],v) if l[:3]=="cc:": #continue c = l.strip().split() scn=int(c[1]) scl=eval(" ".join(c[3:])) scaffolds[scn]=scl for s in scl: scaffold[s]=scn contigs=[] strand={} scaffold={} coords={} facing={} ccn=1 for c in nx.connected_components(g): # print "#",len(c) ends=[] for cc in c: scaffold[cc]=ccn if g.degree(cc)==1: ends.append(cc) ccn+=1 order = list(nx.dfs_preorder_nodes(g,ends[0])) # def traverse_and_layout(n,coords,facing,x,s,og,max_disp=False): # """Traverse the nodes in og, from node n. Give node n position x. s==1 for increasing coords, -1 for decreasing. store in coords and facing the position and 'side' of each end respectively. # Stop traversing if you hit max_disp (optional).""" greedy_chicagoan2.traverse_and_layout(ends[0],coords,facing,0,1,g) order1=[] for i in range(0,len(order),2): print(order) if not order[i][:-2]==order[i+1][:-2]: print("wtf", i,order) exit(0) if order[i][-1]=="5": strand[order[i][:-2]]="+" else: strand[order[i][:-2]]="-" order1.append(order[i][:-2]) contigs.append(order1) return(contigs,strand,ll,scaffolds,scaffold,coords)
def _depth_first_search(edge_list): ''' This function does a depth first search of a graph with a random node selected as the root of a tree representing the graph. ''' G_tmp = nx.Graph() G_tmp.add_weighted_edges_from(edge_list) edge_index = random.randint(0, len(edge_list) - 1) path_sequence = list(nx.dfs_preorder_nodes(G_tmp, edge_list[edge_index][0])) return path_sequence
def optimize_dead_ends(in_g, out_g): print "DEBUG: There are %s dead ends and %s odd-degree nodes in this graph." % ( len(dead_ends(in_g)), len(odd_nodes(in_g))) for node in dead_ends(in_g): new_from = node new_to = next(n for n in networkx.dfs_preorder_nodes( in_g, node) if len(set(adjoining_streets(in_g,n))) > 1) print "DEBUG: I will optimize by adding an edge from %s to %s" % ( in_g.node[new_from]['pretty_name'], in_g.node[new_to]['pretty_name']) add_artificial_edge(in_g, out_g, new_from, new_to) print "DEBUG: There are now %s dead ends and %s odd-degree nodes in this graph." % ( len(dead_ends(out_g)), len(odd_nodes(out_g)))
def _partition(self): """ Return all the atoms of the I-diagram for `dist`. Parameters ---------- dist : distribution The distribution to compute the I-diagram of. """ rvs = self.dist.get_rv_names() if not rvs: rvs = tuple(range(self.dist.outcome_length())) self._lattice = poset_lattice(rvs) rlattice = self._lattice.reverse() Hs = {} Is = {} atoms = {} new_atoms = {} # Entropies for node in self._lattice: Hs[node] = self._measure(self.dist, node) # pylint: disable=no-member # Subset-sum type thing, basically co-information calculations. for node in self._lattice: Is[node] = sum((-1)**(len(rv)+1)*Hs[rv] for rv in nx.dfs_preorder_nodes(self._lattice, node)) # Mobius inversion of the above, resulting in the Shannon atoms. for node in list(nx.topological_sort(self._lattice))[:-1]: kids = islice(nx.dfs_preorder_nodes(rlattice, node), 1, None) atoms[node] = Is[node] - sum(atoms[child] for child in kids) # get the atom indices in proper format for atom, value in atoms.items(): a_rvs = tuple((_,) for _ in atom) a_crvs = tuple(sorted(set(rvs) - set(atom))) new_atoms[(a_rvs, a_crvs)] = value self.atoms = new_atoms
def get_node_to_distn_esd(T, root, node_to_pmap, nstates, root_distn=None, P_default=None): """ """ # Construct the bfs tree, preserving transition matrices on the edges. T_bfs = nx.DiGraph() for na, nb in nx.bfs_edges(T, root): T_bfs.add_edge(na, nb) edge_object = T[na][nb] P = edge_object.get('P', None) if P is not None: T_bfs[na][nb]['P'] = P # Get the ordered list of nodes in preorder. preorder_nodes = list(nx.dfs_preorder_nodes(T, root)) nnodes = len(preorder_nodes) # Put node_to_pmap into a dense array. subtree_probability = np.empty((nnodes, nstates), dtype=float) for nb_index, nb in enumerate(preorder_nodes): subtree_probability[nb_index] = node_to_pmap[nb] # Put the tree into sparse boolean csr form. tree_csr_indices, tree_csr_indptr = _density.digraph_to_bool_csr( T_bfs, preorder_nodes) # Construct the edge-specific transition matrix as an ndim-3 numpy array. esd_transitions = _density.get_esd_transitions( T_bfs, preorder_nodes, nstates, P_default=P_default) # Define the prior distribution at the root. if root_distn is None: root_distn = np.ones(nstates, dtype=float) # Get the posterior distribution at each node. node_to_distn_array = np.empty((nnodes, nstates), dtype=float) pyfelscore.mc0_esd_get_node_to_distn( tree_csr_indices, tree_csr_indptr, esd_transitions, root_distn, subtree_probability, node_to_distn_array) # Convert the ndarray back into a dict. node_to_distn = {} for na_index, na in enumerate(preorder_nodes): node_to_distn[na] = node_to_distn_array[na_index] # Return the dict. return node_to_distn
def genes_in_subgraph(cursor, graph, parent_id): genes = [] # this is the whole subtree descendants = [pid for pid in nx.dfs_preorder_nodes(graph, parent_id) if count_successors(graph, pid) == 0] desc_id_string = ",".join([quotify(d) for d in descendants]) qry = "select distinct(ensembl_gene_id) from ensembl2reactome " qry += "where reactome_pathway_id in (%s)" % desc_id_string ret = error_intolerant_search(cursor,qry) if not ret: print("possible problem in Reactome: no associated genes found for ", desc_id_string) return [] return [r[0] for r in ret]
def max_repeated(self, k): '''Return the node of maximum prefix length with #leaves >= k under it.''' g = self._g num_leaves = [0] * g.number_of_nodes() for node in nx.dfs_postorder_nodes(g): num_leaves[node] = 1 if g.out_degree(node) == 0 else sum(num_leaves[child] for child in g.successors_iter(node)) prefix_len = np.zeros((g.number_of_nodes(),), dtype=int) for node in nx.dfs_preorder_nodes(g): node_prefix_len = prefix_len[node] for child, e_attr in g[node].iteritems(): prefix_len[child] = node_prefix_len + e_attr['weight'][1] try: return max(it.ifilter(lambda x: x[0][1] >= k, ((v, k) for k, v in enumerate(zip(prefix_len, num_leaves)))))[1] except ValueError: return None
def _add_state(self, g): for node in nx.dfs_preorder_nodes(g, tuple()): if node == tuple(): state = {} elif node[-1] is None: parent = g.predecessors(node)[0] state = g.node[parent]['state'] else: state = {feat: value for feat, value in zip(self.features, node)} g.node[node]['state'] = state return g
def kosaraju_strongly_connected_components(G,source=None): """Return nodes in strongly connected components of graph. Parameters ---------- G : NetworkX Graph An directed graph. Returns ------- comp : list of lists A list of nodes for each component of G. The list is ordered from largest connected component to smallest. See Also -------- connected_components Notes ----- Uses Kosaraju's algorithm. """ components=[] G=G.reverse(copy=False) post=list(nx.dfs_postorder_nodes(G,source=source)) G=G.reverse(copy=False) seen={} while post: r=post.pop() if r in seen: continue c=nx.dfs_preorder_nodes(G,r) new=[v for v in c if v not in seen] seen.update([(u,True) for u in new]) components.append(new) components.sort(key=len,reverse=True) return components
def kosaraju_strongly_connected_components(G,source=None): """Generate nodes in strongly connected components of graph. Parameters ---------- G : NetworkX Graph An directed graph. Returns ------- comp : generator of lists A list of nodes for each component of G. Raises ------ NetworkXNotImplemented: If G is undirected. See Also -------- connected_components Notes ----- Uses Kosaraju's algorithm. """ with nx.utils.reversed(G): post = list(nx.dfs_postorder_nodes(G, source=source)) seen = {} while post: r = post.pop() if r in seen: continue c = nx.dfs_preorder_nodes(G,r) new=[v for v in c if v not in seen] seen.update([(u,True) for u in new]) yield new
def get_best_paths(self, npaths=-1): """ Extract npaths paths leading to the highest values of the cost function :param npaths: an integer specifying number of paths to generate (default all path) :return: generator returning the list of nodes. """ # set the default number of paths if npaths is negative npaths = (len(self.landscape) if npaths < 0 else npaths) # Get npaths nodes with the largest cost function, which represent the end of policies best_nodes = heapq.nlargest( npaths, ((self.get_cost_function(prop), node) for node, prop in self.landscape.node.items()) ) # Extract the nodes best_nodes = zip(*best_nodes)[1] for end_node in best_nodes: # extract list of nodes using depth first search # Note: depth first search must yield the same result as breath first search nodes = list(nx.dfs_preorder_nodes(self.landscape, end_node)) nodes.reverse() yield nodes
def extract_conjunctive_queries(r_graph): import networkx as nx import rdflib from rdflib import URIRef, BNode, Literal from rdflib.namespace import RDF from rdflib.extras.external_graph_libs import rdflib_to_networkx_multidigraph join_nodes = r_graph.subjects(RDF.type, URIRef("http://www.dfki.de/voc#Join")) # nx_r_graph = rdflib_to_networkx_multidigraph(r_graph, edge_attrs=lambda s, p, o: {'e': r_graph.qname(p)}) nx_r_graph = rdflib_to_networkx_multidigraph( r_graph, edge_attrs=lambda s, p, o: {'e': p}) # draw_graph(nx_r_graph) nx_conjunctive_query_patterns = list() for join_node in join_nodes: nx_conjunctive_query_patterns.append( nx.subgraph(nx_r_graph, list(nx.dfs_preorder_nodes(nx_r_graph, join_node))).copy()) return nx_conjunctive_query_patterns
def _build_graph(self, target, commands=False, outs=False): import networkx from dvc import dvcfile from dvc.repo.graph import get_pipeline from dvc.utils import parse_target path, name, tag = parse_target(target) target_stage = dvcfile.Dvcfile(self.repo, path, tag=tag).stages[name] G = get_pipeline(self.repo.pipelines, target_stage) nodes = set() for stage in networkx.dfs_preorder_nodes(G, target_stage): if commands: if stage.cmd is None: continue nodes.add(stage.cmd) elif outs: for out in stage.outs: nodes.add(str(out)) else: nodes.add(stage.addressing) edges = [] for from_stage, to_stage in networkx.edge_dfs(G, target_stage): if commands: if to_stage.cmd is None: continue edges.append((from_stage.cmd, to_stage.cmd)) elif outs: for from_out in from_stage.outs: for to_out in to_stage.outs: edges.append((str(from_out), str(to_out))) else: edges.append((from_stage.addressing, to_stage.addressing)) return list(nodes), edges, networkx.is_tree(G)
def calc_all_pairs(self, num_relations=3): """ Given a connected graph, calculate all possible pairs of paths, i.e all simple paths :return: """ nodes = list(nx.dfs_preorder_nodes(self.connected_family, 0)) all_pairs = [] for node_a, node_b in it.combinations(nodes, 2): for path in nx.all_simple_paths(self.connected_family, node_a, node_b, cutoff=num_relations): path_len = len(path) if path_len == num_relations + 1: min_path = [path[0], path[-1]] if self.connected_family.has_edge(min_path[0], min_path[1]): all_pairs.append((node_a, node_b, path, min_path)) else: continue # calculate path stats path_lens = [len(path_pairs[2]) - 1 for path_pairs in all_pairs] max_paths = max(path_lens) min_paths = min(path_lens) path_stats = { 'max_path': max_paths, 'min_path': min_paths, 'num_path': len(all_pairs), 'path_counts': [path_lens.count(pi) for pi in range(min_paths, max_paths + 1)] } return all_pairs, path_stats
def peo(tree): """ Returns a perfect elimination order and corresponding cliques, separators, histories, , rests for tree. Args: tree (NetworkX graph): A junction tree. Returns: tuple: A tuple of form (C, S, H, A, R), where the elemenst are lists of Cliques, Separators, Histories, , Rests, from a perfect elimination order. """ # C = list(nx.dfs_preorder_nodes(tree, tree.nodes()[0])) # nx < 2.x C = list(nx.dfs_preorder_nodes(tree, list(tree.nodes)[0])) # nx > 2.x S = [set() for j in range(len(C))] H = [set() for j in range(len(C))] R = [set() for j in range(len(C))] A = [set() for j in range(len(C) - 1)] S[0] = None H[0] = C[0] R[0] = C[0] for j in range(1, len(C)): H[j] = H[j - 1] | C[j] S[j] = H[j - 1] & C[j] A[j - 1] = H[j - 1] - S[j] R[j] = C[j] - H[j - 1] return (C, S, H, A, R)
def apprAlgorithm(G): # Find a minimum spanning tree T of G T = nx.minimum_spanning_tree(G, weight='weight') dfs = nx.dfs_preorder_nodes(T, '0') listnode = [] for item in dfs: listnode += [item] # Create the hamiltonian tour L = nx.Graph() L.add_nodes_from(G.nodes(data=True)) cost = 0 weight = nx.get_edge_attributes(G, 'weight') for index, item in enumerate(listnode): if index < len(G) - 1: L.add_edge(item, listnode[index + 1]) cost += G[str(item)][str(listnode[index + 1])]['weight'] else: L.add_edge(item, listnode[0]) cost += G[str(item)][str(listnode[0])]['weight'] return (cost, T, L, listnode)
def verify(self, test_disconnection: bool = True): for prod in self.productions.values(): for rule in prod: for v in rule.sequence: if isinstance(v, str): if v not in self: raise MissingProductionError(f"Production {prod.name} references {v}, which is not in the grammar") elif prod.name not in self.used_by[v]: raise CorruptedGrammarError( f"Production {prod.name} references {v} but that is not " 'recorded in the "used by" table: ' f"{self.used_by[prod.name]!r}" ) for user in self.used_by[prod.name]: if user not in self: raise CorruptedGrammarError( f"Production {prod.name} is used by {user}, but {user} production is not in the grammar" ) # if not self.used_by[prod.name] and self.start is not prod: # print(f"Warning: Production {prod.name} is never used") for prod_name in self.used_by.keys(): if prod_name not in self: raise CorruptedGrammarError(f'Production {prod_name} is in the "used by" table, but not in the grammar') if self.start is not None and test_disconnection: # make sure there is a path from start to every other production graph = self.dependency_graph() visited = set(node for node in nx.dfs_preorder_nodes(graph, source=self.start)) if len(visited) < len(self.productions): not_visited_prods = set(node for node in self.productions.values() if node not in visited) # it's okay if the unvisited productions aren't able to produce terminals not_visited = [node.name for node in not_visited_prods if node.can_produce_terminal] if not_visited: raise DisconnectedGrammarError( "These productions are not accessible from the start production " f"{self.start.name}: {', '.join(not_visited)}" )
def local_independencies(self, variables): """ Returns an instance of Independencies containing the local independencies of each of the variables. Parameters ---------- variables: str or array like variables whose local independencies are to be found. Examples -------- >>> from pgmpy.models import DAG >>> student = DAG() >>> student.add_edges_from([('diff', 'grade'), ('intel', 'grade'), >>> ('grade', 'letter'), ('intel', 'SAT')]) >>> ind = student.local_independencies('grade') >>> ind (grade _|_ SAT | diff, intel) """ independencies = Independencies() for variable in ( variables if isinstance(variables, (list, tuple)) else [variables] ): non_descendents = ( set(self.nodes()) - {variable} - set(nx.dfs_preorder_nodes(self, variable)) ) parents = set(self.get_parents(variable)) if non_descendents - parents: independencies.add_assertions( [variable, non_descendents - parents, parents] ) return independencies
def approximation(g): # n is the number of vertices. n = g.number_of_nodes() # You might want to use the function "nx.minimum_spanning_tree(g)" # which returns a Minimum Spanning Tree of the graph g # You also might want to use the command "list(nx.dfs_preorder_nodes(graph, 0))" # which gives a list of vertices of the given graph in depth-first preorder. msp = nx.minimum_spanning_tree(g) dfs_nodes = list(nx.dfs_preorder_nodes(msp, 0)) prev = -1 ans = 0 for node in dfs_nodes: if (prev == -1): prev = node else: ans += g[prev][node]['weight'] prev = node ans += g[prev][dfs_nodes[0]]['weight'] return ans
def findall(self, ntype, source='root', attr=None, val=None): """ finds all nodes in the tree of the type ntype starting at source with attribute attr (if set) having value val (if set) :param ntype: node type to find :param source: the source to start the search from :param attr: the attribute key the node will have :param val: the val that the given attribute key will have :return: a list of node ids """ if val and not attr: raise lts.LituusException(lts.ETREE, "attr required with val") found = [] for node in nx.dfs_preorder_nodes(self._t, source): if node_type(node) == ntype and not node == source: if attr: if attr in self._t.node[node]: if val: if self._t.node[node][attr] == val: found.append(node) else: if attr in self._t.node[nid]: found.append(node) else: found.append(node) return found
def unconstrained_bridge_augmentation(G): """Finds an optimal 2-edge-augmentation of G using the fewest edges. This is an implementation of the algorithm detailed in [1]_. The basic idea is to construct a meta-graph of bridge-ccs, connect leaf nodes of the trees to connect the entire graph, and finally connect the leafs of the tree in dfs-preorder to bridge connect the entire graph. Parameters ---------- G : NetworkX graph An undirected graph. Yields ------ edge : tuple Edges in the bridge augmentation of G Notes ----- Input: a graph G. First find the bridge components of G and collapse each bridge-cc into a node of a metagraph graph C, which is gaurenteed to be a forest of trees. C contains p "leafs" --- nodes with exactly one incident edge. C contains q "isolated nodes" --- nodes with no incident edges. Theorem: If p + q > 1, then at least :math:`ceil(p / 2) + q` edges are needed to bridge connect C. This algorithm achieves this min number. The method first adds enough edges to make G into a tree and then pairs leafs in a simple fashion. Let n be the number of trees in C. Let v(i) be an isolated vertex in the i-th tree if one exists, otherwise it is a pair of distinct leafs nodes in the i-th tree. Alternating edges from these sets (i.e. adding edges A1 = [(v(i)[0], v(i + 1)[1]), v(i + 1)[0], v(i + 2)[1])...]) connects C into a tree T. This tree has p' = p + 2q - 2(n -1) leafs and no isolated vertices. A1 has n - 1 edges. The next step finds ceil(p' / 2) edges to biconnect any tree with p' leafs. Convert T into an arborescence T' by picking an arbitrary root node with degree >= 2 and directing all edges away from the root. Note the implementation implicitly constructs T'. The leafs of T are the nodes with no existing edges in T'. Order the leafs of T' by DFS prorder. Then break this list in half and add the zipped pairs to A2. The set A = A1 + A2 is the minimum augmentation in the metagraph. To convert this to edges in the original graph References ---------- .. [1] Eswaran, Kapali P., and R. Endre Tarjan. (1975) Augmentation problems. http://epubs.siam.org/doi/abs/10.1137/0205044 See Also -------- :func:`bridge_augmentation` :func:`k_edge_augmentation` Example ------- >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7)) >>> sorted(unconstrained_bridge_augmentation(G)) [(1, 7)] >>> G = nx.path_graph((1, 2, 3, 2, 4, 5, 6, 7)) >>> sorted(unconstrained_bridge_augmentation(G)) [(1, 3), (3, 7)] >>> G = nx.Graph([(0, 1), (0, 2), (1, 2)]) >>> G.add_node(4) >>> sorted(unconstrained_bridge_augmentation(G)) [(1, 4), (4, 0)] """ # ----- # Mapping of terms from (Eswaran and Tarjan): # G = G_0 - the input graph # C = G_0' - the bridge condensation of G. (This is a forest of trees) # A1 = A_1 - the edges to connect the forest into a tree # leaf = pendant - a node with degree of 1 # alpha(v) = maps the node v in G to its meta-node in C # beta(x) = maps the meta-node x in C to any node in the bridge # component of G corresponding to x. # find the 2-edge-connected components of G bridge_ccs = list(nx.connectivity.bridge_components(G)) # condense G into an forest C C = collapse(G, bridge_ccs) # Choose pairs of distinct leaf nodes in each tree. If this is not # possible then make a pair using the single isolated node in the tree. vset1 = [ tuple(cc) * 2 # case1: an isolated node if len(cc) == 1 else sorted( cc, key=C.degree)[0:2] # case2: pair of leaf nodes for cc in nx.connected_components(C) ] if len(vset1) > 1: # Use this set to construct edges that connect C into a tree. nodes1 = [vs[0] for vs in vset1] nodes2 = [vs[1] for vs in vset1] A1 = list(zip(nodes1[1:], nodes2)) else: A1 = [] # Connect each tree in the forest to construct an arborescence T = C.copy() T.add_edges_from(A1) # If there are only two leaf nodes, we simply connect them. leafs = [n for n, d in T.degree() if d == 1] if len(leafs) == 1: A2 = [] if len(leafs) == 2: A2 = [tuple(leafs)] else: # Choose an arbitrary non-leaf root root = next(n for n, d in T.degree() if d > 1) # order the leaves of C by (induced directed) preorder v2 = [n for n in nx.dfs_preorder_nodes(T, root) if T.degree(n) == 1] # connecting first half of the leafs in pre-order to the second # half will bridge connect the tree with the fewest edges. half = int(math.ceil(len(v2) / 2.0)) A2 = list(zip(v2[:half], v2[-half:])) # collect the edges used to augment the original forest aug_tree_edges = A1 + A2 # Construct the mapping (beta) from meta-nodes to regular nodes inverse = defaultdict(list) for k, v in C.graph['mapping'].items(): inverse[v].append(k) # sort so we choose minimum degree nodes first inverse = { mu: sorted(mapped, key=lambda u: (G.degree(u), u)) for mu, mapped in inverse.items() } # For each meta-edge, map back to an arbitrary pair in the original graph G2 = G.copy() for mu, mv in aug_tree_edges: # Find the first available edge that doesn't exist and return it for u, v in it.product(inverse[mu], inverse[mv]): if not G2.has_edge(u, v): G2.add_edge(u, v) yield u, v break
def test_preorder_nodes(self): assert_equal(list(nx.dfs_preorder_nodes(self.G, source=0)), [0, 1, 2, 4, 3]) assert_equal(list(nx.dfs_preorder_nodes(self.D)), [0, 1, 2, 3])
def build_pipeline_graph(input: DataType, output: DataType, registry, max_list_depth=3, max_pipeline_width=3) -> "PipelineBuilder": """ Creates a `PipelineBuilder` instance that generates all pipelines from `input` to `output` types. ##### Parameters - `input`: type descriptor for the desired input. - `output`: type descriptor for the desired output. - `registry`: list of available classes to build the pipelines. """ # First we will unpack the input and output type and # store them in actual lists for easier use if isinstance(input, Tuple): input_type = list(input.inner) else: input_type = [input] if isinstance(output, Tuple): output_type = list(output.inner) else: output_type = [output] logger.info(f"input_type={input_type}") logger.info(f"output_type={output_type}") # Before starting, let's create all the List[T] wrappers up to # `max_list_depth` and add them to `registry`, so that they are available later for algorithm in list(registry): for _ in range(max_list_depth): algorithm = make_list_wrapper(algorithm) registry.append(algorithm) # We will also need an index to quickly find out which algorithms # accept each input type index = defaultdict(set) for algorithm in registry: types = _get_annotations(algorithm).input types = list(types.inner) if isinstance(types, Tuple) else [types] for t in types: index[t].add(algorithm) logger.info(f"Built algorithm index with {len(index)} entries and {len(registry)} total algorithms.") # The graph contains all the algorithms, each algorithm is connected # to all those nodes that it can process, which are nodes whose output # type is a superset of what the algorithm requires. G = Graph() # For each node stored in the graph, we will store also the full list # of all inputs and outputs that we can guarantee are available at this point. # Initially we add the `Start` node, which produces all of the inputs, # and the `End` node which consumes all the outputs. start_node = PipelineStart(input_type) end_node = PipelineEnd(output_type) G.add_edge(GraphSpace.Start, start_node) G.add_edge(end_node, GraphSpace.End) # We will apply a BFS algorithm at this point. We will make sure # that once a node is processed, all the algorithms to which it could # potentially connect are stored in the graph. # Initially the `Start` node is the only one open. open_nodes = [start_node] closed_nodes = set() while open_nodes: # This is the next node we will need to connect. node = open_nodes.pop(0) if node in closed_nodes: continue # When leaving this node we can guarantee that we have the types in this list. types = node.output logger.info(f"Processing node={node}") # We will need this method to check if all of the input types of and algorithm are # guaranteed at this point, i.e., if they are available in `types`, # or at least a conforming type is. def type_is_guaranteed(input_type): for other_type in types: if conforms(other_type, input_type): return True return False # In this point we have to identify all the algorithms that could continue # from this point on. These are all the algorithms whose input expects a subset # of the types that we already have. potential_algorithms = set() for t in types: potential_algorithms |= index[t] for algorithm in potential_algorithms: annotations = _get_annotations(algorithm) algorithm_input_types = list(annotations.input.inner) if isinstance(annotations.input, Tuple) else [annotations.input] algorithm_output_types = list(annotations.output.inner) if isinstance(annotations.output, Tuple) else [annotations.output] logger.info(f"Analyzing algorithm={algorithm.__name__} with inputs={algorithm_input_types} and outputs={algorithm_output_types}") if any(not type_is_guaranteed(input_type) for input_type in algorithm_input_types): logger.info(f"Skipping algorithm={algorithm.__name__}") continue # At this point we can add the current algorithm to the graph. # First, we make the current algorithm "consume" the input types, # hence, the output types produced at this point are the output types # this algorithm provides plus any input type not consumed so far. output_types = sorted(set([t for t in types if t not in algorithm_input_types] + algorithm_output_types), key=str) if len(output_types) > max_pipeline_width: continue # We add this node to the graph and we mark that it consumes the inputs, # so that later when sampling we can correctly align all the types. # When building the node, we can get a `ValueError` if the internal # grammar cannot be built; in that case, we simply skip it try: new_node = PipelineNode(algorithm=algorithm, input=types, output=output_types) G.add_node(new_node) G.add_edge(node, new_node) open_nodes.append(new_node) logger.info(f"Adding node={algorithm.__name__} producing types={output_types}") except ValueError as e: logger.warning(f"Node={algorithm.__name__} cannot be built. Error={e}.") # Let's check if we can add the `End` node. if all(type_is_guaranteed(t) for t in output_type): G.add_edge(node, end_node) logger.info("Connecting to end node") closed_nodes.add(node) # Once done we have to check if the `End` node was at some point included in the graph. # Otherwise that means there is no possible path. if GraphSpace.End not in G: raise TypeError( "No pipelines can be constructed from input:%r to output:%r." % (input, output) ) # Now we remove all nodes that don't participate in any path # leaving to `End` reachable_from_end = set(nx.dfs_preorder_nodes(G.reverse(False), GraphSpace.End)) unreachable_nodes = set(G.nodes) - reachable_from_end G.remove_nodes_from(unreachable_nodes) # If the node `Start` was removed, that means the graph is disconnected. if not GraphSpace.Start in G: raise TypeError( "No pipelines can be constructed from input:%r to output:%r." % (input, output) ) return PipelineBuilder(G, registry)
state_dict[(first_state_id, 'resource')], first_state_id) #This is not the ordered schedule but rather the roads cleared until this state cleared_roads = [i for i, val in enumerate(state_dict[(first_state_id, 'debris')]) if val == 0] Schedule.extend(cleared_roads) #G2 is the original graph whereas G_disrupted is the graph to be constructed with the cleared roads for cr in Schedule: ed = [edge for edge, edge_id in ActionList.items() if edge_id == cr][0] G2[ed[0]][ed[1]]['debris'] = 0 G_restored.add_edge(ed[0], ed[1]) reachable_nodes = [] #list for reachable nodes for s in supply_nodes: reachable_nodes.extend(list(nx.dfs_preorder_nodes(G_restored, s))) actions = funcs2.initializeActionSpace(reachable_nodes, G, ActionList) # actions are the admissable action indices corresponding in ActionList ############sas_vec.append(first_state.ID) while remaining_demand: #Choose action eligible_actions = actions - set(Schedule) action = random.choice(list(eligible_actions)) Schedule.append(action) ## Vertex collapse - condense the network #For large sized instances calculating sp can be hard try: betw_centrality_service[first_state.ID]
def aa_seq(self, order="dfs", train=True): mol_atoms_heavy = [a for a in self.atoms if a.type.mass >= 2.0] atom_seq_dict_heavy = {} atom_seq_dict_hydrogens = {} atom_predecessors_dict = {} cg_seq = self.cg_seq(order=order, train=train) for bead, predecessor_beads in cg_seq: bead_atoms = bead.atoms heavy_atoms = [a for a in bead_atoms if a.type.mass >= 2.0] hydrogens = [a for a in bead_atoms if a.type.mass < 2.0] predecessor_atoms = list(itertools.chain.from_iterable([b.atoms for b in set(predecessor_beads)])) predecessor_atoms_heavy = [a for a in predecessor_atoms if a.type.mass >= 2.0] predecessor_atoms_hydrogens = [a for a in predecessor_atoms if a.type.mass < 2.0] #find start atom psble_start_nodes = [] n_heavy_neighbors = [] for a in heavy_atoms: n_heavy_neighbors.append(len(list(nx.all_neighbors(self.G_heavy, a)))) for n in nx.all_neighbors(self.G_heavy, a): if n in predecessor_atoms_heavy: psble_start_nodes.append(a) if psble_start_nodes: #start_atom = np.random.choice(psble_start_nodes) #weird bonds in cg sPS... therefore just take first one... start_atom = psble_start_nodes[0] else: start_atom = heavy_atoms[np.array(n_heavy_neighbors).argmin()] #else: # start_atom = heavy_atoms[0] #sequence through atoms of bead if order == "bfs": edges = list(nx.bfs_edges(self.G.subgraph(heavy_atoms), start_atom)) atom_seq = [start_atom] + [e[1] for e in edges] elif order == "random": atom_seq = [start_atom] pool = [] for n in range(1, len(heavy_atoms)): pool += list(nx.neighbors(self.G.subgraph(heavy_atoms), atom_seq[-1])) pool = list(set(pool)) next = np.random.choice(pool) while next in atom_seq: next = np.random.choice(pool) pool.remove(next) atom_seq.append(next) else: atom_seq = list(nx.dfs_preorder_nodes(self.G.subgraph(heavy_atoms), start_atom)) #hydrogens = self.hydrogens[:] np.random.shuffle(hydrogens) #atom_seq = atom_seq + hydrogens #atom_seq = [] for n in range(0, len(atom_seq)): atom_predecessors_dict[atom_seq[n]] = predecessor_atoms_heavy + atom_seq[:n] for n in range(0, len(hydrogens)): atom_predecessors_dict[hydrogens[n]] = mol_atoms_heavy + predecessor_atoms_hydrogens + hydrogens[:n] atom_seq_dict_heavy[bead] = atom_seq atom_seq_dict_hydrogens[bead] = hydrogens return cg_seq, atom_seq_dict_heavy, atom_seq_dict_hydrogens, atom_predecessors_dict
def solve(G): """ Idea for solve method below: is to basically find shortest paths (via Dijkstras) between each pair of vertices within the dominating set. Put all the vertices within the dominating set into a new graph G_prime, and add edges between each pair of vertices. Introduce new vertices into the graph as necessary to ensure connectivity. In the end, return the MST of G_prime. Also calls extra-vertex-optimization in the end. Args: G: networkx.Graph Returns: T: networkx.Graph """ # TODO: your code here! dominatingSet = min_weighted_dominating_set(G, weight="weight") # The variable defined below, apsp, stands for all pairs shortest paths from calling NetworkX built-in Dijkstra's algorithm. apsp = dict( nx.algorithms.shortest_paths.weighted.all_pairs_dijkstra( G, weight="weight")) # G_prime, the new graph below, shall consist of all vertices within the dominating set along with their shortest path edge weights in # between, bringing in new vertices as necessary. G_prime = nx.Graph() G.add_nodes_from(dominatingSet) # Vertices to add contains new vertices which must be added into graph G prime in order to ensure connectivity of nodes from min # dominating set. extra_vertices = set() for node in dominatingSet: for node2 in dominatingSet: shortest_path = apsp[node][1][node2] # First, identify new vertices to be thrown into G prime. for vertex in shortest_path: if vertex not in dominatingSet: G_prime.add_node( vertex ) # I do believe from my Internet search that duplicate nodes has no effect extra_vertices.add( vertex ) # Keep track of the list of all vertices within the dominating set # Next, identify new edges to be thrown into G prime. Adding edges more than once has no effect. for i in range(len(shortest_path) - 1): origin_vertex = shortest_path[i] terminus_vertex = shortest_path[i + 1] w = G.get_edge_data(origin_vertex, terminus_vertex)['weight'] G_prime.add_edge(origin_vertex, terminus_vertex, weight=w) final_edges = list( nx.minimum_spanning_edges(G_prime, algorithm='kruskal', weight='weight', keys=True, data=True, ignore_nan=False)) T = nx.Graph() T.add_nodes_from(dominatingSet) T.add_nodes_from(extra_vertices) T.add_edges_from(final_edges) current_average = average_pairwise_distance(T) last_average = 4000 print(current_average) # Until adding more edges doesn't improve the average pairwise cost while current_average < last_average: last_average = current_average # For every node in T for node in nx.dfs_preorder_nodes(T, source=list(T.nodes)[0]): neighbors = nx.algorithms.traversal.breadth_first_search.bfs_tree( G, node, reverse=False, depth_limit=1) # Get one of its neighbors NOT in T for node2 in neighbors: # and add the edge between that vertex and its neighbor # if it decreases the average pairwise cost. if node2 not in T and G.get_edge_data(node, node2)\ and G[node][node2]['weight'] < current_average: T.add_node(node2) T.add_edge(node, node2, weight=G.get_edge_data(node, node2)['weight']) new_average = average_pairwise_distance(T) if new_average > current_average: T.remove_node(node2) #T.remove_edge(node, node2) else: current_average = new_average print("Adding an edge between", node, "and", node2, "yields average", new_average) print("Dominating vertices:", [node for node in T]) return T
def nodeatk(self, graph_org, centrality, wt): graph = graph_org.copy() ncc2flag = 0 criticaln = 0 criticallcc = 0 sf2 = 0 efr2 = 0 ###### initilization tempcc = [len(xind) for xind in nx.weakly_connected_components(graph)] lcc = [max(tempcc)] # largest connected component ncc = [len(tempcc)] # no. of connected comp. sf = [self.resoutput.get_servicefactor(graph)] # service factor efr = [self.resoutput.get_edgerobustness(graph)] # edge flow robust while (len(graph.nodes) > 2): if centrality == "out degree": nodeimpscore = dict(graph.out_degree(weight=wt)) else: nodeimpscore = nx.betweenness_centrality(graph, weight=wt) nodeselected = max(nodeimpscore, key=nodeimpscore.get) recchildnodes = list(nx.dfs_preorder_nodes(graph, nodeselected)) recchildnodes.remove(nodeselected) ##### node removal at primary level graph.remove_node(nodeselected) #### effect of input on output- transitive property for childnode in recchildnodes: indeg = graph.in_degree(childnode, weight="weight") try: tempratio = indeg / graph.nodes[childnode]['indegwt'] except: continue for (nodest, nodeed) in graph.edges(childnode): graph[nodest][nodeed]['weight'] = tempratio * ( graph[nodest][nodeed]['weight']) ##### node removal at secondary level # if indeg ==0: # graph.remove_node(childnode) ### collect metrics tempcc = [ len(xind) for xind in nx.weakly_connected_components(graph) ] lcc.append(max(tempcc)) ncc.append(len(tempcc)) if len(graph.edges()) > 1: tempefr = self.resoutput.get_edgerobustness(graph) tempsf = self.resoutput.get_servicefactor(graph) sf.append(tempsf) efr.append(tempefr) ####### critical values when graph gets disconnected into 2 components first time if len(tempcc) == 2 and ncc2flag == 0: ncc2flag = 1 criticaln = len(lcc) criticallcc = max(tempcc) sf2 = tempsf efr2 = tempefr return lcc, ncc, sf, efr, criticaln, criticallcc, sf2, efr2
def get_nodeattack(graph_org): criticaln = 0 criticallcc = 0 sf2 = 0 efr2 = 0 ncc2flag = 0 graph = graph_org.copy() tempcc = [ len(xind) for xind in nx.weakly_connected_components(graph) ] lcc = [max(tempcc)] # largest connected component ncc = [len(tempcc)] # no. of connected comp. sf = [self.resoutput.get_servicefactor(graph)] # service factor efr = [self.resoutput.get_edgerobustness(graph) ] # edge flow robust while (len(graph.nodes) > 2): nodeselected = np.random.choice(graph.nodes()) recchildnodes = list(nx.dfs_preorder_nodes( graph, nodeselected)) recchildnodes.remove(nodeselected) ##### node removal at primary level graph.remove_node(nodeselected) #### effect of input on output- transitive property for childnode in recchildnodes: indeg = graph.in_degree(childnode, weight="weight") try: tempratio = indeg / graph.nodes[childnode]['indegwt'] except: continue for (nodest, nodeed) in graph.edges(childnode): graph[nodest][nodeed]['weight'] = tempratio * ( graph[nodest][nodeed]['weight']) ##### node removal at secondary level # if indeg ==0: # graph.remove_node(childnode) #### collecting metrics tempcc = [ len(xind) for xind in nx.weakly_connected_components(graph) ] try: lcc.append(max(tempcc)) except: break ncc.append(len(tempcc)) if len(graph.edges()) > 1: tempsf = self.resoutput.get_servicefactor(graph) tempefr = self.resoutput.get_edgerobustness(graph) sf.append(tempsf) efr.append(tempefr) ####### critical values when graph gets disconnected into 2 components first time if len(tempcc) == 2 and ncc2flag == 0: ncc2flag = 1 criticaln = len(lcc) criticallcc = max(tempcc) sf2 = tempsf efr2 = tempefr return lcc, ncc, sf, efr, criticaln, criticallcc, sf2, efr2
def maximal_cliques(self): """ return the list of maximal cliques in the model """ #return list(self.tree.nodes()) return list(nx.dfs_preorder_nodes(self.tree))
def _reproduce_stages(G, stages, node, downstream=False, ignore_build_cache=False, **kwargs): r"""Derive the evaluation of the given node for the given graph. When you _reproduce a stage_, you want to _evaluate the descendants_ to know if it make sense to _recompute_ it. A post-ordered search will give us an order list of the nodes we want. For example, let's say that we have the following pipeline: E / \ D F / \ \ B C G \ / A The derived evaluation of D would be: [A, B, C, D] In case that `downstream` option is specifed, the desired effect is to derive the evaluation starting from the given stage up to the ancestors. However, the `networkx.ancestors` returns a set, without any guarantee of any order, so we are going to reverse the graph and use a pre-ordered search using the given stage as a starting point. E A / \ / \ D F B C G / \ \ --- reverse --> \ / / B C G D F \ / \ / A E The derived evaluation of _downstream_ B would be: [B, D, E] """ import networkx as nx if downstream: # NOTE (py3 only): # Python's `deepcopy` defaults to pickle/unpickle the object. # Stages are complex objects (with references to `repo`, `outs`, # and `deps`) that cause struggles when you try to serialize them. # We need to create a copy of the graph itself, and then reverse it, # instead of using graph.reverse() directly because it calls # `deepcopy` underneath -- unless copy=False is specified. pipeline = nx.dfs_preorder_nodes(G.copy().reverse(copy=False), node) else: pipeline = nx.dfs_postorder_nodes(G, node) result = [] for n in pipeline: try: ret = _reproduce_stage(stages, n, **kwargs) if len(ret) != 0 and ignore_build_cache: # NOTE: we are walking our pipeline from the top to the # bottom. If one stage is changed, it will be reproduced, # which tells us that we should force reproducing all of # the other stages down below, even if their direct # dependencies didn't change. kwargs["force"] = True result += ret except Exception as ex: raise ReproductionError(stages[n].relpath, ex) return result
import networkx as nx import scipy.io as sc import matplotlib.pyplot as plt A = nx.read_edgelist('test.edges') nx.draw(A) plt.draw() #plt.show() firstNode = nx.nodes(A)[0] print firstNode dfs_list = list(nx.dfs_preorder_nodes(A, firstNode)) for node in dfs_list: print 'node:', node
def generar_grafo(nombre_artista): G = nx.DiGraph() # agegar nodos (26) G.add_node("Ava Max") G.add_node("Dua Lipa") G.add_node("Melanie Martinez") G.add_node("Little Mix") G.add_node("Lady Gaga") G.add_node("Bebe Rexha") G.add_node("Camila Cabello") G.add_node("Anne Marie") G.add_node("Ariana Grande") G.add_node("Halsey") G.add_node("Zara Larsson") G.add_node("Sabrina Carpenter") G.add_node("Demi Lovato") G.add_node("Bea Miller") G.add_node("Hailee Steinfeld") G.add_node("Meghan Trainor") G.add_node("Clean Bandit") G.add_node("5SOS") G.add_node("MGK") G.add_node("Jonas Brothers") G.add_node("Sam Smith") G.add_node("Sia") G.add_node("Diplo") G.add_node("Zedd") G.add_node("Charlotte Lawrence") G.add_node("Doja Cat") #print ("Nodos: ", G.nodes()) #Agregar aristas G.add_edge("Camila Cabello","5SOS") G.add_edge("Camila Cabello","Clean Bandit") G.add_edge("Dua Lipa","Anne Marie") G.add_edge("Dua Lipa","Camila Cabello") G.add_edge("5SOS","Diplo") G.add_edge("Halsey","Lady Gaga") G.add_edge("Halsey","Dua Lipa") G.add_edge("Halsey","Ava Max") G.add_edge("Halsey","Sia") G.add_edge("Sia","MGK") G.add_edge("Sia","Melanie Martinez") G.add_edge("Diplo","Halsey") G.add_edge("Diplo","Doja Cat") G.add_edge("Melanie Martinez","Halsey") G.add_edge("Melanie Martinez","Ariana Grande") G.add_edge("Demi Lovato","Melanie Martinez") G.add_edge("Demi Lovato","Sam Smith") G.add_edge("Lady Gaga","Demi Lovato") G.add_edge("Lady Gaga","Bea Miller") G.add_edge("Lady Gaga","MGK") G.add_edge("Lady Gaga","Zedd") G.add_edge("Lady Gaga","Anne Marie") G.add_edge("Bea Miller","Meghan Trainor") G.add_edge("Bea Miller","Little Mix") G.add_edge("Ava Max","Bebe Rexha") G.add_edge("Zara Larsson","Zedd") G.add_edge("Zedd", "Sia") G.add_edge("Clean Bandit", "Doja Cat") G.add_edge("Clean Bandit", "Ava Max") G.add_edge("Little Mix", "Zara Larsson") G.add_edge("Little Mix", "Meghan Trainor") G.add_edge("Little Mix", "Sabrina Carpenter") G.add_edge("Meghan Trainor", "Dua Lipa") G.add_edge("Sabrina Carpenter", "Doja Cat") G.add_edge("Sabrina Carpenter", "Charlotte Lawrence") G.add_edge("Hailee Steinfeld", "Little Mix") G.add_edge("Doja Cat", "Lady Gaga") G.add_edge("Charlotte Lawrence", "Zara Larsson") G.add_edge("Ariana Grande", "Sam Smith") G.add_edge("Sam Smith", "Charlotte Lawrence") G.add_edge("Bebe Rexha", "Hailee Steinfeld") G.add_edge("Bebe Rexha", "Meghan Trainor") G.add_edge("Bebe Rexha", "Ariana Grande") G.add_edge("Jonas Brothers", "5SOS") G.add_edge("Anne Marie", "Jonas Brothers") G.add_edge("MGK", "Anne Marie") G.add_edge("MGK", "Jonas Brothers") G.add_edge("MGK", "5SOS") #Orden DFS del grafo return (list(nx.dfs_preorder_nodes(G,nombre_artista)))
def linkatk(self, graph_org, centrality, wt, dfact): graph = graph_org.copy() ncc2flag = 0 criticaln = 0 criticallcc = 0 sf2 = 0 efr2 = 0 for u, v, w in graph.edges(data=True): graph[u][v]['newweight'] = w['weight'] ##### initialization tempcc = [len(xind) for xind in nx.weakly_connected_components(graph)] lcc = [max(tempcc)] # largest connected component ncc = [len(tempcc)] # no. of connected comp. sf = [self.resoutput.get_servicefactor(graph)] # service factor efr = [self.resoutput.get_edgerobustness(graph)] # edge flow robust while (len(graph.edges) > 1): ranks = centrality(graph, weight=wt) edges_sorted = sorted(graph.edges(), key=lambda n: ranks[n], reverse=True) # sorts in descending edge_selected = edges_sorted[0] nodeinc = edge_selected[1] recchildnodes = list(nx.dfs_preorder_nodes(graph, nodeinc)) graph[edge_selected[0]][edge_selected[1]]['newweight'] = graph[ edge_selected[0]][edge_selected[1]]['newweight'] - 0.1 ##### comparing weights with service acceptable level if graph[edge_selected[0]][ edge_selected[1]]['newweight'] < dfact * ( graph[edge_selected[0]][edge_selected[1]]['weight']): graph.remove_edge(*edge_selected) #### effect of input on output- transitive property for childnode in recchildnodes: indeg = graph.in_degree(childnode, weight="newweight") try: tempratio = indeg / graph.nodes[childnode]['indegwt'] except: continue for (nodest, nodeed) in graph.edges(childnode): graph[nodest][nodeed]['newweight'] = tempratio * ( graph[nodest][nodeed]['newweight']) ##### node removal at secondary level # if indeg ==0: # graph.remove_node(childnode) else: #### effect of input on output- transitive property for childnode in recchildnodes: indeg = graph.in_degree(childnode, weight="newweight") try: tempratio = indeg / graph.nodes[childnode]['indegwt'] except: continue for (nodest, nodeed) in graph.edges(childnode): graph[nodest][nodeed]['newweight'] = tempratio * ( graph[nodest][nodeed]['newweight']) ##### node removal at secondary level # if indeg ==0: # graph.remove_node(childnode) ##### collecting metrics tempcc = [ len(xind) for xind in nx.weakly_connected_components(graph) ] lcc.append(max(tempcc)) ncc.append(len(tempcc)) tempsf = self.resoutput.get_servicefactor(graph) sf.append(tempsf) if len(graph.edges()) > 1: tempefr = self.resoutput.get_edgerobustness(graph) efr.append(tempefr) ####### critical values when graph disconnected into 2 components first time if len(tempcc) == 2 and ncc2flag == 0: ncc2flag = 1 criticaln = len(lcc) criticallcc = max(tempcc) sf2 = tempsf efr2 = tempefr return lcc, ncc, sf, efr, criticaln, criticallcc, sf2, efr2
def build_pipelines(input, output, registry) -> "PipelineBuilder": """ Creates a `PipelineBuilder` instance that generates all pipelines from `input` to `output` types. ##### Parameters - `input`: type descriptor for the desired input. - `output`: type descriptor for the desired output. - `registry`: list of available classes to build the pipelines. """ # warnings.warn( # "This method is deprecated and not under use by AutoGOAL's" # " internal API anymore, use `build_pipeline_graph` instead.", # category=DeprecationWarning, # stacklevel=2, # ) list_pairs = set() types_queue = [] if isinstance(input, Tuple): types_queue.extend(input.inner) else: types_queue.append(input) if isinstance(output, Tuple): types_queue.extend(output.inner) else: types_queue.append(output) types_seen = set() while types_queue: output_type = types_queue.pop(0) def build(internal_output, depth): if internal_output in types_seen: return for other_clss in registry: annotations = _get_annotations(other_clss) if annotations in list_pairs: continue other_input = annotations.input other_output = annotations.output if other_input == other_output: continue if not conforms(internal_output, other_input): continue other_wrapper = build_composite_list(other_input, other_output, depth) list_pairs.add(annotations) registry.append(other_wrapper) types_queue.append(_get_annotations(other_wrapper).output) depth = 0 while isinstance(output_type, List): if output_type.depth() >= MAX_LIST_DEPTH: break depth += 1 output_type = output_type.inner build(output_type, depth) types_seen.add(output_type) logger.debug("Output type", output_type) list_tuples = set() def connect_tuple_wrappers(node, output_type): if not isinstance(output_type, Tuple): return for index in range(0, len(output_type.inner)): internal_input = output_type.inner[index] for other_clss in registry: annotations = _get_annotations(other_clss) other_input = annotations.input if not (conforms(internal_input, other_input) and other_clss != node): continue # `other_class` has input compatible with one element in the Tuple # build the output `Tuple[..., internal_output, ...]` of the wrapper class internal_output = annotations.output output_tuple = list(output_type.inner) output_tuple[index] = internal_output output_tuple_type = Tuple(*output_tuple) # dynamic class representing the wrapper algorithm if (index, output_type, output_tuple_type) in list_tuples: continue other_wrapper = build_composite_tuple( index, output_type, output_tuple_type ) list_tuples.add((index, output_type, output_tuple_type)) registry.append(other_wrapper) open_nodes.append(other_wrapper) G.add_edge(node, other_wrapper) G = Graph() open_nodes = [] closed_nodes = set() # Enqueue open nodes for clss in registry: if conforms(input, _get_annotations(clss).input): open_nodes.append(clss) G.add_edge(GraphSpace.Start, clss) connect_tuple_wrappers(GraphSpace.Start, input) if GraphSpace.Start not in G: raise TypeError("There are no classes compatible with input type:%r." % input) while open_nodes: clss = open_nodes.pop(0) if clss in closed_nodes: continue closed_nodes.add(clss) output_type = _get_annotations(clss).output for other_clss in registry: other_input = _get_annotations(other_clss).input if conforms(output_type, other_input) and other_clss != clss: open_nodes.append(other_clss) G.add_edge(clss, other_clss) connect_tuple_wrappers(clss, output_type) if conforms(output_type, output): G.add_edge(clss, GraphSpace.End) if GraphSpace.End not in G: raise TypeError( "No pipelines can be constructed from input:%r to output:%r." % (input, output) ) reachable_from_end = set(nx.dfs_preorder_nodes(G.reverse(False), GraphSpace.End)) unreachable_nodes = set(G.nodes) - reachable_from_end G.remove_nodes_from(unreachable_nodes) if not GraphSpace.Start in G: raise TypeError( "No pipelines can be constructed from input:%r to output:%r." % (input, output) ) return PipelineBuilder(G, registry)
def leaves_subtended_by(self): return { v: self.leaves & set(nx.dfs_preorder_nodes(self, v)) for v in self }
def domain_view(multi_graph: nx.MultiDiGraph, root_domain: str) -> nx.MultiDiGraph: """Returns the subgraph rooted at the given domain.""" return multi_graph.subgraph(nx.dfs_preorder_nodes(multi_graph, root_domain))
cond_mnem2 = [('\x0f' + chr(x)) for x in range(0x80, 0x90)] uncond_mnem1 = [0xe9, 0xeb, 0xc3] uncond_mnem2 = ['\xff\x04', '\xff\x05'] for n in nodes: if n.id != None: if ord(n.code[-1]) in uncond_mnem1 or (len(n.code) > 1 and n.code[-2:] in uncond_mnem2): conditional[n.id] = False elif ord(n.code[-1]) in cond_mnem1 or (len(n.code) > 1 and n.code[-2:] in cond_mnem2): conditional[n.id] = True else: conditional[n.id] = True trav = nx.dfs_preorder_nodes(g, 0) chains = [] visited = set() # gather all contiguous pieces: "chains" of blocks for t in trav: chain = [] if t in visited: continue c = t while True: #print c if c in visited: idxs = filter(lambda i: chains[i][0] == c, range(len(chains)))
l = len(file) pos = np.zeros((l, 3)) rotM = np.zeros((l, 3, 3)) quat = np.zeros((l, 4)) for i, line in enumerate(file): line_list = line.split() pos[i] = np.array(line_list[1:4]) quat[i] = np.array(line_list[4:]) r = R.from_quat(quat[i]) rotM[i] = r.as_matrix().copy() clf = NearestNeighbors(2).fit(pos) G = clf.kneighbors_graph() T = nx.from_scipy_sparse_matrix(G) paths = [list(nx.dfs_preorder_nodes(T, i)) for i in range(len(pos))] mindist = np.inf minidx = 0 for i in range(len(pos)): p = paths[i] # order of nodes ordered = pos[p] # ordered nodes # find cost of that order by the sum of euclidean distances between points (i) and (i+1) cost = (((ordered[:-1] - ordered[1:])**2).sum(1)).sum() if cost < mindist: mindist = cost minidx = i opt_order = paths[minidx] posop = pos[opt_order]