def graph_1():
G = nx.Graph()
G.add_nodes_from([2, 3, 5, 6, 7])
G.add_edges_from([[2, 3], [5, 3], [6, 7], [7, 2], [5, 7]])
print(list(G.nodes()))
print(list(G.edges()))
print(distance_measures.center(G))
print(distance_measures.periphery(G))
# print(distance_measures.center(G,e={12: 2, 13: 3, 15: 2, 16: 3}))
# print(distance_measures.center(G,e={333: 3}))
print(distance_measures.eccentricity(G))
def runWith(fname) :
print(fname)
gm=dr.GraphMaker()
gm.load(fname)
# dpr=gm.pagerank()
dg=gm.graph()
#for x in dg: print('VERT::', x)
print('nodes:', dg.number_of_nodes())
print('edges:', dg.number_of_edges())
comps=nx.strongly_connected_components(dg)
print('strongly connected components:',len(list(comps)))
c = max(nx.strongly_connected_components(dg), key=len)
mg=dg.subgraph(c)
print('attracting components:', co.number_attracting_components(dg))
print('number_weakly_connected_components:',co.number_weakly_connected_components(dg))
print('Transitivity:',cl.transitivity(dg))
return
e=dm.eccentricity(mg)
dprint('ecc:', e)
cent=dm.center(mg,e=e)
print('CENTER',cent)
p=dm.periphery(mg,e=e)
print('perif:', len(list(e)))
#dprint('perif:', e)
print('diameter:', dm.diameter(nx.Graph(mg)))
print('radius:', dm.radius(nx.Graph(mg)))
g = nx.Graph(dg)
print('omega:', omega(g))
print('sigma:', sigma(g))
def getNodeEccentricity(
self, node: V
) -> Union[int, list[Unknown], dict[Unknown, Any], float, Any, None]:
"""
"""
return eccentricity(self.graph, v=node)
def _build_core_nodes(self):
"""
It builds the list of core nodes
"""
def get_all_nrot_neighbors(self, atom_id, visited_neighbors):
"""
A recursive function that hierarchically visits all atom neighbors
in the graph.
Parameters
----------
atom_id : int
Is is both the id of the graph's node and index of the
corresponding atom
visited_neighbors : set[int]
The ids of the nodes that have already been visited
Returns
-------
visited_neighbors : set[int]
The updated set that contains the ids of the nodes that have
already been visited
"""
if atom_id in visited_neighbors:
return visited_neighbors
visited_neighbors.add(atom_id)
nrot_neighbors = self.nodes[atom_id]['nrot_neighbors']
for nrot_neighbor in nrot_neighbors:
visited_neighbors = get_all_nrot_neighbors(
self, nrot_neighbor, visited_neighbors)
return visited_neighbors
from networkx.algorithms.shortest_paths.generic import \
shortest_path_length
from networkx.algorithms.distance_measures import eccentricity
# Calculate graph distances according to weight values
weighted_distances = dict(shortest_path_length(self, weight="weight"))
# Calculate eccentricites using weighted distances
eccentricities = eccentricity(self, sp=weighted_distances)
# Group nodes by eccentricity
nodes_by_eccentricities = defaultdict(list)
for node, ecc in eccentricities.items():
nodes_by_eccentricities[ecc].append(node)
# Core atoms must have the minimum eccentricity
_, centered_nodes = sorted(nodes_by_eccentricities.items())[0]
# Construct nrot groups with centered nodes
# already_visited = set()
centered_node_groups = list()
for node in centered_nodes:
# if node in already_visited:
# continue
centered_node_groups.append(
get_all_nrot_neighbors(self, node, set()))
# In case of more than one group, core will be the largest
core_nodes = sorted(centered_node_groups, key=len, reverse=True)[0]
# To do: think on what to do with the code below
"""
# Core can hold a maximum of one rotatable bond <- Not true!
# Get all core's neighbors
neighbor_candidates = set()
for node in core_nodes:
neighbors = self.neighbors(node)
for neighbor in neighbors:
if neighbor not in core_nodes:
neighbor_candidates.add(neighbor)
# If any core's neighbor, get the deepest one and include it to
# the core
if len(neighbor_candidates) > 0:
branch_graph = deepcopy(self)
for node in core_nodes:
branch_graph.remove_node(node)
branch_groups = list(nx.connected_components(branch_graph))
rot_bonds_per_group = self._get_rot_bonds_per_group(branch_groups)
best_group = sorted(rot_bonds_per_group, key=len,
reverse=True)[0]
for neighbor in neighbor_candidates:
if any([neighbor in rot_bond for rot_bond in best_group]):
deepest_neighbor = neighbor
break
else:
raise Exception('Unconsistent graph')
deepest_neighbors = get_all_nrot_neighbors(self, deepest_neighbor,
set())
for neighbor in deepest_neighbors:
core_nodes.add(neighbor)
"""
self._core_nodes = core_nodes
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 get_eccentricity(graph):
'''
Calculates the eccentricity of nodes of a given graph.
@return dictionary keying each node to its eccentricity
'''
return nx_dist.eccentricity(graph)
