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 _createGraph(self):
dlg = PropertyViewer(self.name, self.icon,
Nodes=Integer(5, 1, 100, 1),
Degree=Integer(2,1,100,1),
TriangleDensity=Float(0.5))
nodes = []
edges = []
if dlg.exec_():
values = dlg.values()
n = values['Nodes']
m = values['Degree']
p = values['TriangleDensity']
G = rnd.powerlaw_cluster_graph(m, n, p)
nodes = layout.circularNodes(n, 25)
for i in G.edges_iter():
edges.append(i)
return nodes, edges
import networkx
import os
import random
import numpy as np
from networkx.generators.random_graphs import powerlaw_cluster_graph
for size in [256, 512, 1024, 2048, 4096, 8192, 16384]:
print("For size: ", size)
g = powerlaw_cluster_graph(size, m=15, p=0.2)
# if not os.path.exists(os.path.join('../datasets', 'syn_' + str(size))):
# os.makedirs(os.path.join('../datasets', 'syn_' + str(size)))
current_dir = os.path.join('../datasets', 'syn_' + str(size))
probs = [0.1, 0.01, 0.001]
thresh = 0.2
nodes = sorted(g.degree, key=lambda x: x[1], reverse=True)
print(nodes[:4])
with open(os.path.join(current_dir, 'seeds.txt'), 'w') as f:
for node in nodes[:5]:
f.write(str(node[0]) + '\n')
with open(os.path.join(current_dir, 'mem.txt'), 'w') as f:
for i in range(size):
vec = np.random.uniform(0, 1, 100)
my_features = np.where(vec < thresh)
# print(my_features[0])
list_f = [str(x) for x in my_features[0]]
# print(list_f)
def powerlawClusterGraph(n,m=3,p=0.3):
graphsToReturn = []
for i in range(100):
print RandomGraphGenerator.powerlaw_cluster_graph, n, i
graphsToReturn.append([i*TIME_UNIT_IN_SECONDS, my_nx.getDictForGraph(powerlaw_cluster_graph(n,m,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)
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)
from math import log
import networkx as nx
import matplotlib.pyplot as plt
from networkx.generators.random_graphs import powerlaw_cluster_graph
from networkx.algorithms.centrality import edge_betweenness_centrality
plt.rcParams["figure.figsize"] = (15, 15)
G = powerlaw_cluster_graph(30, 3, 0.05)
coords = nx.spectral_layout(G) # a different layout this time
rank = nx.pagerank(G) # default damping
print(list(rank.items())[:3])
# normalize to [0, 1] and logscale
low = min(rank.values())
high = max(rank.values())
span = high - low
rank = [log((rank[v] - low) / span + 1) for v in G.nodes()]
opt = {
'node_size': 800,
'width': 3,
'with_labels': True,
'font_color': 'black',
'edge_color': 'orange'
}
fig, ax = plt.subplots()
nx.draw(
G,
pos=coords,
