def test_white_harary_paper(): # Figure 1b white and harary (2001) # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF # A graph with high adhesion (edge connectivity) and low cohesion # (node connectivity) G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.remove_node(7) for i in range(4, 7): G.add_edge(0, i) G = nx.disjoint_union(G, nx.complete_graph(4)) G.remove_node(G.order() - 1) for i in range(7, 10): G.add_edge(0, i) for flow_func in flow_funcs: kwargs = dict(flow_func=flow_func) errmsg = f"Assertion failed in function: {flow_func.__name__}" # edge cuts edge_cut = nx.minimum_edge_cut(G, **kwargs) assert 3 == len(edge_cut), errmsg H = G.copy() H.remove_edges_from(edge_cut) assert not nx.is_connected(H), errmsg # node cuts node_cut = nx.minimum_node_cut(G, **kwargs) assert {0} == node_cut, errmsg H = G.copy() H.remove_nodes_from(node_cut) assert not nx.is_connected(H), errmsg
def test_white_harary_paper(): # Figure 1b white and harary (2001) # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF # A graph with high adhesion (edge connectivity) and low cohesion # (node connectivity) G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.remove_node(7) for i in range(4, 7): G.add_edge(0, i) G = nx.disjoint_union(G, nx.complete_graph(4)) G.remove_node(G.order() - 1) for i in range(7, 10): G.add_edge(0, i) for flow_func in flow_funcs: kwargs = dict(flow_func=flow_func) # edge cuts edge_cut = nx.minimum_edge_cut(G, **kwargs) assert_equal(3, len(edge_cut), msg=msg.format(flow_func.__name__)) H = G.copy() H.remove_edges_from(edge_cut) assert_false(nx.is_connected(H), msg=msg.format(flow_func.__name__)) # node cuts node_cut = nx.minimum_node_cut(G, **kwargs) assert_equal(set([0]), node_cut, msg=msg.format(flow_func.__name__)) H = G.copy() H.remove_nodes_from(node_cut) assert_false(nx.is_connected(H), msg=msg.format(flow_func.__name__))
def process(self, batch, request): outputs = gp.Batch() gt_graph = nx.Graph() mst_graph = nx.Graph() for block, block_specs in self.specs.items(): ground_truth_key = block_specs["ground_truth"][0] mst_key = block_specs["mst_pred"][0] block_gt_graph = batch[ground_truth_key].to_nx_graph( ).to_undirected() block_mst_graph = batch[mst_key].to_nx_graph().to_undirected() gt_graph = nx.disjoint_union(gt_graph, block_gt_graph) mst_graph = nx.disjoint_union(mst_graph, block_mst_graph) for node, attrs in gt_graph.nodes.items(): attrs["id"] = node for node, attrs in mst_graph.nodes.items(): attrs["id"] = node outputs[self.gt] = gp.Graph.from_nx_graph( gt_graph, gp.GraphSpec(roi=gp.Roi((None, ) * 3, (None, ) * 3), directed=False)) outputs[self.mst] = gp.Graph.from_nx_graph( mst_graph, gp.GraphSpec(roi=gp.Roi((None, ) * 3, (None, ) * 3), directed=False), ) return outputs
def graph_example_1(): G = nx.convert_node_labels_to_integers(nx.grid_graph([5, 5]), label_attribute='labels') rlabels = nx.get_node_attributes(G, 'labels') labels = {v: k for k, v in rlabels.items()} for nodes in [(labels[(0, 0)], labels[(1, 0)]), (labels[(0, 4)], labels[(1, 4)]), (labels[(3, 0)], labels[(4, 0)]), (labels[(3, 4)], labels[(4, 4)])]: new_node = G.order() + 1 # Petersen graph is triconnected P = nx.petersen_graph() G = nx.disjoint_union(G, P) # Add two edges between the grid and P G.add_edge(new_node + 1, nodes[0]) G.add_edge(new_node, nodes[1]) # K5 is 4-connected K = nx.complete_graph(5) G = nx.disjoint_union(G, K) # Add three edges between P and K5 G.add_edge(new_node + 2, new_node + 11) G.add_edge(new_node + 3, new_node + 12) G.add_edge(new_node + 4, new_node + 13) # Add another K5 sharing a node G = nx.disjoint_union(G, K) nbrs = G[new_node + 10] G.remove_node(new_node + 10) for nbr in nbrs: G.add_edge(new_node + 17, nbr) G.add_edge(new_node + 16, new_node + 5) G.name = 'Example graph for connectivity' return G
def generate_map(map_size, dim_of_bases, num_bases, buff_size, buff_E, size_connectors): main = Map.generate_delaunay_main(map_size) full_G = main player_pos = {0: 'N', 1: 'S', 2: 'E', 3: 'W'} for player in range(num_bases): player_base = Map.generate_base(dim_of_bases, dim_of_bases, player, player_pos[player]) player_buffer = Map.generate_buffer_zone(buff_size, buff_E, player, player_pos[player]) full_base = nx.disjoint_union(player_base, player_buffer) full_G = nx.disjoint_union(full_G, full_base) data_nodes = {} data_nodes['main'] = [] data_nodes['base_1'] = [] data_nodes['base_2'] = [] data_nodes['base_3'] = [] data_nodes['base_0'] = [] data_nodes['buff_1'] = [] data_nodes['buff_2'] = [] data_nodes['buff_3'] = [] data_nodes['buff_0'] = [] for node in full_G.nodes(): node_type = full_G.node[node]['type'] if node_type == 'main': data_nodes['main'].append(node) for i in range(4): if node_type == ('base', i): data_nodes['base_' + str(i)].append(node) if node_type == ('buffer', i): data_nodes['buff_' + str(i)].append(node) return full_G, data_nodes
def from_cr(cls, cr, HASH): _rdkit_config = rdkit_config(reaction_center=cr.ReactingAtomsMN, reactant_or_product='reactant') reaction = HashGraph.from_rdkit(cr.reactants[0], '1', _rdkit_config).to_networkx() for reactant in cr.reactants[1:]: g = HashGraph.from_rdkit(reactant, '1', _rdkit_config).\ to_networkx() reaction = nx.disjoint_union(reaction, g) _rdkit_config = rdkit_config(reaction_center=cr.ReactingAtomsMN, reactant_or_product='product') for product in cr.products: g = HashGraph.from_rdkit(product, '1', _rdkit_config).\ to_networkx() reaction = nx.disjoint_union(reaction, g) g = _from_networkx(cls, reaction) g.hash = HASH if g.nodes.to_pandas()['ReactingCenter'].max() <= 0: raise RuntimeError(f'No reacting atoms are found in reactants: ' f'{cr.reaction_smarts}') if g.nodes.to_pandas()['ReactingCenter'].min() >= 0: raise RuntimeError(f'No reacting atoms are found in products: ' f'{cr.reaction_smarts}') return g
def from_reaction_template(cls, template_smarts): template = ReactionTemplate(template_smarts) _rdkit_config = rdkit_config(reaction_center=template.ReactingAtomsMN, reactant_or_product='reactant', IsSanitized=False, set_morgan_identifier=False) reaction = Graph.from_rdkit(template.reactants[0], _rdkit_config).to_networkx() for reactant in template.reactants[1:]: g = Graph.from_rdkit(reactant, _rdkit_config).to_networkx() reaction = nx.disjoint_union(reaction, g) _rdkit_config = rdkit_config(reaction_center=template.ReactingAtomsMN, reactant_or_product='product', IsSanitized=False, set_morgan_identifier=False) for product in template.products: g = Graph.from_rdkit(product, _rdkit_config).to_networkx() reaction = nx.disjoint_union(reaction, g) g = _from_networkx(cls, reaction) if g.nodes.to_pandas()['ReactingCenter'].max() <= 0: raise RuntimeError(f'No reacting atoms are found in reactants: ' f'{template_smarts}') if g.nodes.to_pandas()['ReactingCenter'].min() >= 0: raise RuntimeError(f'No reacting atoms are found in products: ' f'{template_smarts}') return g
def atlas6(): """ Return the atlas of all connected graphs of 6 nodes or less. Attempt to check for isomorphisms and remove. """ Atlas = graph_atlas_g()[0:208] # 208 # remove isolated nodes, only connected graphs are left U = nx.Graph() # graph for union of all graphs in atlas for G in Atlas: zerodegree = [n for n in G if G.degree(n) == 0] for n in zerodegree: G.remove_node(n) U = nx.disjoint_union(U, G) # list of graphs of all connected components C = nx.connected_component_subgraphs(U) UU = nx.Graph() # do quick isomorphic-like check, not a true isomorphism checker nlist = [] # list of nonisomorphic graphs for G in C: # check against all nonisomorphic graphs so far if not iso(G, nlist): nlist.append(G) UU = nx.disjoint_union(UU, G) # union the nonisomorphic graphs return UU
def __generate_motifs__(x=208): """ Return the atlas of all connected graphs of 5 nodes or less. Uses networkx graph atlas, which returns all possible graphs with up to 7 nodes, based on https://networkx.github.io/documentation/stable/auto_examples/drawing/plot_atlas.html Parameters: x (int): which motifs of the graph atlas are returned Returns: graph atlas: contains all possible graphs of specified size as shown in the graph atlas """ #uses networkx graph atlas, which returns all possible graphs with up to 6 nodes #based on https://networkx.github.io/documentation/stable/auto_examples/drawing/plot_atlas.html Atlas = graph_atlas_g()[0:x] # remove isolated nodes, only connected graphs are left U = nx.Graph() # graph for union of all graphs in atlas for G in Atlas: zerodegree = [n for n in G if G.degree(n) == 0] for n in zerodegree: G.remove_node(n) U = nx.disjoint_union(U, G) # list of graphs of all connected components C = (U.subgraph(c) for c in nx.connected_components(U)) UU = nx.Graph() # do quick isomorphic-like check, not a true isomorphism checker nlist = [] # list of nonisomorphic graphs for G in C: # check against all nonisomorphic graphs so far if not __iso__(G, nlist): nlist.append(G) UU = nx.disjoint_union(UU, G) # union the nonisomorphic graphs return UU
def test_white_harary_paper(): # Figure 1b white and harary (2001) # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF # A graph with high adhesion (edge connectivity) and low cohesion # (node connectivity) G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.remove_node(7) for i in range(4,7): G.add_edge(0,i) G = nx.disjoint_union(G, nx.complete_graph(4)) G.remove_node(G.order()-1) for i in range(7,10): G.add_edge(0,i) for flow_func in flow_funcs: kwargs = dict(flow_func=flow_func) # edge cuts edge_cut = nx.minimum_edge_cut(G, **kwargs) assert_equal(3, len(edge_cut), msg=msg.format(flow_func.__name__)) H = G.copy() H.remove_edges_from(edge_cut) assert_false(nx.is_connected(H), msg=msg.format(flow_func.__name__)) # node cuts node_cut = nx.minimum_node_cut(G, **kwargs) assert_equal(set([0]), node_cut, msg=msg.format(flow_func.__name__)) H = G.copy() H.remove_nodes_from(node_cut) assert_false(nx.is_connected(H), msg=msg.format(flow_func.__name__))
def _crossover(self, ga, gb): gs = [] ga = nx.convert_node_labels_to_integers(ga) gb = nx.convert_node_labels_to_integers(gb) edges_a = self._get_valid_edges(ga, max_num=self.n_edges) edges_b = self._get_valid_edges(gb, max_num=self.n_edges) for ea in edges_a: for eb in edges_b: if ea is not None and eb is not None: ia, ja = ea ib, jb = eb ibu, jbu = ib + len(ga), jb + len(ga) gu0 = nx.disjoint_union(ga, gb) self._swap_edge(gu0, (ia, ja), (ibu, jbu), mode=0) components = list(nx.connected_components(gu0)) gs.extend([ nx.subgraph(gu0, component).copy() for component in components ]) gu1 = nx.disjoint_union(ga, gb) self._swap_edge(gu1, (ia, ja), (ibu, jbu), mode=1) components = list(nx.connected_components(gu1)) gs.extend([ nx.subgraph(gu1, component).copy() for component in components ]) return gs
def _init_graph(self, p1, p2): """ Returns an Apex Bridge graph where the first cluster is sampled from G(self._n1, P1) and the second sampled from G(self._n2, P2). """ # Create a graph with only the apex apex_graph = nx.Graph() apex_graph.add_node(self._apex) # Create a graph with only the bridge bridge_graph = nx.Graph() bridge_graph.add_node(self._bridge) # Create the two cluster graphs g1 = nx.erdos_renyi_graph(self._n1, p1) g2 = nx.erdos_renyi_graph(self._n2, p2) # Create the final graph g = nx.disjoint_union(apex_graph, g1) g = nx.disjoint_union(g, g2) g = nx.disjoint_union(g, bridge_graph) # Connect the apex and bridge nodes for v in range(1, self._bridge + 1): g.add_edge(self._apex, v) # Connect the bridge to the two communities for v in self._cluster1: g.add_edge(self._bridge, v) for v in self._cluster2: g.add_edge(self._bridge, v) return g
def test_union_and_compose(): K3 = nx.complete_graph(3) P3 = nx.path_graph(3) G1 = nx.DiGraph() G1.add_edge('A', 'B') G1.add_edge('A', 'C') G1.add_edge('A', 'D') G2 = nx.DiGraph() G2.add_edge('1', '2') G2.add_edge('1', '3') G2.add_edge('1', '4') G = nx.union(G1, G2) H = nx.compose(G1, G2) assert_edges_equal(G.edges(), H.edges()) assert not G.has_edge('A', 1) pytest.raises(nx.NetworkXError, nx.union, K3, P3) H1 = nx.union(H, G1, rename=('H', 'G1')) assert (sorted(H1.nodes()) == [ 'G1A', 'G1B', 'G1C', 'G1D', 'H1', 'H2', 'H3', 'H4', 'HA', 'HB', 'HC', 'HD' ]) H2 = nx.union(H, G2, rename=("H", "")) assert (sorted(H2.nodes()) == [ '1', '2', '3', '4', 'H1', 'H2', 'H3', 'H4', 'HA', 'HB', 'HC', 'HD' ]) assert not H1.has_edge('NB', 'NA') G = nx.compose(G, G) assert_edges_equal(G.edges(), H.edges()) G2 = nx.union(G2, G2, rename=('', 'copy')) assert (sorted(G2.nodes()) == [ '1', '2', '3', '4', 'copy1', 'copy2', 'copy3', 'copy4' ]) assert sorted(G2.neighbors('copy4')) == [] assert sorted(G2.neighbors('copy1')) == ['copy2', 'copy3', 'copy4'] assert len(G) == 8 assert nx.number_of_edges(G) == 6 E = nx.disjoint_union(G, G) assert len(E) == 16 assert nx.number_of_edges(E) == 12 E = nx.disjoint_union(G1, G2) assert sorted(E.nodes()) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] G = nx.Graph() H = nx.Graph() G.add_nodes_from([(1, {'a1': 1})]) H.add_nodes_from([(1, {'b1': 1})]) R = nx.compose(G, H) assert R.nodes == {1: {'a1': 1, 'b1': 1}}
def _crossover(self, ga, gb): gs = [] ga = nx.convert_node_labels_to_integers(ga) edges_a = self._get_valid_edges(ga, max_num=self.n_cycles, n_edges_per_cycle=self.n_edges_per_cycle) if edges_a is None: return gs edges_a = self._get_selected_edges(ga, edges_a, fraction=self.fraction) gb = nx.convert_node_labels_to_integers(gb) edges_b = self._get_valid_edges(gb, max_num=self.n_cycles, n_edges_per_cycle=self.n_edges_per_cycle) if edges_b is None: return gs edges_b = self._get_selected_edges(gb, edges_b, fraction=self.fraction) if edges_a is None or edges_b is None: return gs for ea in edges_a: for eb in edges_b: if ea is not None and eb is not None: ia, ja = ea[0] ib, jb = eb[0] ibu, jbu = ib + len(ga), jb + len(ga) ka, la = ea[1] kb, lb = eb[1] kbu, lbu = kb + len(ga), lb + len(ga) gu0 = nx.disjoint_union(ga, gb) self._swap_edge(gu0, (ia, ja), (ibu, jbu), mode=0) self._swap_edge(gu0, (ka, la), (kbu, lbu), mode=0) components = list(nx.connected_components(gu0)) gs.extend([nx.subgraph(gu0, component).copy() for component in components]) gu0 = nx.disjoint_union(ga, gb) self._swap_edge(gu0, (ia, ja), (ibu, jbu), mode=0) self._swap_edge(gu0, (ka, la), (kbu, lbu), mode=1) components = list(nx.connected_components(gu0)) gs.extend([nx.subgraph(gu0, component).copy() for component in components]) gu1 = nx.disjoint_union(ga, gb) self._swap_edge(gu1, (ia, ja), (ibu, jbu), mode=1) self._swap_edge(gu1, (ka, la), (kbu, lbu), mode=1) components = list(nx.connected_components(gu1)) gs.extend([nx.subgraph(gu1, component).copy() for component in components]) gu1 = nx.disjoint_union(ga, gb) self._swap_edge(gu1, (ia, ja), (ibu, jbu), mode=1) self._swap_edge(gu1, (ka, la), (kbu, lbu), mode=0) components = list(nx.connected_components(gu1)) gs.extend([nx.subgraph(gu1, component).copy() for component in components]) return gs
def test_white_harary1(): # Figure 1b white and harary (2001) # A graph with high adhesion (edge connectivity) and low cohesion # (node connectivity) G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.remove_node(7) for i in range(4, 7): G.add_edge(0, i) G = nx.disjoint_union(G, nx.complete_graph(4)) G.remove_node(G.order() - 1) for i in range(7, 10): G.add_edge(0, i) assert_equal(1, approx.node_connectivity(G))
def test_white_harary1(): # Figure 1b white and harary (2001) # A graph with high adhesion (edge connectivity) and low cohesion # (node connectivity) G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.remove_node(7) for i in range(4,7): G.add_edge(0,i) G = nx.disjoint_union(G, nx.complete_graph(4)) G.remove_node(G.order()-1) for i in range(7,10): G.add_edge(0,i) assert_equal(1, approx.node_connectivity(G))
def test_white_harary_1(): # Figure 1b white and harary (2001) # # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF # A graph with high adhesion (edge connectivity) and low cohesion # (vertex connectivity) G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.remove_node(7) for i in range(4, 7): G.add_edge(0, i) G = nx.disjoint_union(G, nx.complete_graph(4)) G.remove_node(G.order() - 1) for i in range(7, 10): G.add_edge(0, i) assert_equal(1, nx.node_connectivity(G)) assert_equal(3, nx.edge_connectivity(G))
def test_white_harary_1(): # Figure 1b white and harary (2001) # # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF # A graph with high adhesion (edge connectivity) and low cohesion # (vertex connectivity) G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.remove_node(7) for i in range(4,7): G.add_edge(0,i) G = nx.disjoint_union(G, nx.complete_graph(4)) G.remove_node(G.order()-1) for i in range(7,10): G.add_edge(0,i) assert_equal(1, nx.node_connectivity(G)) assert_equal(3, nx.edge_connectivity(G))
def test_generate_seq_graph(): macro_str_A = "A:6:1:A-1." macro_str_B = "B:2:4:B-1." macros = {"A": MacroString(macro_str_A), "B": MacroString(macro_str_B)} seq_graph = generate_seq_graph(["A", "B", "A"], macros, ["0:1:2-0", "1:2:1-1"]) graphA = macros["A"].gen_graph() graphB = macros["B"].gen_graph() ref_graph = nx.disjoint_union(graphA, graphB) ref_graph = nx.disjoint_union(ref_graph, graphA) ref_graph.add_edges_from([(2, 6), (7, 12)]) assert nx.is_isomorphic(ref_graph, seq_graph)
def random_pair_stitch(self, num_edges): left_nodes = self.left_region.graph.nodes() right_nodes = self.right_region.graph.nodes() if num_edges > len(left_nodes) * len(right_nodes): raise Exception("Too many edges to stitch") stitch = [] while len(stitch) != num_edges: edge = (random.choice(list(left_nodes)), random.choice(list(right_nodes))) if edge in stitch: continue stitch.append(edge) self.graph.structure = nx.disjoint_union( self.left_region.graph.structure, self.right_region.graph.structure) for (left_node, right_node) in stitch: edge = (left_node, right_node) self.graph.structure.add_edges_from([edge]) self.attack_edges.append(edge) self.known_honests = self.left_region.known_honests self.is_stitched = True
def string_to_networkx(header, sequence, **options): # defaults energy_range = options.get('energy_range', 10) max_num = options.get('max_num', 3) max_num_subopts = options.get('max_num_subopts', 100) split_components = options.get('split_components', False) seq_struct_list, energy_list = rnasubopt_wrapper(sequence, energy_range=energy_range, max_num=max_num, max_num_subopts=max_num_subopts) if split_components: for seq_struct, energy in zip(seq_struct_list, energy_list): G = sequence_dotbracket_to_graph(seq_info=sequence, seq_struct=seq_struct) G.graph['info'] = 'RNAsubopt energy=%s max_num=%s' % (energy, max_num) if G.number_of_nodes() < 2: G = seq_to_networkx(header, sequence, **options) G.graph['id'] = header G.graph['sequence'] = sequence G.graph['structure'] = seq_struct yield G else: G_global = nx.Graph() G_global.graph['id'] = header G_global.graph['info'] = 'RNAsubopt energy_range=%s max_num=%s' % (energy_range, max_num) G_global.graph['sequence'] = sequence for seq_struct in seq_struct_list: G = sequence_dotbracket_to_graph(seq_info=sequence, seq_struct=seq_struct) G_global = nx.disjoint_union(G_global, G) if G_global.number_of_nodes() < 2: G_global = seq_to_networkx(header, sequence, **options) yield G_global
def CreateInd(self,nbClusters, connectInter, connectIntra, pcExc, pcInh, nbNeuronByCluster, interRatio): """ connectInter est la probabilite de connecter deux clusters entre eux connectIntra est une liste de probabilite de connection de neurones suivant leur type (pEE,pEI,pII,pIE) pcExc et pcInh sont le pourcentage de chaque type de neurones interRatio est le ratio de neurones-interface entre deux clusters (>1) """ nbNeuronsInd = nbClusters * nbNeuronByCluster numNeuron = 0 nbExc = int(pcExc * nbNeuronByCluster) lstNeuronsType = ([1] * nbExc + [-1]*(nbNeuronByCluster - nbExc)) * nbClusters lstNeuronToCluster = [y for y in range(nbClusters) for x in range(nbNeuronByCluster)] lstClusterToNeuron = [range(y*nbNeuronByCluster,(y+1)*nbNeuronByCluster) for y in range(nbClusters) ] lstInterfaceNeuron = [[],[],[],[]] #Liste des neurones de chaque cluster connectes aux neurones d'autres clusters gphInd = nx.MultiDiGraph() #Creation des clusters for numCluster in range(nbClusters): gphCluster = nx.MultiDiGraph() matrix = self.CreateConnectionMatrix(pcExc,pcInh,nbNeuronByCluster,connectIntra) #Parcourt de la matrice de connexion du cluster for ligne in range(nbNeuronByCluster): for col in range(nbNeuronByCluster): gphCluster.add_edge(ligne+numNeuron , col+numNeuron,weight=matrix[ligne,col]) #Permet la numerotation continue entre les clusters numNeuron+=nbNeuronByCluster #Rajoute le graphe du cluster (gphCluster) au graphe total (gphInd) gphInd=nx.disjoint_union(gphInd,gphCluster) gphCluster=nx.create_empty_copy(gphCluster) #Creation des connexions inter-cluster lstClusterConnection = self.CreateClusterConnection(connectInter,nbClusters) for numCluster in range(nbClusters): pcInter = int(nbNeuronByCluster / interRatio) #Nombre de neurones connectes entre deux clusters (preNeurones,postNeurones,weights) = self.CreateInterConnectionMatrix(numCluster,nbNeuronByCluster,lstClusterToNeuron,lstClusterConnection,pcInter,lstNeuronsType) for n in range(len(preNeurones)): gphInd.add_edge(preNeurones[n] , postNeurones[n] ,weight=weights[n]) #Liste caracterisant les connexions inter-cluster #ligne 0 : numero de cluster des neurones pre-synaptiques #ligne 1 : numero des neurones pre-synaptiques #ligne 2 : numero de cluster des neurones post-synaptiques #ligne 3 : numero des neurones post-synaptiques lstInterfaceNeuron[0].extend([numCluster] * len(preNeurones)) lstInterfaceNeuron[1].extend(preNeurones) lstInterfaceNeuron[2].extend( [lstNeuronToCluster[x] for x in postNeurones] ) lstInterfaceNeuron[3].extend(postNeurones) #Stockage des valeurs de sortie dans des proprietes de la classe self.graph = gphInd self.lstNeuronsType = lstNeuronsType self.lstNeuronToCluster = lstNeuronToCluster self.lstClusterToNeuron = lstClusterToNeuron self.lstInterfaceNeuron = lstInterfaceNeuron
def _string_to_networkx(self, header=None, sequence=None, constraint=None): seq_struct_list, energy_list = self._rnasubopt_wrapper(sequence) if self.split_components: for seq_struct, energy in zip(seq_struct_list, energy_list): graph = sequence_dotbracket_to_graph(header=header, seq_info=sequence, seq_struct=seq_struct) graph.graph['info'] = 'RNAsubopt energy=%s max_num=%s' % \ (energy, self.max_num) graph.graph['id'] = header graph.graph['sequence'] = sequence graph.graph['structure'] = seq_struct yield graph else: graph_global = nx.Graph() graph_global.graph['id'] = header graph_global.graph['info'] = \ 'RNAsubopt energy_range=%s max_num=%s' % \ (self.energy_range, self.max_num) graph_global.graph['sequence'] = sequence for seq_struct in seq_struct_list: graph = sequence_dotbracket_to_graph(header=header, seq_info=sequence, seq_struct=seq_struct) graph_global = nx.disjoint_union(graph_global, graph) yield graph_global
def get_shortest_path(self, tree_1, tree_2, connection_point): ''' Given two trees and a connection point, find the shortest path from the first node in the forst tree to the last in the second Args: tree_1: Tree with starting point at node index 0 tree_2: Tree with ending point as the last node. connection_point: The point that connects the two trees Returns: The path as a Nx3 NumPy array with points ''' full_tree = nx.disjoint_union(tree_1.tree, tree_2.tree) full_nodes = np.append(tree_1.nodes, tree_2.nodes, axis=0) connection_idx_tree_1 = len(tree_1.nodes) - 1 connection_idx_tree_2 = tree_2.nearest_node(connection_point)[0] connection_idx_tree_2_full_tree = connection_idx_tree_1 + connection_idx_tree_2 + 1 full_tree.add_edge(connection_idx_tree_1, connection_idx_tree_2_full_tree, weight=0) start_idx = 0 end_idx = len(tree_1.nodes) def dist(a, b): a_point = full_nodes[a] b_point = full_nodes[b] return np.linalg.norm(b_point - a_point) path = nx.astar_path(full_tree, start_idx, end_idx, heuristic=dist) return np.array([full_nodes[idx] for idx in path])
def connect_clusters_n_times(graphs, number_of_times): """ inserts edges between given graphs to create connected graph """ cpy = copy.deepcopy(graphs) if graphs is None or len(graphs) == 0: return None result_graph = cpy.pop() while len(cpy) > 0: rand = random.randint(0, len(cpy) - 1) #select subgraph to add subgraph = cpy.pop(rand) offset_to_new_nodes = nx.number_of_nodes(result_graph) subgraph_number_of_nodes = nx.number_of_nodes(subgraph) result_graph = nx.disjoint_union(result_graph, subgraph) #connect by random edge connected to graph used_edges = [] current_edge = [-1, -1] for i in range(number_of_times): while current_edge in used_edges: node_idx_1 = random.randint(0, offset_to_new_nodes - 1) node_idx_2 = offset_to_new_nodes + random.randint( 0, subgraph_number_of_nodes - 1) result_graph.add_edge(node_idx_1, node_idx_2) used_edges.add([node_idx_1, node_idx_2]) return result_graph
def graph(self, nested=False): ''' generate the graph that will be used for evaluation ( it will be vectorized by eden and then used in a machine learning scheme). Args: nested: bool the graph returned here is the union of graph minor and the base graph. nested decides wether there edges between nodes in the base graph and their representative in the graph minor. these edges have the attribute 'nested'. Returns: nx.graph ''' g= nx.disjoint_union(self._base_graph, self.abstract_graph()) node_id= len(g) if nested: for n,d in g.nodes(data=True): if 'contracted' in d and 'edge' not in d: for e in d['contracted']: if 'edge' not in g.node[e]: # we want an edge from n to e g.add_node(node_id,edge=True,label='e') g.add_edge( n, node_id, nesting=True) g.add_edge( node_id, e, nesting=True) #g.add_edge( n, e, nesting=True) node_id+=1 return g
def join_graphs(*graphs): graph = graphs[0] for g in graphs[1:]: graph = nx.disjoint_union(graph, g) assert len(graph.nodes) == sum(len(g.nodes) for g in graphs) return graph
def connect_clusters_by_overlay(overlay_graph, subgraphs): """ inserts subgraphs as edges between given graphs into overlay """ cpy = copy.deepcopy(subgraphs) if subgraphs is None or len(subgraphs) == 0: return None result_graph = cpy.pop() number_overlay_nodes = nx.number_of_nodes(overlay_graph) onverlay_node_index = 0 while len(cpy) > 0: rand = random.randint(0, len(cpy) - 1) # select subgraph to add subgraph = cpy.pop(rand) offset_to_new_nodes = nx.number_of_nodes(result_graph) subgraph_number_of_nodes = nx.number_of_nodes(subgraph) result_graph = nx.disjoint_union(result_graph, subgraph) # connect by random edge connected to graph subgraph_node_idx = offset_to_new_nodes + random.randint( 0, subgraph_number_of_nodes - 1) result_graph.add_edge(onverlay_node_index, subgraph_node_idx) onverlay_node_index = (onverlay_node_index + 1) % number_overlay_nodes return result_graph
def test_five_clique(): # Make a graph that can be disconnected less than 4 edges, but no node has # degree less than 4. G = nx.disjoint_union(nx.complete_graph(5), nx.complete_graph(5)) paths = [ # add aux-connections (1, 100, 6), (2, 100, 7), (3, 200, 8), (4, 200, 100), ] G.add_edges_from(it.chain(*[pairwise(path) for path in paths])) assert min(dict(nx.degree(G)).values()) == 4 # For k=3 they are the same assert fset(nx.k_edge_components(G, k=3)) == fset(nx.k_edge_subgraphs(G, k=3)) # For k=4 they are the different # the aux nodes are in the same CC as clique 1 but no the same subgraph assert fset(nx.k_edge_components(G, k=4)) != fset( nx.k_edge_subgraphs(G, k=4)) # For k=5 they are not the same assert fset(nx.k_edge_components(G, k=5)) != fset( nx.k_edge_subgraphs(G, k=5)) # For k=6 they are the same assert fset(nx.k_edge_components(G, k=6)) == fset(nx.k_edge_subgraphs(G, k=6)) _check_edge_connectivity(G)
def disjoint_union_all(graphs): """Return the disjoint union of all graphs. This operation forces distinct integer node labels starting with 0 for the first graph in the list and numbering consecutively. Parameters ---------- graphs : list List of NetworkX graphs Returns ------- U : A graph with the same type as the first graph in list Notes ----- It is recommended that the graphs be either all directed or all undirected. Graph, edge, and node attributes are propagated to the union graph. If a graph attribute is present in multiple graphs, then the value from the last graph in the list with that attribute is used. """ U = graphs.pop(0) for H in graphs: U = nx.disjoint_union(U, H) return U
def self_repetition(G, n=1, linknode=0): new_graph = nx.null_graph() new_graph.add_node(0) for i in range(n): new_graph = nx.disjoint_union(new_graph, G.copy()) new_graph.add_edge(0, i * len(G) + linknode + 1) return new_graph
def generate_synthetic(): import random max_nodes = 200 min_nodes = 100 community_num_nodes = 10 graphs = [] labels = [] com_1 = nx.caveman_graph(1, community_num_nodes) com_2 = nx.star_graph(community_num_nodes) for i in range(500): num_nodes = random.randint(min_nodes, max_nodes) graph = nx.fast_gnp_random_graph(num_nodes, 0.1) graph = nx.disjoint_union(graph, com_1) for i in range(num_nodes, graph.number_of_nodes()): for j in range(num_nodes): if random.random() > 0.9: graph.add_edge(graph.nodes()[i], graph.nodes()[j]) graphs.append(graph) labels.append(1) num_nodes = random.randint(min_nodes, max_nodes) graph = nx.fast_gnp_random_graph(num_nodes, 0.1) for i in range(num_nodes, graph.number_of_nodes()): for j in range(num_nodes): if random.random() > 0.9: graph.add_edge(graph.nodes[i], graph.nodes[j]) graphs.append(graph) labels.append(0) return graphs, labels
def __imul__(self, m): """In-place repeat of atoms.""" if isinstance(m, int): m = (m, m, m) for x, vec in zip(m, self._cell): if x != 1 and not vec.any(): raise ValueError( 'Cannot repeat along undefined lattice vector') M = np.product(m) n = len(self) for name, a in self.arrays.items(): self.arrays[name] = np.tile(a, (M, ) + (1, ) * (len(a.shape) - 1)) cgraph = self._graph.copy() positions = self.arrays['positions'] i0 = 0 for m0 in range(m[0]): for m1 in range(m[1]): for m2 in range(m[2]): i1 = i0 + n positions[i0:i1] += np.dot((m0, m1, m2), self._cell) i0 = i1 if m0 + m1 + m2 != 0: self._graph = nx.disjoint_union(self._graph, cgraph) if self.constraints is not None: self.constraints = [c.repeat(m, n) for c in self.constraints] self._cell = np.array([m[c] * self._cell[c] for c in range(3)]) return self
def staple_component_to_graph(self, n_nodes_in_subgraph, graph_root_node, **kwargs): """ Staple a connected component to a graph. Args - n_nodes_in_subgraph (int): number of nodes in each subgraph - graph_root_node (int): node in the base graph that the component should be "stapled" to Return - cc_node_ids (list): nodes in a connected component - cc_root_node (int): node in the connected component (subgraph) to connect with the graph_root_node """ # Create new connected component for the node in base graph con_component = self.generate_subgraph(n_nodes_in_subgraph, **kwargs) cc_node_ids = list( range(len(self.graph.nodes), len(self.graph.nodes) + n_nodes_in_subgraph)) # Staple the connected component to the base graph joined_graph = nx.disjoint_union(self.graph, con_component) cc_root_node = random.sample(cc_node_ids, 1)[0] joined_graph.add_edge(graph_root_node, cc_root_node) self.graph = joined_graph.copy() return cc_node_ids, cc_root_node
def random_pair_stitch(self, num_edges): left_nodes = self.left_region.graph.nodes() right_nodes = self.right_region.graph.nodes() if num_edges > len(left_nodes) * len(right_nodes): raise Exception("Too many edges to stitch") stitch = [] while len(stitch) != num_edges: edge = ( random.choice(left_nodes), random.choice(right_nodes) ) if edge in stitch: continue stitch.append(edge) self.graph.structure = nx.disjoint_union( self.left_region.graph.structure, self.right_region.graph.structure ) for (left_node, right_node) in stitch: edge = (left_node, len(left_nodes)+right_node ) self.graph.structure.add_edges_from([edge]) self.attack_edges.append(edge) self.known_honests = self.left_region.known_honests self.is_stitched = True
def _patch_modification(block, modification): """ Applies, in order, modifications to block and returns a new Block. Modifications are applied by overlaying the anchor of a modification with the block and adding the remaining nodes and edges. """ anchor_idxs = set() for mod_idx in modification: if not modification.nodes[mod_idx]['PTM_atom']: anchor_idxs.add(mod_idx) anchor = nx.subgraph(modification, anchor_idxs) non_anchor_idxs = set(modification) - anchor_idxs non_anchor = nx.subgraph(modification, non_anchor_idxs) block = nx.convert_node_labels_to_integers(block) ismags = ISMAGS(block, anchor, node_match=_node_equal) anchor_block_to_mod = list(ismags.subgraph_isomorphisms_iter()) if not anchor_block_to_mod: LOGGER.error("Modification {} doesn't fit on Block {}", modification.name, block.name) raise ValueError("Cannot apply modification to block") # This probably can't happen, since atoms in Modifications /should/ have # atomnames. Which should be unique. So, nocover. elif len(anchor_block_to_mod) > 1: # pragma: nocover LOGGER.error("Modification {} fits on Block {} in {} ways", modification.name, block.name, len(anchor_block_to_mod)) # pragma: nocover raise ValueError( "Cannot apply modification to block") # pragma: nocover block_to_mod = anchor_block_to_mod[0] mod_to_block = {val: key for key, val in block_to_mod.items()} # Add the extra modification atoms to the mapping/match. It's important to # note that this is under the assumption that when nx.disjoint_union # relabels nodes in non_anchor to ints it keeps the same order. # The alternative to this assumption is to reimplement disjoint_union where # the mapping is also returned mod_to_block.update( dict( zip(non_anchor_idxs, range(len(block), len(block) + len(non_anchor_idxs))))) result = Block(nx.disjoint_union(block, non_anchor)) # Mark the modified atoms with the specified modification, so canonicalize # modifications has an easier job for mod_idx in modification: idx = mod_to_block[mod_idx] node_mods = result.nodes[idx].get('modifications', []) if modification not in node_mods: result.nodes[idx]['modifications'] = node_mods + [modification] for mod_idx, mod_jdx in modification.edges_between(anchor_idxs, non_anchor_idxs): idx = mod_to_block[mod_idx] jdx = mod_to_block[mod_jdx] result.add_edge(idx, jdx) return result
def __setup_network_graph(self): structure = nx.disjoint_union( self.left_region.graph.structure, self.right_region.graph.structure ) return sypy.CustomGraph(structure)
def plot_clustered_graph(dist_matrix, labels=None): plt.close('all') plt.figure(1) plt.clf() n_clusters = max(labels) + 1 print('n_clusters = {}'.format(n_clusters)) g_g = nx.Graph() for k in range(0, n_clusters): class_members = labels == k class_dist = dist_matrix[class_members].T[class_members] g = nx.from_numpy_matrix(class_dist) g_g = nx.disjoint_union(g_g, g) # color nodes the same in each connected subgraph for g in nx.connected_component_subgraphs(g_g): c = [random.random()] * nx.number_of_nodes(g) # random color... nx.draw(g, node_size=40, node_color=c, vmin=0.0, vmax=1.0, with_labels=False) plt.savefig("atlas.png", dpi=75) plt.show()
def disjoint_union_all(graphs): """Return the disjoint union of all graphs. This operation forces distinct integer node labels starting with 0 for the first graph in the list and numbering consecutively. Parameters ---------- graphs : list List of NetworkX graphs Returns ------- U : A graph with the same type as the first graph in list Raises ------ ValueError If `graphs` is an empty list. Notes ----- It is recommended that the graphs be either all directed or all undirected. Graph, edge, and node attributes are propagated to the union graph. If a graph attribute is present in multiple graphs, then the value from the last graph in the list with that attribute is used. """ if not graphs: raise ValueError('cannot apply disjoint_union_all to an empty list') graphs = iter(graphs) U = next(graphs) for H in graphs: U = nx.disjoint_union(U, H) return U
def disjoint_union_all(graphs): """Return the disjoint union of all graphs. This operation forces distinct integer node labels starting with 0 for the first graph in the list and numbering consecutively. Parameters ---------- graphs : list List of NetworkX graphs Returns ------- U : A graph with the same type as the first graph in list Notes ----- It is recommended that the graphs be either all directed or all undirected. Graph, edge, and node attributes are propagated to the union graph. If a graph attribute is present in multiple graphs, then the value from the last graph in the list with that attribute is used. """ graphs = iter(graphs) U = next(graphs) for H in graphs: U = nx.disjoint_union(U, H) return U
def patternsets2(MotifG1, MotifG2): #enumerate all possible permutations of node labels, #minimum is sharing one edge, all the way to max is the smaller number of edges, complexity 2^edgenum_max #return a set of possibly isomorphic collapses patternset = set() edgenum_max = min(MotifG1.number_of_edges(), MotifG2.number_of_edges()) #select L (two+) edges to overlap for L in range(1, edgenum_max + 1): print L L_subsets = list(itertools.combinations(MotifG1.edges(),L)) L_subsets2 = list(itertools.combinations(MotifG2.edges(),L)) for subset1 in L_subsets: for subset2 in L_subsets2: print "already chose these" +str(L)+" edges in Motif2" print subset2 permutations = list(itertools.permutations(subset1)) i = 0 for permutation in permutations: print "this permutation is" print permutation print "in this particular order" + str(i) if MotifG1 == MotifG2: print "waring!!!same motif non-relabled" G = nx.disjoint_union(MotifG1, MotifG2) else: G = nx.union(MotifG1, MotifG2) if len(G) != 0: G2 = nx.Graph() G22 = nx.Graph() Motif2merged_nodes = set() for j in range(0, len(permutation)): edge_1 = permutation[j] edge_2 = subset2[j] print "edge 1" print edge_1 print "edge 2" print edge_2 if edge_2[0] not in Motif2merged_nodes: G1 = merge_nodes(G, edge_1[0], edge_2[0]) Motif2merged_nodes.add(edge_2[0]) if edge_2[1] not in Motif2merged_nodes: G2 = merge_nodes(G1, edge_1[1], edge_2[1]) Motif2merged_nodes.add(edge_2[1]) if edge_2[0] not in Motif2merged_nodes: G11 = merge_nodes(G, edge_1[1], edge_2[0]) if edge_2[1] not in Motif2merged_nodes: G22 = merge_nodes(G11, edge_1[0], edge_2[1]) patternset.add(G2) patternset.add(G22) print G2.nodes() i += 1 return patternset
def add_community(self, G, community): last_community = len(G.nodes())/self._household_size-1 G=nx.disjoint_union(G, community) self.get_node_with_highest_degree(last_community, G) for i in range(last_community+1, last_community+len(community.nodes())/self._household_size+1): G.add_edge(self.get_random_node(last_community), self.get_random_node(i)) return G
def contraction(graphs=None, contraction_attribute='label', dont_contract_attribute_symbol=None, nesting=False, contraction_weight_scaling_factor=1, modifiers=modifiers, **options): ''' modifiers: list of named tuples, each containing the keys: attribute_in, attribute_out and reduction. "attribute_in" identifies the node attribute that is extracted from all contracted nodes. "attribute_out" identifies the node attribute that is written in the resulting graph. "reduction" is one of the following reduction operations: 1. histogram, 2. sum, 3. average, 4. categorical, 5. set_categorical. "histogram" returns a sparse vector with numerical hashed keys, "sum" and "average" cast the values into floats before computing the sum and average respectively, "categorical" returns the concatenation string of the lexicographically sorted list of input attributes, "set_categorical" returns the concatenation string of the lexicographically sorted set of input attributes. contraction_weight_scaling_factor: factor to multiply the weights of the contracted part ''' for g in graphs: # check for 'position' attribute and add it if not present for i, (n, d) in enumerate(g.nodes_iter(data=True)): if d.get('position', None) is None: g.node[n]['position'] = i # compute contraction g_contracted = edge_contraction(graph=g, node_attribute=contraction_attribute, except_symbol=dont_contract_attribute_symbol) info = g_contracted.graph.get('info', '') g_contracted.graph['info'] = info + '\n' + serialize_modifiers(modifiers) for n, d in g_contracted.nodes_iter(data=True): # get list of contracted node ids contracted = d.get('contracted', None) if contracted is None: raise Exception('Empty contraction list for: id %d data: %s' % (n, d)) for modifier in modifiers: modifier_func = contraction_modifer_map[modifier.reduction] g_contracted.node[n][modifier.attribute_out] = modifier_func( input_attribute=modifier.attribute_in, graph=g, id_nodes=contracted) # rescale the weight of the contracted nodes if contraction_weight_scaling_factor != 1: w = d.get('weight', 1) w = w * contraction_weight_scaling_factor g_contracted.node[n]['weight'] = w if nesting: # add nesting edges between the constraction graph and the original graph g_nested = nx.disjoint_union(g, g_contracted) # rewire contracted graph to the original graph for n, d in g_nested.nodes_iter(data=True): contracted = d.get('contracted', None) if contracted: for m in contracted: g_nested.add_edge(n, m, label='.', len=1, nesting=True) yield g_nested else: yield g_contracted
def instance8_1000(): """ Returns a 3-element tuple (G,T,leaves) where G is the graph T is the optimal solution and leaves is the number of leaves in the optimal solution. The graph is constructed by creating 4 stars with 90 nodes and adding 10 random nodes. """ #create a star of 4 stars starList = [] for _ in range(0,6): starList.append(nx.heawood_graph()) T = nx.Graph() for star in starList: T = nx.disjoint_union(T,star) T.add_node(84) T.add_edges_from([(84,0),(84,14),(84,28),(84,42),(84,56),(84,70)]) #add 10 more nodes with random edges T.add_nodes_from(range(85,100)) for i in range(85,100): x = int(random()*5371)%90 T.add_edge(i,x) #count the number of leaves leaves = list(T.degree(T.nodes()).values()).count(1) #randomize the label of nodes n = range(100) new = range(100) r.shuffle(new) T = nx.relabel_nodes(T,dict(zip(n,new))) G = nx.Graph() G.add_nodes_from(T.nodes()) G.add_edges_from(T.edges()) # add random edges for i in range(1000): x = int(random()*15897)%100 y = int(random()*17691)%100 G.add_edge(G.nodes()[x],G.nodes()[y]) for e in G.edges(): if e[0] == e[1]: G.remove_edge(e[0],e[1]) G = G.to_undirected() #T = mlst.one_edge_swap(G) T = nx.Graph() return (G,T)
def test_is_planar_unions(self): try: from itertools import combinations,product except ImportError: raise SkipTest('itertools.combinations not found') for (G1,G2) in combinations(self.planar,2): G=nx.disjoint_union(G1,G2) assert_true(planarity.is_planar(G)) for (G1,G2) in combinations(self.non_planar,2): G=nx.disjoint_union(G1,G2) assert_false(planarity.is_planar(G)) for (G1,G2) in product(self.planar,self.non_planar): G=nx.disjoint_union(G1,G2) assert_false(planarity.is_planar(G))
def original_graph(): romeos_family = nx.complete_graph(5) julias_family = nx.complete_graph(5) # The families clash <- aw, not good! family_fight = nx.disjoint_union(romeos_family, julias_family) # ... but Romeo and Julia make love nevertheless family_fight.add_edge(0, 9) return family_fight
def test_spanner_unweighted_disconnected_graph(): """Test spanner construction on a disconnected graph.""" G = nx.disjoint_union(nx.complete_graph(10), nx.complete_graph(10)) spanner = nx.spanner(G, 4, seed=_seed) _test_spanner(G, spanner, 4) spanner = nx.spanner(G, 10, seed=_seed) _test_spanner(G, spanner, 10)
def get_json(self): # join together all layers in the network H = nx.DiGraph() for G in self.layergraphs: H = nx.disjoint_union(G, H) data = json_graph.node_link_data(H) return json.dumps(data)
def test_white_harary_2(): # Figure 8 white and harary (2001) # # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.add_edge(0,4) # kappa <= lambda <= delta assert_equal(3, min(nx.core_number(G).values())) assert_equal(1, nx.node_connectivity(G)) assert_equal(1, nx.edge_connectivity(G))
def instance1_1000(): #make a star of 4 24-node stars A = nx.star_graph(24) B = nx.star_graph(24) C = nx.star_graph(24) D = nx.star_graph(23) T = nx.disjoint_union(A,B) T = nx.disjoint_union(T,C) T = nx.disjoint_union(T,D) T.add_node(99) T.add_edges_from([(0,99),(25,99),(50,99),(75,99)]) #randomize the labels of nodes # for n in T.nodes(): # new = n + int(random()*10000) # while(new in T.nodes()): # new = n + int(random()*10000) n = range(100) new = range(100) r.shuffle(new) T = nx.relabel_nodes(T,dict(zip(n,new))) # T is optimal solution # G is the graph G = nx.Graph() G.add_nodes_from(T.nodes()) G.add_edges_from(T.edges()) # add random edges for i in range(1000): x = int(random()*15897)%100 y = int(random()*17691)%100 G.add_edge(G.nodes()[x],G.nodes()[y]) for e in G.edges(): if e[0] == e[1]: G.remove_edge(e[0],e[1]) return (G,T)
def pre_vectorizer_graph(self, nested=True, fcorrect=False, base_only=False): """ Parameters ---------- nested: nested minor + base graph fcorrect: introduce nodes that aid the forgi abstraction base_only: only return the base graph Returns ------- nx.graph """ g = nx.disjoint_union(nx.Graph(self._base_graph), self.abstract_graph()) if base_only: g = self.base_graph().copy() node_id = len(g) delset = [] if nested: for n, d in g.nodes(data=True): if 'contracted' in d and 'edge' not in d: for e in d['contracted']: if 'edge' not in g.node[e] and not (g.node[e]['label'] == 'F' and fcorrect): # think about this # we want an edge from n to e g.add_node(node_id, edge=True, label='e') g.add_edge(n, node_id, nesting=True) g.add_edge(node_id, e, nesting=True) # g.add_edge( n, e, nesting=True) node_id += 1 if fcorrect: for n, d in g.nodes(data=True): if d['label'] == "F": down = self.nextnode(g, n) up = self.nextnode(g, n, down_direction=False) delset.append((n, down, up)) for r, d, u in delset: # print g.node[d[0]] # we copy the label of the adjacent edge to r g.node[r] = g.node[d[0]].copy() # print g.node[r] # g.node[r]={"label":'-','edge':True} # delete neighbors g.remove_nodes_from([d[0], u[0]]) # rewire neighbors of neighbors g.add_edge(r, d[1]) g.add_edge(u[1], r) # print r,d,u return g
def test_disjoint_union_multigraph(): G = nx.MultiGraph() G.add_edge(0, 1, key=0) G.add_edge(0, 1, key=1) H = nx.MultiGraph() H.add_edge(2, 3, key=0) H.add_edge(2, 3, key=1) GH = nx.disjoint_union(G, H) assert_equal(set(GH), set(G) | set(H)) assert_equal(set(GH.edges(keys=True)), set(G.edges(keys=True)) | set(H.edges(keys=True)))
def test_already_branching(self): """Tests that a directed acyclic graph that is already a branching produces an isomorphic branching as output. """ T1 = nx.balanced_tree(2, 2, create_using=nx.DiGraph()) T2 = nx.balanced_tree(2, 2, create_using=nx.DiGraph()) G = nx.disjoint_union(T1, T2) B = nx.dag_to_branching(G) assert_true(nx.is_isomorphic(G, B))
def instance7_2000(): """ Returns a 3-element tuple (G,T,leaves) where G is the graph T is the optimal solution and leaves is the number of leaves in the optimal solution. The graph is constructed by creating 4 stars with 90 nodes and adding 10 random nodes. """ #create a star of 4 stars starList = [] starList.append(nx.star_graph(22)) starList.append(nx.star_graph(21)) starList.append(nx.star_graph(21)) starList.append(nx.star_graph(21)) T = nx.Graph() for star in starList: T = nx.disjoint_union(T,star) T.add_node(89) T.add_edges_from([(89,0),(89,23),(89,67),(89,45)]) #add 10 more nodes with random edges T.add_nodes_from(range(90,101)) for i in range(90,101): x = int(random()*5371)%90 T.add_edge(i,x) #count the number of leaves leaves = list(T.degree(T.nodes()).values()).count(1) #randomize the label of nodes for n in T.nodes(): new = n + int(random()*2000) while(new in T.nodes()): new = n + int(random()*2000) T = nx.relabel_nodes(T,{n:new}) G = nx.Graph() G.add_nodes_from(T.nodes()) G.add_edges_from(T.edges()) #code for 2000 edges #add random edges while(G.number_of_edges() < 2000): x = int(random()*15897)%100 y = int(random()*17691)%100 G.add_edge(G.nodes()[x],G.nodes()[y]) T = one_edge_swap(G) return (G,T)
def _union(self, graphs): graph_global = nx.Graph() for graph in graphs: graph_global = nx.disjoint_union(graph_global, graph) for n in graph_global.nodes(): if self.attribute in graph_global.node[n]: graph_global.node[n]['part_id'] = \ [graph_global.node[n][self.attribute]] graph_global.node[n]['part_name'] = \ [graph_global.node[n]['label']] return graph_global
def getRandomG(): G = nx.Graph() H = nx.Graph() allAnomNodes = [] for node in range(30): p = CustomData.minval(CustomData.myrand(), 0.09) n = int((CustomData.myrand() + CustomData.myrand()) * 10) n = CustomData.minval(n) tenp = int(p * 10 + 1) num_nodes = int(math.ceil(n * tenp / 3)) recur = tenp g = nx.Graph() temp = nx.fast_gnp_random_graph(num_nodes, p) for j in range(recur): g = nx.disjoint_union(g, temp) dup = g.copy() maxAnomCount = n * math.sqrt(len(g.edges())) * p anomCount = 0 nodes = g.nodes() if len(nodes) == 0: continue numAnomNodes = int(len(nodes) * random.randint(1, 10) / 100) numAnomNodes = 1 if numAnomNodes == 0 else numAnomNodes anomNodes = random.sample(nodes, numAnomNodes) random.shuffle(nodes) print "anom_edges:%d recur:%d nodes:%d edges:%d numAnomNodes:%d" % ( maxAnomCount, recur, len(g.nodes()), len(g.edges()), numAnomNodes) for node in nodes: for anomNode in anomNodes: if anomCount <= maxAnomCount and not g.has_edge(node, anomNode): dup.add_edge(anomNode, node) G = nx.disjoint_union(g, G) H = nx.disjoint_union(dup, H) allAnomNodes.extend(anomNodes) H = CustomGraph(H) H.addAnomNodes(allAnomNodes) print (len(G.nodes()), len(G.edges())) print (len(H.nodes()), len(H.edges())) return G, H
def create_community(self, community_size): households = [] for i in range(community_size): H =self.create_household() households.insert(0, H) G = households[0] for i in range(1, len(households)): G = nx.disjoint_union(G, households[i]) for i in range(len(households)-1): for j in range(i+1, len(households)): G.add_edge(self.get_random_node(i), self.get_random_node(j)) return G