def readFile(Lines): vlist = {} source = 0 dest = 0 for line in Lines: if line.startswith("#"): continue else: x = line.strip("\n").split(",") if len(x) == 2: if x[0] == "S": source = int(x[1]) elif x[0] == "D": dest = int(x[1]) else: x[0] = int(x[0]) x[1] = int(x[1]) v = g.vertices(x[0], x[1]) vlist[x[0]] = v elif len(x) == 3: x[0] = int(x[0]) x[1] = int(x[1]) x[2] = float(x[2]) v1 = vlist.get(x[0]) v2 = vlist.get(x[1]) e = g.edges(x[0], x[1], x[2]) v1.add_edge(e) v2.add_edge(e) return vlist, source, dest
def remove_random(graph, percent): resitev = graph lay = False if percent > 0.5: lay = True percent = 1 - percent edges = graph.edges() chosen = set() while len(chosen) < percent * len(edges): edge = random.choice(edges) if edge not in chosen: chosen.add(edge) chosen.add((edge[1], edge[0], edge[2])) if lay: zacasno = edges for el in chosen: zacasno.remove(el) chosen = zacasno for (first, second, _) in chosen: try: resitev.del_edge(first, second) resitev.del_edge(second, first) except: pass return resitev
def successorClauses(graph, at): ans = {t: set() for t in at} for u, v in graph.edges(): if graph.vertex_properties['info'][u]['type'] == 'tuple': assert graph.vertex_properties['info'][v]['type'] == 'clause' t = graph.vertex_properties['info'][u]['label'] c = graph.vertex_properties['info'][v]['label'] assert t in ans ans[t].add(c) return ans
def _csr_gen_triples(A): """Converts a SciPy sparse matrix in **Compressed Sparse Row** format to an iterable of weighted edge triples. """ graph = nx.Graph() nrows = A.shape[0] data, indices, indptr = A.data, A.indices, A.indptr for i in range(nrows): for j in range(indptr[i], indptr[i + 1]): graph.add_edge(i, indices[j], weight=data[j]) return graph.edges(data="weight")
def _csr_gen_triples(A): """Converts a SciPy sparse matrix in **Compressed Sparse Row** format to an iterable of weighted edge triples. """ graph = nx.Graph() nrows = A.shape[0] data, indices, indptr = A.data, A.indices, A.indptr for i in range(nrows): for j in range(indptr[i], indptr[i+1]): graph.add_edge(i,indices[j], weight = data[j]) return graph.edges(data = 'weight')
def easy_short_path(self, graph, start, end): visited = set() path = [] for node in graph.edges(): if node.node not in visited: visited.add(node.node) if node.node == end: return None value = node.get_edges() minnode = min(value, key=lambda x: x.weight) path.append(minnode.inedge) return path
def successorTuples(graph, at): ans = {} for u, v in graph.edges(): if graph.vertex_properties['info'][u]['type'] == 'clause': assert graph.vertex_properties['info'][v]['type'] == 'tuple' c = graph.vertex_properties['info'][u]['label'] t = graph.vertex_properties['info'][v]['label'] if c in ans: assert ans[c] == t else: ans[c] = t # if c in ans: logging.info('{}; {}; {}; {}'.format(c, t, ans[c], u.out_degree())) # assert c not in ans # ans[c] = t return ans
def testForbidden(self): claw = make_claw() c4 = make_cycle(4) cok4 = make_cok4() g = make_cycle(5) not_allowed = [claw, c4, cok4] gen = Generator2(g, 1, forbidden=not_allowed) for graph in gen.iterate(): for h in not_allowed: if induced_subgraph(graph, h) is not None: print(graph.edges()) print(h.edges()) self.assertEqual(True, False ,"Failed to forbid a graph")
def testGenerate2Nodes(self): G = nx.Graph() G.add_node(0) index = 0 expected = [{'nodes':[0, 1], 'edges':[]}, {'nodes':[0, 1], 'edges':[(0, 1)]}] self.gen = Generator(G, 1, []) for graph in self.gen.iterate(): self.assertEqual(graph.nodes(), expected[index]['nodes']) self.assertEqual(graph.edges(), expected[index]['edges']) index += 1 self.assertEqual(index, 2)
def testTwoNode(self): g = nx.Graph() g.add_node(0) gen = Generator2(g, 1, []) expected = [{'nodes':[0, 1], 'edges':[]}, {'nodes':[0, 1], 'edges':[(0, 1)]}, ] number = 0 for graph in gen.iterate(): self.assertEqual(expected[number]['nodes'], graph.nodes()) self.assertEqual(expected[number]['edges'], graph.edges()) number += 1 self.assertEqual(number, 2)
def random_test(num_users, probability): ''' Generates test graph and saves it to a file in the gen folder params ------ num_users: number of nodes/users to generate probability: probability of generating edges returns ------- filename of random test ''' filename = 'data/gen/random-%s.dat' % datetime.now().strftime('%Y-%m-%d_%H%M') graph = nx.gnp_random_graph(int(num_users), probability) fileh = open(filename, 'w') for n1, n2 in graph.edges(): weight = str(random.randint(0,100)) fileh.write('{} {} {}\n'.format(str(n1), str(n2), weight)) fileh.close() return filename
def remove_centered(graph, percent, start=None): resitev = graph total_edges = len(graph.edges()) if start == None: start = random.choice(graph.nodes()) queue = [start] done = [] while len(resitev.edges()) > (1 - percent) * total_edges and queue != []: node = queue[0] queue.remove(node) for el in graph.nodes(from_node=node): if len(resitev.edges()) <= (1 - percent) * total_edges: break if el not in done: queue.append(el) try: resitev.del_edge(node, el) resitev.del_edge(el, node) except: continue done.append(node) return resitev
def investigate_ER_edge_probs(node_num): """ Compare theoretical versus practical edge numbers in ER-graph """ def max_edge_num(nodes): return (nodes*(nodes-1)/2) # check property for some ER-graphs en = max_edge_num(node_num) for p in np.arange(0, 1, 0.2): graph = nx.erdos_renyi_graph(node_num, p) edge_num = len(graph.edges()) pp = edge_num / en print(p, '->', pp) print() # get probability for TRN trn = utils.GraphGenerator.get_regulatory_graph('../data/architecture/network_tf_gene.txt') trn_node_num = len(trn.graph.nodes()) trn_edge_num = len(trn.graph.edges()) p = trn_edge_num / max_edge_num(trn_node_num) print(p)
def allConsequents(graph): return { graph.vertex_properties['info'][v]['label'] for u, v in graph.edges() \ if graph.vertex_properties['info'][v]['type'] == 'tuple' }
def from_graph(cls, graph: Graph): """ Initialize graph using another graph which is in adjacency list representation """ return cls(graph.V(), graph.E(), graph.edges())