def test_directed_node_connectivity():
G = nx.cycle_graph(10, create_using=nx.DiGraph()) # only one direction
D = nx.cycle_graph(10).to_directed() # 2 reciprocal edges
assert_equal(1, approx.node_connectivity(G))
assert_equal(1, approx.node_connectivity(G, 1, 4))
assert_equal(2, approx.node_connectivity(D))
assert_equal(2, approx.node_connectivity(D, 1, 4))
def test_global_node_connectivity():
# Figure 1 chapter on Connectivity
G = nx.Graph()
G.add_edges_from(
[
(1, 2),
(1, 3),
(1, 4),
(1, 5),
(2, 3),
(2, 6),
(3, 4),
(3, 6),
(4, 6),
(4, 7),
(5, 7),
(6, 8),
(6, 9),
(7, 8),
(7, 10),
(8, 11),
(9, 10),
(9, 11),
(10, 11),
]
)
assert 2 == approx.local_node_connectivity(G, 1, 11)
assert 2 == approx.node_connectivity(G)
assert 2 == approx.node_connectivity(G, 1, 11)
def test_directed_node_connectivity():
G = nx.cycle_graph(10, create_using=nx.DiGraph()) # only one direction
D = nx.cycle_graph(10).to_directed() # 2 reciprocal edges
assert_equal(1, approx.node_connectivity(G))
assert_equal(1, approx.node_connectivity(G, 1, 4))
assert_equal(2, approx.node_connectivity(D))
assert_equal(2, approx.node_connectivity(D, 1, 4))
def test_global_node_connectivity():
# Figure 1 chapter on Connectivity
G = nx.Graph()
G.add_edges_from([(1,2),(1,3),(1,4),(1,5),(2,3),(2,6),(3,4),
(3,6),(4,6),(4,7),(5,7),(6,8),(6,9),(7,8),
(7,10),(8,11),(9,10),(9,11),(10,11)])
assert_equal(2, approx.local_node_connectivity(G,1,11))
assert_equal(2, approx.node_connectivity(G))
assert_equal(2, approx.node_connectivity(G,1,11))
def measure_connectivity(G,grouping = None):
overall_conn = approx.node_connectivity(G)
print('Minimum number of nodes that must be removed to disconnect studets: '+str(overall_conn))
pairwise_conn = approx.all_pairs_node_connectivity(G)
plt.title('Distribution of Min Removed Nodes to Disconnect Pair')
plt.hist(pairwise_conn.values())
avg_cluster = approx.average_clustering(G)
print('Mean of the fraction of triangles that actually exist over all possible triangles in each neighborhood: '+str(avg_cluster))
def get_connectivity(prefix, group_id):
userlist, user_info = load_user(prefix, group_id)
filename = util.get_full_prefix(prefix) + "group_" + str(
group_id) + "_user_followers_dic.json"
myFollowerFinder = follower.FollowerFinder(prefix=prefix,
userlist=userlist)
"""generate and save json file"""
TYPE = "undirected"
SAVE_DIR = "gephi/"
g = Graph(myFollowerFinder.load_file(filename=filename), TYPE)
g.build_graph()
g.add_screenname(user_info)
print len(g.get_graph().nodes())
print approx.node_connectivity(g.get_graph())
dic = degree_alg.degree_centrality(g.get_graph())
print sum(dic.values()) / len(dic)
return sum(dic.values()) / len(dic)
def measure_between_group_connectivity(induced, name = '', plots = False):
overall_conn = approx.node_connectivity(induced)
print('Minimum number of nodes that must be removed to disconnect studets: '+str(overall_conn))
pairwise_conn = approx.all_pairs_node_connectivity(induced)
avg_cluster = approx.average_clustering(induced)
print('Mean of the fraction of triangles that actually exist over all possible triangles in each neighborhood: '+str(avg_cluster))
avg_cluster = approx.average_clustering(induced)
print('Mean of the fraction of triangles that actually exist over all possible triangles in each neighborhood: '+str(avg_cluster))
if plots:
p.pairwise_conn_dist(pairwise_conn, name)
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 draw_graph():
"""
Get all edges information and draw the graph of connection of robots.
"""
token = sign_in(args["-u"], args["-p"])
req = {"access_token": token}
resp = access("/api/datagraph", req)
if resp["code"] != 0:
print "[ERROR] get robot edges info error"
# create graph
G = nx.Graph()
# add nodes
# nodes = resp["robot_nodes"]
# for node in nodes:
# graph.add_node(node["username"], group=node["group"])
# add edges
edges = resp["robot_edges"]
weighted_edges = [(e["source"], e["target"], e["weight"]) for e in edges]
G.add_weighted_edges_from(weighted_edges)
# export data with GraphML format
# for example, Cytoscape can read the GraphML format
nx.write_graphml(G, "static/tmp/test.graphml")
# draw graph
nx.draw(G)
# nx.draw_random(G)
# nx.draw_circular(G)
# nx.draw_spectral(G)
plt.show() # need optional dependence matplotlab
# demos the usage of algorithms in networkx
print approx.node_connectivity(G)
def vis_degree_distribution(graph, dynasty):
degree_seq = [d for n, d in graph.degree()]
print(len(degree_seq), approx.node_connectivity(graph))
degree = sorted(degree_seq, reverse=True)
print(min(degree))
degreeCount = collections.Counter(degree)
deg, cnt = zip(*degreeCount.items())
ln_deg = [math.log(i, 10) for i in deg]
ln_cn = [math.log(i, 10) for i in cnt]
# plt.bar(deg, cnt, width=0.8)
ax = plt.subplot()
ax.scatter(ln_deg, ln_cn, marker='+')
# print([i for i in ax.get_xticks()])
print([10**i for i in ax.get_xticks()])
ax.set_xticklabels([round(10**i, 1) for i in ax.get_xticks()])
ax.set_yticklabels([round(10**i, 1) for i in ax.get_yticks()])
ax.set_title(dynasty[0].upper() + dynasty[1:])
#plt.yticks()
ax.set_ylabel('frequency')
ax.set_xlabel('degree')
plt.show()
def test_dodecahedral():
G = nx.dodecahedral_graph()
assert_equal(3, approx.node_connectivity(G))
assert_equal(3, approx.node_connectivity(G, 0, 5))
def test_octahedral():
G = nx.octahedral_graph()
assert_equal(4, approx.node_connectivity(G))
assert_equal(4, approx.node_connectivity(G, 0, 5))
def test_empty_graphs():
for k in range(5, 25, 5):
G = nx.empty_graph(k)
assert_equal(0, approx.node_connectivity(G))
assert_equal(0, approx.node_connectivity(G, 0, 3))
def test_petersen():
G = nx.petersen_graph()
assert_equal(3, approx.node_connectivity(G))
assert_equal(3, approx.node_connectivity(G, 0, 5))
def test_dodecahedral():
G = nx.dodecahedral_graph()
assert_equal(3, approx.node_connectivity(G))
assert_equal(3, approx.node_connectivity(G, 0, 5))
def graphinfo(G):
nodenum = G.number_of_nodes()
edgenum = G.size()
connectivity = approx.node_connectivity(G)
avgdegree = nx.k_nearest_neighbors(G)
def ver_medidas(G):
print(function.info(G))
"""
Numero minimo de nodos que deben ser removidos para desconectar G
"""
print("Numero minimo de nodos que deben ser removidos para desconectar G :"+str(approximation.node_connectivity(G)))
"""
average clustering coefficient of G.
"""
print("average clustering coefficient of G: "+str(approximation.average_clustering(G)))
"""
Densidad de un Grafo
"""
print("Densidad de G: "+str(function.density(G)))
"""
Assortativity measures the similarity of connections in
the graph with respect to the node degree.
Valores positivos de r indican que existe una correlacion entre nodos
con grado similar, mientras que un valor negativo indica
correlaciones entre nodos de diferente grado
"""
print("degree assortativity:"+str(assortativity.degree_assortativity_coefficient(G)))
"""
Assortativity measures the similarity of connections
in the graph with respect to the given attribute.
"""
print("assortativity for node attributes: "+str(assortativity.attribute_assortativity_coefficient(G,"crime")))
"""
Grado promedio vecindad
"""
plt.plot(assortativity.average_neighbor_degree(G).values())
plt.title("Grado promedio vecindad")
plt.xlabel("Nodo")
plt.ylabel("Grado")
plt.show();
"""
Grado de Centralidad de cada nodo
"""
plt.plot(centrality.degree_centrality(G).values())
plt.title("Grado de centralidad")
plt.xlabel("Nodo")
plt.ylabel("Centralidad")
plt.show();
"""
Calcular el coeficiente de agrupamiento para nodos
"""
plt.plot(cluster.clustering(G).values())
plt.title("coeficiente de agrupamiento")
plt.xlabel("Nodo")
plt.show();
"""
Media coeficiente de Agrupamiento
"""
print("Coeficiente de agrupamiento de G:"+str(cluster.average_clustering(G)))
"""
Centro del grafo
El centro de un grafo G es el subgrafo inducido por el
conjunto de vertices de excentricidad minima.
La excentricidad de v in V se define como la
distancia maxima desde v a cualquier otro vertice del
grafo G siguiendo caminos de longitud minima.
"""
print("Centro de G:"+ str(distance_measures.center(G)))
"""
Diametro de un grafo
The diameter is the maximum eccentricity.
"""
print("Diametro de G:"+str(distance_measures.diameter(G)))
"""
Excentricidad de cada Nodo
The eccentricity of a node v is the maximum distance
from v to all other nodes in G.
"""
plt.plot(distance_measures.eccentricity(G).values())
plt.title("Excentricidad de cada Nodo")
plt.xlabel("Nodo")
plt.show();
"""
Periferia
The periphery is the set of nodes with eccentricity equal to the diameter.
"""
print("Periferia de G:")
print(distance_measures.periphery(G))
"""
Radio
The radius is the minimum eccentricity.
"""
print("Radio de G:"+str(distance_measures.radius(G)))
"""
PageRank calcula una clasificacion de los nodos
en el grafico G en funcion de la estructura de
los enlaces entrantes. Originalmente fue disenado
como un algoritmo para clasificar paginas web.
"""
plt.plot(link_analysis.pagerank_alg.pagerank(G).values())
plt.title("Puntaje de cada Nodo")
plt.xlabel("Nodo")
plt.show();
"""
Coeficiente de Small World.
A graph is commonly classified as small-world if sigma>1.
"""
print("Coeficiente de Small World: " + str(smallworld.sigma(G)))
"""
The small-world coefficient (omega) ranges between -1 and 1.
Values close to 0 means the G features small-world characteristics.
Values close to -1 means G has a lattice shape whereas values close
to 1 means G is a random graph.
"""
print("Omega coeficiente: "+str(smallworld.omega(G)))
def test_empty_graphs():
for k in range(5, 25, 5):
G = nx.empty_graph(k)
assert_equal(0, approx.node_connectivity(G))
assert_equal(0, approx.node_connectivity(G, 0, 3))
def test_octahedral():
G = nx.octahedral_graph()
assert 4 == approx.node_connectivity(G)
assert 4 == approx.node_connectivity(G, 0, 5)
print(key,value)
""" Assortativity """
r=nx.degree_pearson_correlation_coefficient(mastodon_digraph)
print(r)
""" Network Analysis Undirected """
mastodon_undirected = mastodon_digraph.to_undirected()
average_node_degree = nx.average_degree_connectivity(mastodon_undirected)
print ("average node degree", average_node_degree.keys())
average_clustering = approx.average_clustering(mastodon_undirected)
print("Average Clustering: ", average_clustering)
node_connectivity = approx.node_connectivity(mastodon_undirected)
print("Node connectivity: ", node_connectivity)
""" Max degree node + Ego Network """
#find node with largest degree
node_and_degree = mastodon_digraph.degree()
(largest_hub, degree) = sorted(node_and_degree, key=itemgetter(1))[-1]
# Create ego graph of main hub
hub_ego = nx.ego_graph(mastodon_digraph, largest_hub)
# Draw graph
pos = nx.spring_layout(hub_ego)
nx.draw(hub_ego, pos, node_color='b', node_size=50, with_labels=False)
# Draw ego as large and red
nx.draw_networkx_nodes(hub_ego, pos, nodelist=[largest_hub], node_size=300, node_color='r')
def test_dodecahedral():
G = nx.dodecahedral_graph()
assert 3 == approx.node_connectivity(G)
assert 3 == approx.node_connectivity(G, 0, 5)
def test_petersen():
G = nx.petersen_graph()
assert 3 == approx.node_connectivity(G)
assert 3 == approx.node_connectivity(G, 0, 5)
def test_icosahedral():
G = nx.icosahedral_graph()
assert_equal(5, approx.node_connectivity(G))
assert_equal(5, approx.node_connectivity(G, 0, 5))
def ncnt():
messagebox.showinfo(
"Info", "Node Connectivity of the graph is {}".format(
apxa.node_connectivity(g)))
def test_icosahedral():
G=nx.icosahedral_graph()
assert_equal(5, approx.node_connectivity(G))
assert_equal(5, approx.node_connectivity(G, 0, 5))
def test_complete_graphs():
for n in range(5, 25, 5):
G = nx.complete_graph(n)
assert_equal(n-1, approx.node_connectivity(G))
assert_equal(n-1, approx.node_connectivity(G, 0, 3))
G.remove_node(13)
G.add_edge(1, 2)
E = (2, 3)
G.add_edge(*E)
G.add_edges_from([(1, 2), (1, 3)])
G.add_edges_from(H.edges())
G.add_edge(1, 8)
G[1][8]['color'] = 'blue'
print '\nDraw out with matplotlib...'
nx.draw(G)
plt.show()
print '\nIterators...'
FG = nx.Graph()
FG.add_weighted_edges_from(
[(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375), (1, 4, 0.175)])
for n, nbrs in FG.adjacency_iter():
for nbr, attr in nbrs.items():
if attr['weight'] < 0.5:
print '(%d, %d, %.3f)' % (n, nbr, attr['weight'])
for (u, v, d) in FG.edges(data='weight'):
if d < 0.5:
print '(%d, %d, %.3f)' % (u, v, d)
print "\nAlgorithms operators..."
print approx.node_connectivity(G)
def test_petersen():
G = nx.petersen_graph()
assert_equal(3, approx.node_connectivity(G))
assert_equal(3, approx.node_connectivity(G, 0, 5))
def test_complete_graphs():
for n in range(5, 25, 5):
G = nx.complete_graph(n)
assert_equal(n - 1, approx.node_connectivity(G))
assert_equal(n - 1, approx.node_connectivity(G, 0, 3))
def test_octahedral():
G=nx.octahedral_graph()
assert_equal(4, approx.node_connectivity(G))
assert_equal(4, approx.node_connectivity(G, 0, 5))
print('#weakly connected component:\t',
number_weakly_connected_components(G),
file=f)
print('Is strongly connected:\t', is_strongly_connected(G), file=f)
print('#strongly connected component:\t',
number_strongly_connected_components(G),
file=f)
print('#node in largest SCC:\t',
len(next(strongly_connected_components(G))),
file=f)
print('#node in largest WCC:\t',
len(next(weakly_connected_components(G))),
file=f)
print('node connectivity (approx.):\t',
approx.node_connectivity(G.to_undirected()),
file=f)
# exact, slow
# print('node connectivity:', node_connectivity(G.to_undirected()))
# print('edge connectivity:', edge_connectivity(G.to_undirected()))
#print('------------DAG-------------', file = f)
print('Is DAG (should be true):\t',
is_directed_acyclic_graph(G),
file=f)
print('Longest path length:\t', dag_longest_path_length(G), file=f)
#print('--------Clustering--------')
# exact, slow
# print('Average clustering coefficient (undirected):', average_clustering(G.to_undirected()))
def node_connectivity(network):
""" Computes the node connectivity for the network. """
connectivity = approx.node_connectivity(network)
return connectivity
def conn2(g, row):
try:
ret = approx.node_connectivity(g, row.question1, row.question2)
except:
return 1
return ret
def graph_node_connectivity(self, source=None, dest=None):
conn = approx.node_connectivity(self.graph, source, dest)
return conn
def get_graph_properties(edges):
# Set up graph
connections = np.array([int(x) for x in edges.split(';')])
nodes = sorted(list(set(connections)))
# Calculate Properties
properties = []
timings = {}
if connections[0] > 0:
edges = connections.reshape(int(connections.size / 2), 2)
timeS = time.time()
# directed graph
G = nx.DiGraph()
G.add_edges_from(edges)
# undirected graph
U = nx.Graph()
U.add_edges_from(edges)
# graph generated
# property 1: number of components
num_comp = nx.number_connected_components(U)
properties.append(num_comp)
# property 2: number of strongly connected components
num_strong_comp = nx.number_strongly_connected_components(G)
properties.append(num_strong_comp)
# property 3: average in/out degree
indeg = []
outdeg = []
indeg_ls = list(G.in_degree())
outdeg_ls = list(G.out_degree())
for x in np.arange(len(nodes)):
indeg.append(indeg_ls[x][1])
outdeg.append(outdeg_ls[x][1])
av_deg = np.mean(indeg)
properties.append(av_deg)
# property 4: link density
linkden = connections.size / (len(nodes) * len(nodes))
properties.append(linkden)
# property 5: number of self loops
numloop = list(G.selfloop_edges())
numloop = len(numloop)
properties.append(numloop)
# # property 6: number of simple cycles (excluding self loops)
# numcyc = list(nx.simple_cycles(G))
# numcyc = len(numcyc) - numloop
# properties.append(numcyc)
# timings.update({'p6':time.time()-timeS})
# print('p6')
# print(timings['p6'])
# timeS = time.time()
# find all components
components = list(nx.connected_components(U))
ischain = [None] * len(components)
istree = [None] * len(components)
isdag = [None] * len(components)
unicel = [None] * len(components)
isscc = [None] * len(components)
iscyc = [None] * len(components)
iseul = [None] * len(components)
indeg_by_comp = []
outdeg_by_comp = []
node_conn = [0] * len(components)
av_clust = [0.] * len(components)
assort = [0.] * len(components)
indeg_cen_av = [0.] * len(components)
indeg_cen_max = [0.] * len(components)
indeg_cen_min = [0.] * len(components)
outdeg_cen_av = [0.] * len(components)
outdeg_cen_max = [0.] * len(components)
outdeg_cen_min = [0.] * len(components)
bet_cen_av = [0.] * len(components)
bet_cen_max = [0.] * len(components)
bet_cen_min = [0.] * len(components)
eig_cen_av = [0.] * len(components)
eig_cen_max = [0.] * len(components)
eig_cen_min = [0.] * len(components)
triangles_av = [0.] * len(components)
triangles_max = [0.] * len(components)
triangles_min = [0.] * len(components)
squares_av = [0.] * len(components)
squares_max = [0.] * len(components)
squares_min = [0.] * len(components)
transitivity = [0.] * len(components)
rc = [0.] * len(components)
loopnumber = [0] * len(components)
for compnum in np.arange(len(components)):
# property 6: ischain?(remove self-loops and then test this property)
# want: how many chains does the graph contain.. look at each component, not the whole graph in one go.
# most graphs are single components.
G1 = G.subgraph(list(components[compnum]))
Gnoself = G1.copy()
Gnoself.remove_edges_from(Gnoself.selfloop_edges())
Unoself = nx.Graph()
Unoself.add_edges_from(Gnoself.edges)
# if all in and out degrees are 1, graph is a chain..do not include in trees
indeg2 = []
outdeg2 = []
indeg_ls2 = list(Gnoself.in_degree())
outdeg_ls2 = list(Gnoself.out_degree())
# nx gives indeg and outdeg as tuples (nodename, in/out deg). which is why i need the for loop below
for x in np.arange(len(G1.nodes())):
indeg2.append(indeg_ls2[x][1])
outdeg2.append(outdeg_ls2[x][1])
indeg_by_comp.append(int_arr_to_str(indeg2, delim=';'))
outdeg_by_comp.append(int_arr_to_str(outdeg2, delim=';'))
indeg2 = np.array(indeg2)
outdeg2 = np.array(outdeg2)
in_min_out = indeg2 - outdeg2
ischain[compnum] = int((np.sum(in_min_out) == 0)
& (np.sum(np.abs(in_min_out)) == 2)
& (np.all(indeg2 <= 1))
& (np.all(outdeg2 <= 1)))
# property 7: istree(remove chains first)
istree[compnum] = int((nx.is_tree(Gnoself) - ischain[compnum]) > 0)
# property 8: isdag(only looking at DAGs other than trees and chains)
isdag[compnum] = int((int(nx.is_directed_acyclic_graph(Gnoself)) -
istree[compnum] - ischain[compnum]) > 0)
if isdag[compnum] > 0:
loopnumber[compnum] = len(list(
Gnoself.edges)) - (len(list(Gnoself.nodes)) - 1)
# property 9: single celled
unicel[compnum] = int(len(Gnoself.nodes) == 1)
istree[compnum] = int(istree[compnum]) - int(
unicel[compnum]
) # nx counts single node with no self-edge as a tree
# property 10: isscc (excluding unicellular)
num_strong_comp2 = nx.number_strongly_connected_components(Gnoself)
isscc[compnum] = int(num_strong_comp2 == 1)
isscc[compnum] = int((isscc[compnum] - unicel[compnum]) > 0)
# property 11: iscyc(cyclic graphs other than those with a single scc and single celled graphs)
iscyc[compnum] = int((isdag[compnum] + istree[compnum] +
ischain[compnum] + isscc[compnum] +
unicel[compnum]) == 0)
# property 12: is eulerian
iseul[compnum] = int(nx.is_eulerian(Gnoself))
# property 13: node connectivity
node_conn[compnum] = approx.node_connectivity(Gnoself)
# property 14: clustering coefficient
av_clust[compnum] = nx.average_clustering(Gnoself)
# property 15: assortativity(pearson's coefficient)
try:
assort[compnum] = nx.degree_pearson_correlation_coefficient(
Gnoself) #####################check
except:
assort[compnum] = 0.0
# property 16,17,18: in degree centrality (average, maximum and minimum)
indeg_cen = []
dict1 = nx.in_degree_centrality(Gnoself)
for a1 in dict1:
indeg_cen.append(dict1[a1])
indeg_cen_av[compnum] = np.average(indeg_cen)
indeg_cen_max[compnum] = max(indeg_cen)
indeg_cen_min[compnum] = min(indeg_cen)
# property 19,20,21: out degree centrality (average, maximum, minimum)
outdeg_cen = []
dict1 = nx.out_degree_centrality(Gnoself)
for a1 in dict1:
outdeg_cen.append(dict1[a1])
outdeg_cen_av[compnum] = np.average(outdeg_cen)
outdeg_cen_max[compnum] = max(outdeg_cen)
outdeg_cen_min[compnum] = min(outdeg_cen)
# property 22,23,24: betweenness centrality (average,maximum, minimum)
bet_cen = []
dict1 = nx.betweenness_centrality(Gnoself)
for a1 in dict1:
bet_cen.append(dict1[a1])
bet_cen_av[compnum] = np.average(bet_cen)
bet_cen_max[compnum] = max(bet_cen)
bet_cen_min[compnum] = min(bet_cen)
# property 25,26,27: eigen vector centrality (average,maximum, minimum)
eig_cen = []
try:
dict1 = nx.eigenvector_centrality(Gnoself)
for a1 in dict1:
eig_cen.append(dict1[a1])
eig_cen_av[compnum] = np.average(eig_cen)
eig_cen_max[compnum] = max(eig_cen)
eig_cen_min[compnum] = min(eig_cen)
except nx.PowerIterationFailedConvergence:
pass
# property 28,29,30: number of triangles for each node (average,maximum, minimum)
triangles = []
dict1 = nx.triangles(Unoself)
for a1 in dict1:
triangles.append(dict1[a1])
if len(triangles):
triangles_av[compnum] = np.average(triangles)
triangles_max[compnum] = max(triangles)
triangles_min[compnum] = min(triangles)
# property 31: transitivity (fraction of all possible triangles present in the graph)
transitivity[compnum] = nx.transitivity(Gnoself)
# property 32,33,34: square clustering for each node(fraction of all possible squares present at a node)
squares = []
dict1 = nx.square_clustering(Gnoself)
for a1 in dict1:
squares.append(dict1[a1])
if len(squares):
squares_av[compnum] = np.average(squares)
squares_max[compnum] = max(squares)
squares_min[compnum] = min(squares)
# propery 35: rich club coefficient
if len(list(Unoself.nodes())) > 3:
rc[compnum] = 0.0
# rc[compnum] = nx.rich_club_coefficient(Unoself).values()# only works if graph has 4 or more edges
# property 36 and 37: number of source and target nodes
iseul = sum(iseul)
iscyc = sum(iscyc)
isscc = sum(isscc)
unicel = sum(unicel)
isdag = sum(isdag)
istree = sum(istree)
ischain = sum(ischain)
indeg_by_comp = ';'.join([str(x) for x in indeg_by_comp])
outdeg_by_comp = ';'.join([str(x) for x in outdeg_by_comp])
node_conn = ';'.join([str(x) for x in node_conn
]) # node connectivity for each component
avav_clust = np.average(
av_clust) # average clustering coefficient over all components
av_clust = ';'.join([
str(round(x, 2)) for x in av_clust
]) # average clustering coefficients for each component
av_assort = np.average(
assort) # average assortativity over all components
assort = ';'.join([str(round(x, 2)) for x in assort
]) # assortativity for each component
indeg_cen_avav = np.average(
indeg_cen_av) # average indeg centrality over all components
indeg_cen_av = ';'.join([
str(round(x, 2)) for x in indeg_cen_av
]) # average indeg centrality for each component
indeg_cen_maxmax = max(
indeg_cen_max) # maximum indeg centrality across all components
indeg_cen_max = ';'.join([
str(round(x, 2)) for x in indeg_cen_max
]) # maximum indeg centrality for each component
indeg_cen_minmin = min(
indeg_cen_min) # minimum indeg centrality across all components
indeg_cen_min = ';'.join([
str(round(x, 2)) for x in indeg_cen_min
]) # minimum indeg centrality for each component
outdeg_cen_avav = np.average(outdeg_cen_av)
outdeg_cen_av = ';'.join([str(round(x, 2)) for x in outdeg_cen_av])
outdeg_cen_maxmax = max(outdeg_cen_max)
outdeg_cen_max = ';'.join([str(round(x, 2)) for x in outdeg_cen_max])
outdeg_cen_minmin = min(outdeg_cen_min)
outdeg_cen_min = ';'.join([str(round(x, 2)) for x in outdeg_cen_min])
bet_cen_avav = np.average(bet_cen_av)
bet_cen_av = ';'.join([str(round(x, 2)) for x in bet_cen_av])
bet_cen_maxmax = max(bet_cen_max)
bet_cen_max = ';'.join([str(round(x, 2)) for x in bet_cen_max])
bet_cen_minmin = min(bet_cen_min)
bet_cen_min = ';'.join([str(round(x, 2)) for x in bet_cen_min])
eig_cen_avav = np.average(eig_cen_av)
eig_cen_av = ';'.join([str(round(x, 2)) for x in eig_cen_av])
eig_cen_maxmax = max(eig_cen_max)
eig_cen_max = ';'.join([str(round(x, 2)) for x in eig_cen_max])
eig_cen_minmin = min(eig_cen_min)
eig_cen_min = ';'.join([str(round(x, 2)) for x in eig_cen_min])
triangles_avav = np.average(triangles_av)
triangles_av = ';'.join([str(x) for x in triangles_av])
triangles_maxmax = max(triangles_max)
triangles_max = ';'.join([str(x) for x in triangles_max])
triangles_minmin = min(triangles_min)
triangles_min = ';'.join([str(x) for x in triangles_min])
transitivity_av = np.average(transitivity)
transitivity_max = max(transitivity)
transitivity_min = min(transitivity)
transitivity = ';'.join([str(x) for x in transitivity])
squares_avav = np.average(squares_av)
squares_maxmax = max(squares_max)
squares_minmin = min(squares_min)
squares_av = ';'.join([str(x) for x in squares_av])
squares_max = ';'.join([str(x) for x in squares_max])
squares_min = ';'.join([str(x) for x in squares_min])
rc_av = np.average(rc)
rc_max = max(rc)
rc_min = min(rc)
rc = ';'.join([str(x) for x in rc])
ln = [loopnumber[x] for x in np.nonzero(loopnumber)[0]]
if any(ln):
loopnumber_av = np.average(ln)
else:
loopnumber_av = 0.0
loopnumber = ';'.join([str(x) for x in loopnumber])
# check.. sum of iscyc, isscc, unicel, dag,tree, chain should be the total number of components
if num_comp != (iscyc + isscc + unicel + isdag + istree + ischain):
print('Number of components is wrong!!!!!!')
print(num_comp)
print([iscyc, isscc, unicel, isdag, istree, ischain])
sys.exit()
properties.append(indeg_by_comp) # string
properties.append(outdeg_by_comp) #string
properties.append(ischain) #int
properties.append(istree) #int
properties.append(isdag) #int
properties.append(unicel) #int
properties.append(isscc) #int
properties.append(iscyc) #int
properties.append(iseul) #int
properties.append(loopnumber_av) #float
properties.append(loopnumber) #string
properties.append(node_conn) #string
properties.append(avav_clust) #float
properties.append(av_clust) #string
properties.append(av_assort) #float
properties.append(assort) #string
properties.append(indeg_cen_avav) #float
properties.append(indeg_cen_av) #string
properties.append(indeg_cen_maxmax) #float
properties.append(indeg_cen_max) #string
properties.append(indeg_cen_minmin) #float
properties.append(indeg_cen_min) #string
properties.append(outdeg_cen_avav) #float
properties.append(outdeg_cen_av) #string
properties.append(outdeg_cen_maxmax) #float
properties.append(outdeg_cen_max) #string
properties.append(outdeg_cen_minmin) #float
properties.append(outdeg_cen_min) #string
properties.append(bet_cen_avav) #float
properties.append(bet_cen_av) #string
properties.append(bet_cen_maxmax) #float
properties.append(bet_cen_max) #string
properties.append(bet_cen_minmin) #float
properties.append(bet_cen_min) #string
properties.append(eig_cen_avav) #float
properties.append(eig_cen_av) #string
properties.append(eig_cen_maxmax) #float
properties.append(eig_cen_max) #string
properties.append(eig_cen_minmin) #float
properties.append(eig_cen_min) #string
properties.append(triangles_avav) #float
properties.append(triangles_av) #string
properties.append(triangles_maxmax) #float
properties.append(triangles_max) #string
properties.append(triangles_minmin) #float
properties.append(triangles_min) #string
properties.append(transitivity_av) # float
properties.append(transitivity_max) #float
properties.append(transitivity_min) #float
properties.append(transitivity) #string
properties.append(squares_avav) #float
properties.append(squares_av) #string
properties.append(squares_maxmax) #float
properties.append(squares_max) #string
properties.append(squares_minmin) #float
properties.append(squares_min) #string
properties.append(rc_av) # float
properties.append(rc_max) #float
properties.append(rc_min) #float
properties.append(rc) #string
# append more properties.....
# property 14:
# property x: in-degree sequence
#indeg = # list(G.in_degree())[iterate over number of nodes][1]
# property y: out-degree sequence
#outdeg = # list(G.in_degree())[iterate over number of nodes][1]
#.....
else:
properties = [0] * 2 + [0.] * 2 + [0] + [''] * 2 + [0] * 7 + [
0.
] + [''] * 2 + [0., ''] * 17 + [0.] * 3 + [''] + [0., ''] * 3 + [
0., 0., 0., ''
]
# return list of properties
return properties