def test_evolution_operator(n_qubits, n_levels):
#generate random parameters
params = 0.01*np.random.rand(2, n_levels)
gammas = params[0]
betas = params[1]
#generate random graph
edges = []
while len(edges) < 1:
prob = 0.5
graph = erdos_renyi_graph(n_qubits, prob)
edges = list(graph.edges)
#generate random n-qubits state
list_gen_state = qucs.n_rand_qubits(n_qubits)
gen_state = qu.tensor(list_gen_state)
#Test if it works as expected
obs = qaoa.evolution_operator(n_qubits, edges, gammas, betas)*gen_state
exp = gen_state
for i in range(len(gammas)):
u_mix_hamilt_i = (-complex(0,betas[i])*qaoa.mix_hamilt(n_qubits)).expm()
u_prob_hamilt_i = (-complex(0,gammas[i])*qaoa.prob_hamilt(n_qubits, edges)).expm()
exp = u_mix_hamilt_i*u_prob_hamilt_i*exp
assert (np.round(np.array(exp.full()), 8) == (np.round(np.array(obs.full()), 8))).all()
#test if it evolves a state for known parameters
exp = qu.qload('final_state_simple_graph_p=1')
obs = qaoa.evolution_operator(3, [(0,1),(1,2)], [1.0], [0.4])*qaoa.initial_state(3)
def smoke_test_random_graph(self):
seed = 42
G=gnp_random_graph(100,0.25,seed)
G=binomial_graph(100,0.25,seed)
G=erdos_renyi_graph(100,0.25,seed)
G=fast_gnp_random_graph(100,0.25,seed)
G=gnm_random_graph(100,20,seed)
G=dense_gnm_random_graph(100,20,seed)
G=watts_strogatz_graph(10,2,0.25,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=connected_watts_strogatz_graph(10,2,0.1,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=watts_strogatz_graph(10,4,0.25,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 20)
G=newman_watts_strogatz_graph(10,2,0.0,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=newman_watts_strogatz_graph(10,4,0.25,seed)
assert_equal(len(G), 10)
assert_true(G.number_of_edges() >= 20)
G=barabasi_albert_graph(100,1,seed)
G=barabasi_albert_graph(100,3,seed)
assert_equal(G.number_of_edges(),(97*3))
G = extended_barabasi_albert_graph(100, 1, 0, 0, seed)
assert_equal(G.number_of_edges(), 99)
G = extended_barabasi_albert_graph(100, 3, 0, 0, seed)
assert_equal(G.number_of_edges(), 97 * 3)
G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
assert_equal(G.number_of_edges(), 99)
G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
assert_greater(G.number_of_edges(), 100 * 3)
assert_less(G.number_of_edges(), 100 * 4)
G=extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
assert_greater(G.number_of_edges(), 100 * 2)
assert_less(G.number_of_edges(), 100 * 4)
G=powerlaw_cluster_graph(100,1,1.0,seed)
G=powerlaw_cluster_graph(100,3,0.0,seed)
assert_equal(G.number_of_edges(),(97*3))
G=random_regular_graph(10,20,seed)
assert_raises(NetworkXError, random_regular_graph, 3, 21)
constructor=[(10,20,0.8),(20,40,0.8)]
G=random_shell_graph(constructor,seed)
G=random_lobster(10,0.1,0.5,seed)
def smoke_test_random_graph(self):
seed = 42
G=gnp_random_graph(100,0.25,seed)
G=binomial_graph(100,0.25,seed)
G=erdos_renyi_graph(100,0.25,seed)
G=fast_gnp_random_graph(100,0.25,seed)
G=gnm_random_graph(100,20,seed)
G=dense_gnm_random_graph(100,20,seed)
G=watts_strogatz_graph(10,2,0.25,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=connected_watts_strogatz_graph(10,2,0.1,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=watts_strogatz_graph(10,4,0.25,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 20)
G=newman_watts_strogatz_graph(10,2,0.0,seed)
assert_equal(len(G), 10)
assert_equal(G.number_of_edges(), 10)
G=newman_watts_strogatz_graph(10,4,0.25,seed)
assert_equal(len(G), 10)
assert_true(G.number_of_edges() >= 20)
G=barabasi_albert_graph(100,1,seed)
G=barabasi_albert_graph(100,3,seed)
assert_equal(G.number_of_edges(),(97*3))
G = extended_barabasi_albert_graph(100, 1, 0, 0, seed)
assert_equal(G.number_of_edges(), 99)
G = extended_barabasi_albert_graph(100, 3, 0, 0, seed)
assert_equal(G.number_of_edges(), 97 * 3)
G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
assert_equal(G.number_of_edges(), 99)
G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
assert_greater(G.number_of_edges(), 100 * 3)
assert_less(G.number_of_edges(), 100 * 4)
G=extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
assert_greater(G.number_of_edges(), 100 * 2)
assert_less(G.number_of_edges(), 100 * 4)
G=powerlaw_cluster_graph(100,1,1.0,seed)
G=powerlaw_cluster_graph(100,3,0.0,seed)
assert_equal(G.number_of_edges(),(97*3))
G=random_regular_graph(10,20,seed)
assert_raises(NetworkXError, random_regular_graph, 3, 21)
constructor=[(10,20,0.8),(20,40,0.8)]
G=random_shell_graph(constructor,seed)
G=random_lobster(10,0.1,0.5,seed)
def __init__(self, inp=sys.argv[1:]):
self.nodes = int(inp[0])
self.probability = float(inp[1])
self.start = int(inp[2])
self.targ = int(inp[3])
self.verbose = inp[4].upper()
self.initgraph = erdos_renyi_graph(self.nodes, self.probability)
self.alledges = list(self.initgraph.edges)
self.queue = []
self.stack = []
self.fingraph = {}
def _generate_graph_structure(self) -> dict:
"""
Generate random graph structure with given number of nodes and % of routes
:return: Dictionary representing graph structure
"""
nodes_counter = random.choice(range(5, 10))
percent_of_routes = 0.4
graph = erdos_renyi_graph(nodes_counter, percent_of_routes)
edges = []
for edge in graph.edges:
edges.append(list(edge))
self.log_file.log_all(priority=3, string=f"Dungeon skeleton generated")
return {"rooms": list(graph.nodes), "routes": edges, "mobs": {}}
def test_stresses(self):
for i in range(10000):
if i % 100 == 0:
print("i: ", i)
n = 7
max_w = 40
p = 0.5
g = erdos_renyi_graph(n, p).edges
gg = []
for i, j in g:
gg.append((i, j, randint(0, max_w)))
ans = MatchingTests.matching(gg)
exp = MatchingTests.slow_matching(gg)
self.assertEqual(ans, exp)
def random_graph(n_nodes, prob=0.5):
"""
This method generate a random graph, with n_nodes and at least one edge
Parameters
----------
n_nodes : int
number of nodes of the graph.
prob : float, optional
probability, that two edges are linked during the creation, must be in [0, 1].
The default is 0.5.
Returns
-------
graph : networkx.classes.graph.Graph
Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph or a binomial graph.
The $G_{n,p}$ model chooses each of the possible edges with probability 0.5.
"""
graph = erdos_renyi_graph(n_nodes, prob)
while len(list(graph.edges)) < 1:
graph = erdos_renyi_graph(n_nodes, prob)
return graph
def generate_connected_graph(nds, p):
n = nds
i = 0
while (1):
G = erdos_renyi_graph(n, p)
# print("Iterator: ",i)
# print(G.nodes)
# print(G.edges)
# print(nx.is_connected(G)) #return true if all nodes in geaph connected
# nx.draw_networkx(G)
# plt.show()
if (nx.is_connected(G)):
break
i = i + 1
# print('\n------------------------\n')
return G
def test_prob_hamilt(n_qubits):
#generate a generic n-qubits state
list_gen_state = qucs.n_rand_qubits(n_qubits)
gen_state = qu.tensor(list_gen_state)
#generate a random graph of n-vertices
edges = []
while len(edges) < 1:
prob = 0.5
graph = erdos_renyi_graph(n_qubits, prob)
edges = list(graph.edges)
#test is ìf the result is the one expected
obs = qaoa.prob_hamilt(n_qubits,edges)*gen_state
list_exp = []
for j in range(0,len(edges)):
list_exp.append(0.5*(qucs.n_qeye(n_qubits)
-qucs.n_sigmaz(n_qubits,edges[j][0])*qucs.n_sigmaz(n_qubits,edges[j][1]))*gen_state)
exp = sum(list_exp)
assert_equal(obs,exp)
def initialize(): for i in range(USER_NUM):users[i]=round(random.uniform(-1,1),2) for i in range(POST_NUM):posts[i]=round(random.uniform(-1,1),2) users.sort() posts.sort() g = erdos_renyi_graph(USER_NUM,0.5) for x,y in g.edges: if x not in graph:graph[x] = [] if y not in graph:graph[y] = [] graph[x].append(y) graph[y].append(x) print(users) print(posts) for i in graph: print(i,graph[i]) viewership()
def generateRandGraph(n, p, path):
g = erdos_renyi_graph(n, p)
x = g.edges
with open(path, 'w') as f:
f.write('FROM TO:\n')
for a_tuple in x:
node1 = a_tuple[0]
node2 = a_tuple[1]
if random.random() > 0.5:
f.write(str(node1))
f.write(' ')
f.write(str(node2))
f.write('\n')
if random.random() > 0.5:
f.write(str(node2))
f.write(' ')
f.write(str(node1))
f.write('\n')
f.close
return g
def run_wl_kernel(args, dataloader, model, edge_ratio):
dataset = dataloader.dataset
pos_graph_list = []
neg_graph_list = []
meta_test_edge_ratio = 1 - args.meta_val_edge_ratio - args.meta_train_edge_ratio
i = 0
for graph in dataset:
print("Graph : %d" % (i))
i += 1
try:
x, train_pos_edge_index = graph.x.to(args.dev), \
graph.train_pos_edge_index.to(args.dev)
data = graph
except:
data = model.split_edges(graph,val_ratio=args.meta_val_edge_ratio,\
test_ratio=meta_test_edge_ratio)
nx_graph = create_masked_networkx_graph(data)
neg_graph = erdos_renyi_graph(len(nx_graph), edge_ratio)
pos_edge_list = list(nx_graph.edges())
neg_edge_list = list(neg_graph.edges())
pos_node_dict = {}
neg_node_dict = {}
''' Pos Samples '''
for node_id in nx_graph.nodes:
nx_graph.node[node_id]['label'] = nx_graph.degree[node_id]
pos_node_dict[node_id] = nx_graph.degree[node_id]
pos_grakel_graph = [pos_edge_list, pos_node_dict]
pos_graph_list.append(pos_grakel_graph)
'''Neg Samples '''
for node_id in nx_graph.nodes:
nx_graph.node[node_id]['label'] = nx_graph.degree[node_id]
neg_node_dict[node_id] = nx_graph.degree[node_id]
neg_grakel_graph = [neg_edge_list, neg_node_dict]
neg_graph_list.append(neg_grakel_graph)
wl_kernel = GraphKernel(kernel = [{"name": "weisfeiler_lehman", "n_iter": 5},\
{"name": "subtree_wl"}], Nystroem=len(dataset))
kernel_mat = wl_kernel.fit_transform(pos_graph_list)
neg_kernel_mat = wl_kernel.transform(neg_graph_list)
return kernel_mat, neg_kernel_mat
def gen_erdos(n: int):
p = 8.0 / n
return erdos_renyi_graph(n, p)
def erdos_renyi_generator(args):
return generators.erdos_renyi_graph(args.num_nodes, args.probability)
type=str,
default="./data/packet-forward/test1.db")
parser.add_argument("-s", type=str)
parser.add_argument("-n", type=int, default=6)
parser.add_argument("-p", type=float, default=0.5)
parser.add_argument("-pr", type=int, default=0)
args = parser.parse_args()
if not os.path.exists(args.s):
os.mkdir(args.s)
si = args.s + "/test.png"
sf = args.s + "/test.db"
f = open(sf, 'w')
g = erdos_renyi_graph(args.n, args.p)
# print(g.nodes);
# print(g.edges);
drawGraph(g, si)
routes = buildRouteTable(g)
for node in routes:
for dest in routes[node]:
if args.pr == 0:
f.write("route " + str(node + 1) + " " + str(dest + 1) + " " +
str(routes[node][dest][0] + 1) + "\n")
else:
p = random.random
if args.pr == 0:
packets = generatePackets(g, 200)
def erdosRenyi(n,p=0.3):
graphsToReturn = []
for i in range(100):
print RandomGraphGenerator.erdos_renyi_graph, n, i
graphsToReturn.append([i*TIME_UNIT_IN_SECONDS, my_nx.getDictForGraph(erdos_renyi_graph(n,p))])
return graphsToReturn
def smoke_test_random_graph(self):
seed = 42
G = gnp_random_graph(100, 0.25, seed)
G = gnp_random_graph(100, 0.25, seed, directed=True)
G = binomial_graph(100, 0.25, seed)
G = erdos_renyi_graph(100, 0.25, seed)
G = fast_gnp_random_graph(100, 0.25, seed)
G = fast_gnp_random_graph(100, 0.25, seed, directed=True)
G = gnm_random_graph(100, 20, seed)
G = gnm_random_graph(100, 20, seed, directed=True)
G = dense_gnm_random_graph(100, 20, seed)
G = watts_strogatz_graph(10, 2, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() == 10
G = connected_watts_strogatz_graph(10, 2, 0.1, tries=10, seed=seed)
assert len(G) == 10
assert G.number_of_edges() == 10
pytest.raises(NetworkXError, connected_watts_strogatz_graph, \
10, 2, 0.1, tries=0)
G = watts_strogatz_graph(10, 4, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() == 20
G = newman_watts_strogatz_graph(10, 2, 0.0, seed)
assert len(G) == 10
assert G.number_of_edges() == 10
G = newman_watts_strogatz_graph(10, 4, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() >= 20
G = barabasi_albert_graph(100, 1, seed)
G = barabasi_albert_graph(100, 3, seed)
assert G.number_of_edges() == (97 * 3)
G = extended_barabasi_albert_graph(100, 1, 0, 0, seed)
assert G.number_of_edges() == 99
G = extended_barabasi_albert_graph(100, 3, 0, 0, seed)
assert G.number_of_edges() == 97 * 3
G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
assert G.number_of_edges() == 99
G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
assert G.number_of_edges() > 100 * 3
assert G.number_of_edges() < 100 * 4
G = extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
assert G.number_of_edges() > 100 * 2
assert G.number_of_edges() < 100 * 4
G = powerlaw_cluster_graph(100, 1, 1.0, seed)
G = powerlaw_cluster_graph(100, 3, 0.0, seed)
assert G.number_of_edges() == (97 * 3)
G = random_regular_graph(10, 20, seed)
pytest.raises(NetworkXError, random_regular_graph, 3, 21)
pytest.raises(NetworkXError, random_regular_graph, 33, 21)
constructor = [(10, 20, 0.8), (20, 40, 0.8)]
G = random_shell_graph(constructor, seed)
G = random_lobster(10, 0.1, 0.5, seed)
# difficult to find seed that requires few tries
seq = random_powerlaw_tree_sequence(10, 3, seed=14, tries=1)
G = random_powerlaw_tree(10, 3, seed=14, tries=1)
from time import time
min_n = int(input('Min N: '))
max_n = int(input('Max N: '))
test_cases = int(input('Test case amount: '))
test_case_prefix = input('Test case file prefix: ')
for i in range(1, test_cases + 1):
with open(f'{test_case_prefix}.{i}.in', 'w+') as input_file, \
open(f'{test_case_prefix}.{i}.out','w+') as output_file:
n = randint(min_n, max_n)
print(f'Generating test case {i} (n={n})...')
start_time = time()
graph = erdos_renyi_graph(n, random() / 2)
nodes = [randint(-4, 5) for _ in range(n)]
# guaranteed to create a winnable configuration 35% of the time
if random() <= 0.35:
genus = len(graph.edges) - n + 1
node_sum = sum(nodes)
if node_sum < genus:
nodes[randint(0, n - 1)] += genus - node_sum + randint(1, 10)
node_sum = sum(nodes)
if node_sum < 0:
nodes[randint(0, n - 1)] += node_sum + randint(1, 10)
print(
f'-> Completed generating input data... ({round(time() - start_time, 3)} seconds elapsed)'
posts = POST_NUM*[0]
graph = {}
for i in range(USER_NUM):users[i]=round(random.uniform(-1,1),2)
# for i in range(USER_NUM//2):users[i]=round(random.uniform(0,0.5),2)
# for i in range(USER_NUM//2,USER_NUM):users[i]=round(random.uniform(-0.5,0),2)
for i in range(POST_NUM):posts[i]=round(random.uniform(-1,1),2)
# for i in range(POST_NUM//2):posts[i]=round(random.uniform(0.7,1),2)
# for i in range(POST_NUM//2,POST_NUM):posts[i]=round(random.uniform(-1,-0.7),2)
# users.sort()
# posts.sort()
g = erdos_renyi_graph(USER_NUM,0.5)
for x,y in g.edges:
if x not in graph:graph[x] = []
if y not in graph:graph[y] = []
graph[x].append(y)
graph[y].append(x)
datafile = "data_" + str(USER_NUM) + "_" + str(POST_NUM) + "_" + RANGE + ".csv"
with open(datafile, 'w') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerow(users)
csvwriter.writerow(posts)
for i in graph:
def _generate_graph(self, n):
return erdos_renyi_graph(n, self._param[f'{n}'])
def generate_graph(n, p):
g = random_graphs.erdos_renyi_graph(n, p, seed=None, directed=False)
a = nx.adjacency_matrix(g)
return g, a
def test_random_graph(self):
seed = 42
G = gnp_random_graph(100, 0.25, seed)
G = gnp_random_graph(100, 0.25, seed, directed=True)
G = binomial_graph(100, 0.25, seed)
G = erdos_renyi_graph(100, 0.25, seed)
G = fast_gnp_random_graph(100, 0.25, seed)
G = fast_gnp_random_graph(100, 0.25, seed, directed=True)
G = gnm_random_graph(100, 20, seed)
G = gnm_random_graph(100, 20, seed, directed=True)
G = dense_gnm_random_graph(100, 20, seed)
G = watts_strogatz_graph(10, 2, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() == 10
G = connected_watts_strogatz_graph(10, 2, 0.1, tries=10, seed=seed)
assert len(G) == 10
assert G.number_of_edges() == 10
pytest.raises(NetworkXError,
connected_watts_strogatz_graph,
10,
2,
0.1,
tries=0)
G = watts_strogatz_graph(10, 4, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() == 20
G = newman_watts_strogatz_graph(10, 2, 0.0, seed)
assert len(G) == 10
assert G.number_of_edges() == 10
G = newman_watts_strogatz_graph(10, 4, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() >= 20
G = barabasi_albert_graph(100, 1, seed)
G = barabasi_albert_graph(100, 3, seed)
assert G.number_of_edges() == (97 * 3)
G = extended_barabasi_albert_graph(100, 1, 0, 0, seed)
assert G.number_of_edges() == 99
G = extended_barabasi_albert_graph(100, 3, 0, 0, seed)
assert G.number_of_edges() == 97 * 3
G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
assert G.number_of_edges() == 99
G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
assert G.number_of_edges() > 100 * 3
assert G.number_of_edges() < 100 * 4
G = extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
assert G.number_of_edges() > 100 * 2
assert G.number_of_edges() < 100 * 4
G = powerlaw_cluster_graph(100, 1, 1.0, seed)
G = powerlaw_cluster_graph(100, 3, 0.0, seed)
assert G.number_of_edges() == (97 * 3)
G = random_regular_graph(10, 20, seed)
pytest.raises(NetworkXError, random_regular_graph, 3, 21)
pytest.raises(NetworkXError, random_regular_graph, 33, 21)
constructor = [(10, 20, 0.8), (20, 40, 0.8)]
G = random_shell_graph(constructor, seed)
def is_caterpillar(g):
"""
A tree is a caterpillar iff all nodes of degree >=3 are surrounded
by at most two nodes of degree two or greater.
ref: http://mathworld.wolfram.com/CaterpillarGraph.html
"""
deg_over_3 = [n for n in g if g.degree(n) >= 3]
for n in deg_over_3:
nbh_deg_over_2 = [
nbh for nbh in g.neighbors(n) if g.degree(nbh) >= 2
]
if not len(nbh_deg_over_2) <= 2:
return False
return True
def is_lobster(g):
"""
A tree is a lobster if it has the property that the removal of leaf
nodes leaves a caterpillar graph (Gallian 2007)
ref: http://mathworld.wolfram.com/LobsterGraph.html
"""
non_leafs = [n for n in g if g.degree(n) > 1]
return is_caterpillar(g.subgraph(non_leafs))
G = random_lobster(10, 0.1, 0.5, seed)
assert max([G.degree(n) for n in G.nodes()]) > 3
assert is_lobster(G)
pytest.raises(NetworkXError, random_lobster, 10, 0.1, 1, seed)
pytest.raises(NetworkXError, random_lobster, 10, 1, 1, seed)
pytest.raises(NetworkXError, random_lobster, 10, 1, 0.5, seed)
# docstring says this should be a caterpillar
G = random_lobster(10, 0.1, 0.0, seed)
assert is_caterpillar(G)
# difficult to find seed that requires few tries
seq = random_powerlaw_tree_sequence(10, 3, seed=14, tries=1)
G = random_powerlaw_tree(10, 3, seed=14, tries=1)
def create_erdos_renyi_graph(num_nodes, edge_prob):
graph = erdos_renyi_graph(num_nodes, edge_prob)
return graph
def erdos_renyi_network(n, p, seed=None):
return nx2gt(erdos_renyi_graph(n, p, seed))
#!/usr/bin/python
import networkx as nx
import numpy as np
from networkx.generators.random_graphs import erdos_renyi_graph
import matplotlib.pyplot as plt
n = 20000
p = 0.001290309
g = erdos_renyi_graph(n, p)
##nx.draw(g, with_labels=True)
##plt.show()
file1 = open(str(n) + "_sp" + "_nodes.txt", "w+")
for (i, j) in g.edges:
file1.write(str(j) + " " + str(i) + "\n")
file1.close()
def generationGrapheAleatoireEdgarGilbert():
n = int(sys.argv[1])
p = 0.5
g = erdos_renyi_graph(n, p)
EnregistrerGrapheAlea(g)
from networkx.generators.random_graphs import erdos_renyi_graph
from networkx.readwrite.edgelist import read_edgelist, write_edgelist
import logging
import numpy as np
import os
import pickle
import random
import sys
if __name__ == "__main__":
n = 100
p = 0.05
logging.basicConfig(level=logging.INFO)
logging.info('Creating graph...')
G = erdos_renyi_graph(n, p, directed=True)
numOfNodes = G.number_of_nodes()
numOfEdges = G.number_of_edges()
logging.info(
'\n...done. Created a directed Erdos-Renyi graph with %d nodes and %d edges'
% (numOfNodes, numOfEdges))
degrees = dict(list(G.out_degree(G.nodes())))
descending_degrees = sorted(degrees.values(), reverse=True)
evens = set(descending_degrees[::2])
odds = set(descending_degrees[1::2])
# evens = evens.intersection(set(G.nodes()))
# odds = odds.intersection(set(G.nodes()))
target_partitions = {
0: evens,
1: odds
} # create partitions based on their position in the descending_degrees list
#%% using networkx
from networkx.algorithms.bipartite.edgelist import read_edgelist
from networkx.generators.random_graphs import erdos_renyi_graph
from networkx.algorithms.community.modularity_max import greedy_modularity_communities
from networkx.algorithms.community.quality import modularity
netx = read_edgelist(file)
partx = greedy_modularity_communities(netx)
modx_real = modularity(G=netx, communities=partx)
print(f'\nmod_real_nx = {modx_real}')
p = (2. * m) / n**2
netx_er = erdos_renyi_graph(n=n, p=p)
partx = greedy_modularity_communities(netx_er)
modx_rand = modularity(G=netx_er, communities=partx)
print(f'\nmod_random_nx = {modx_rand}')
#%% data plotting
import pandas as pd
import seaborn as sns
import pylab as plt
data = {
'Networks': ['Real network', 'Random', 'Real Network ', 'Random '],
'Modularity': [mod_real, mod_rand, modx_real, modx_rand],
'Class': ['Our Algorithm', 'Our Algorithm', 'NetworkX', 'NetworkX']
