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())
