def make_prim_mst(G, generator=None): if generator is None: mst = Graph() else: mst = generator() #priorityQ is a list of list (the reverse of the edge tuple with the weight in the front) priorityQ = [] firstNode = G.nodes()[0] mst.add_node(firstNode) for edge in G.edges_iter(firstNode, data=True): if len(edge) != 3 or edge[2] is None: raise ValueError, "make_prim_mst accepts a weighted graph only (with numerical weights)" heappush(priorityQ, (edge[2], edge)) while len(mst.edges()) < (G.order()-1): w, minEdge = heappop(priorityQ) if len(minEdge) != 3 or minEdge[2] is None: raise ValueError, "make_prim_mst accepts a weighted graph only (with numerical weights)" v1, v2, w = minEdge if v1 not in mst: for edge in G.edges_iter(v1, data=True): if edge == minEdge: continue heappush(priorityQ, (edge[2], edge)) elif v2 not in mst: for edge in G.edges_iter(v2, data=True): if edge == minEdge: continue heappush(priorityQ, (edge[2], edge)) else: # non-crossing edge continue mst.add_edge(minEdge[0],minEdge[1],minEdge[2]) return mst
def root_tree(self, tree: nx.Graph, root_sample: str,
remaining_samples: List[str]):
"""Roots a tree produced by UPGMA.
Adds the root at the top of the UPGMA reconstructed tree. By the
ultrametric assumption, the root is placed as the parent to the last
two unjoined nodes.
Args:
tree: Networkx object representing the tree topology
root_sample: Ignored in this case, the root is known in this case
remaining_samples: The last two unjoined nodes in the tree
Returns:
A rooted tree.
"""
tree.add_node("root")
tree.add_edges_from([("root", remaining_samples[0]),
("root", remaining_samples[1])])
rooted_tree = nx.DiGraph()
for e in nx.dfs_edges(tree, source="root"):
rooted_tree.add_edge(e[0], e[1])
return rooted_tree
def upsert_node(slug: str, g: nx.Graph):
if g.has_node(slug):
return g.nodes[slug]
g.add_node(slug, slug=slug, size=0)
return g.nodes[slug]
def simple_graph():
"""Return a basic graph for testing input/output."""
g = Graph()
g.add_node("034", bipartite=0, name="comp", data={"some": "data"})
g.add_node("1a", bipartite=1, name="jule", data={"mode": "data-y"})
g.add_edge("034", "1a", weight=2, data={"edgey": "data"})
return g
def make_prim_mst(G, generator=None):
if generator is None:
mst = Graph()
else:
mst = generator()
#priorityQ is a list of list (the reverse of the edge tuple with the weight in the front)
priorityQ = []
firstNode = G.nodes()[0]
mst.add_node(firstNode)
for edge in G.edges_iter(firstNode, data=True):
if len(edge) != 3 or edge[2] is None:
raise ValueError, "make_prim_mst accepts a weighted graph only (with numerical weights)"
heappush(priorityQ, (edge[2], edge))
while len(mst.edges()) < (G.order() - 1):
w, minEdge = heappop(priorityQ)
if len(minEdge) != 3 or minEdge[2] is None:
raise ValueError, "make_prim_mst accepts a weighted graph only (with numerical weights)"
v1, v2, w = minEdge
if v1 not in mst:
for edge in G.edges_iter(v1, data=True):
if edge == minEdge:
continue
heappush(priorityQ, (edge[2], edge))
elif v2 not in mst:
for edge in G.edges_iter(v2, data=True):
if edge == minEdge:
continue
heappush(priorityQ, (edge[2], edge))
else:
# non-crossing edge
continue
mst.add_edge(minEdge[0], minEdge[1], minEdge[2])
return mst
def build_graph(metadata):
"""Get a NetworkX Graph object populated from a SQLAlchemy MetaData object.
:param metadata: Reflected SQLAlchemy MetaData object.
:type metadata: MetaData
:returns: Populated and structured NetworkX Graph object.
:rtype: Column
"""
if not isinstance(metadata, MetaData):
raise TypeError("Graph requires MetaData object, "
f"object passed was of type {type(metadata)}.")
graph = Graph(metadata=metadata) # Stores metadata in Graph object.
for table in metadata.tables.keys(): # Creates nodes from all Tables.
table_object = metadata.tables[table]
graph.add_node(table_object.name, table=table_object)
# Stores Table objects in Nodes
for target_table in metadata.tables.keys():
target_table_obj = metadata.tables[target_table]
# Uses the Table object foreign keys to create Graph edges.
for foreign_key in target_table_obj.foreign_keys:
referent_column = foreign_key.column # Retreives source Column
referent_table_obj = referent_column.table
referent_table = referent_table_obj.name
# Stores the foreign key as a table name key pair [Target][Source]
graph.add_edge(target_table, referent_table, key=foreign_key)
return graph
def get_every_station_and_time():
try:
# Ожидание прогрузки элементов страницы.
some_elem_on_page = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable(
(By.XPATH, "//button[@class='decor_button_button']")))
finally:
all_elem = driver.find_elements_by_xpath("//td[@class='flag']/a")
# Создание графа
G = Graph()
temp = None
# Пройти по всем значениям станция/время
for i in range(len(all_elem)):
current_city = driver.find_element_by_xpath(
"//tr[" + str(i + 1) + "]/td[@class='flag']/a").text
current_time = driver.find_element_by_xpath(
"//table[ @ id = 'schedule_table'] / tbody / tr[" +
str(i + 1) + "] / td[3]").text
# Наполнение графа(в разработке)
if temp is None:
G.add_node(current_city, Time=5)
else:
G.add_edge(temp, current_city, Time=6)
temp = current_city
print("Город - ", current_city, ";\t Время - ", current_time)
driver.close()
def _hypernymy_dfs(self, G: nx.Graph, node_cui: str, visited: set, leaf: Dict[str, ConceptNode]) -> int:
""" Depth first search helper function """
visited.add(node_cui)
parents = self._get_parents(node_cui)
parents = [p for p in parents if p not in visited]
parent_depth = []
if parents:
for parent in parents:
parent_depth.append(self._hypernymy_dfs(G, parent, visited, leaf))
current_depth = np.max(parent_depth) + 1
# Add node to graph
if current_depth > 0 or node_cui in leaf:
if node_cui in leaf:
attr = "leaf"
else:
attr = "hypernymy"
G.add_node(node_cui, type=attr)
# Create edge to hypernymy
for p_depth, parent in zip(parent_depth, parents):
if parent in G and p_depth > 0:
G.add_edge(node_cui, parent, weight=p_depth/(p_depth+1), relation="hypernymy")
return current_depth
else:
return -1 # define root depth as -1, ignore the top-2 node
def run(location_geotable):
graph = Graph()
for index, row in location_geotable.iterrows():
graph.add_node(index, **{
'lat': row['Latitude'],
'lon': row['Longitude']
})
for node1_id in range(min(graph), max(graph)):
for node2_id in range(node1_id + 1, max(graph) + 1):
node1_d = graph.node[node1_id]
node2_d = graph.node[node2_id]
node1_ll = node1_d['lat'], node1_d['lon']
node2_ll = node2_d['lat'], node2_d['lon']
distance = get_distance(node1_ll, node2_ll).m
graph.add_edge(node1_id, node2_id, weight=distance)
tree = minimum_spanning_tree(graph)
total_distance = sum(
edge_d['weight']
for node1_id, node2_id, edge_d in tree.edges(data=True))
location_count = len(graph)
average_distance = divide_safely(total_distance, location_count, 0)
return [
('total_distance_between_locations_in_meters', total_distance),
('location_count', location_count),
('average_distance_between_locations_in_meters', average_distance),
]
def generatePairings(self):
for scoreGroup in Pairing.getOrdering(self.round):
playersInGroup = self.groups.get(scoreGroup / 2)
if (playersInGroup == None):
continue
self.K = scoreGroup
self.M = len(playersInGroup)
self.m = Pairing.numberOfFloaters(playersInGroup)
allPossibleEdges = Pairing.pairwise(list(range(1, self.M + 1)))
finalEdges = self.filterOutCollisions(allPossibleEdges)
if (len(finalEdges) == 0):
self.transfer(playersInGroup, scoreGroup)
# Create graph
g = Graph()
for i in range(0, self.M):
g.add_node(playersInGroup[i]['player_id'])
for edge in finalEdges:
weight = 5000 - self.penaltyPoints(edge[0], edge[1])
g.add_edge(playersInGroup[edge[0] - 1]['player_id'], playersInGroup[edge[1] - 1]['player_id'],
weight=weight)
result = max_weight_matching(g, maxcardinality=True) # Edmonds Blossom algorithm
unpaired_players = self.get_unpaired_players(result, scoreGroup / 2) # Get any unpaired players
if len(unpaired_players) > 0: self.transfer(unpaired_players, scoreGroup) # Transfer them to next group
# Might need to do some more processing of the result here
self.pairings = self.pairings + list(result)
return self.pairings
def triangle_graph(regions: List[Polygon], graph: Graph) -> List[Triangle]:
"""
Triangulate regions, connecting into a tree (acyclic digraph) for lookups from triangles to
the original polygon tiling.
:param regions: list of regions to be triangulated
:param graph: graph to be populated with edge from the original polygons to the triangles in their triangulations.
:return: list of all triangles in all regions
"""
logging.debug("Triangulating subdivision of %d regions" % len(regions))
triangles = []
for i, region in enumerate(regions):
logging.debug("Triangulating region %d" % i)
logging.getLogger().handlers[0].flush()
graph.add_node(region, original=True)
if isinstance(region, Triangle):
triangles.append(region)
elif region.n == 3:
region.__class__ = Triangle
triangles.append(region)
else:
# triangulation = region.triangulate()
triangulation = triangulate(region)
for triangle in triangulation:
graph.add_node(triangle, original=False)
graph.add_edge(triangle, region)
triangles.append(triangle)
return triangles
def add_node(self, node=None, pos=None, ori=None, commRange=None):
"""
Add node to network.
Attributes:
`node` -- node to add, default: new node is created
`pos` -- position (x,y), default: random free position in environment
`ori` -- orientation from 0 to 2*pi, default: random orientation
"""
if (not node):
node = Node(commRange=commRange)
assert(isinstance(node, Node))
if not node.network:
node.network = self
else:
logger.warning('Node is already in another network, can\'t add.')
return None
pos = pos if pos is not None else self.find_random_pos(n=100)
ori = ori if ori is not None else rand() * 2 * pi
ori = ori % (2 * pi)
if (self._environment.is_space(pos)):
Graph.add_node(self, node)
self.pos[node] = array(pos)
self.ori[node] = ori
self.labels[node] = str(node.id)
logger.debug('Node %d is placed on position %s.' % (node.id, pos))
self.recalculate_edges([node])
else:
logger.error('Given position is not free space.')
return node
def dpg_maximum(g: nx.Graph):
mm = nx.max_weight_matching(g, maxcardinality=True)
g.remove_edges_from(mm.items())
g.add_node(nx.number_of_nodes(g))
for v in mm.keys():
g.add_edge(v, nx.number_of_nodes(g) - 1)
return g
def network(qmatrix):
""" Creates networkx graph object from a :class:`QMatrix` object.
Vertices have an "open" attribute to indicate whether they are open or shut. Edges have a
"k+" and "k-" attribute containing the transition rates for the node with smaller index to
the node with larger index, and vice-versa.
:param qmatrix:
A :class:`QMatrix` instance for which to construct a graph
:return: A `networkx.Graph` object which contains all the information held by the qmatrix
object, but in a graph format.
"""
from networkx import Graph
graph = Graph()
for i in range(qmatrix.nopen):
graph.add_node(i, open=True)
for j in range(qmatrix.nshut):
graph.add_node(i + j, open=False)
for i in range(qmatrix.matrix.shape[0]):
for j in range(i, qmatrix.matrix.shape[1]):
if abs(qmatrix.matrix[i, j]) > 1e-8:
graph.add_edge(i, j)
graph[i][j]['k+'] = qmatrix.matrix[i, j]
graph[i][j]['k-'] = qmatrix.matrix[j, i]
return graph
def add_node(self, node=None, pos=None, ori=None, commRange=None):
"""
Add node to network.
Attributes:
`node` -- node to add, default: new node is created
`pos` -- position (x,y), default: random free position in environment
`ori` -- orientation from 0 to 2*pi, default: random orientation
"""
if (not node):
node = Node(commRange=commRange)
assert(isinstance(node, Node))
if not node.network:
node.network = self
else:
logger.warning('Node is already in another network, can\'t add.')
return None
pos = pos if pos is not None else self.find_random_pos(n=100)
ori = ori if ori is not None else rand() * 2 * pi
ori = ori % (2 * pi)
if (self._environment.is_space(pos)):
Graph.add_node(self, node)
self.pos[node] = array(pos)
self.ori[node] = ori
self.labels[node] = str(node.id)
logger.debug('Node %d is placed on position %s.' % (node.id, pos))
self.recalculate_edges([node])
else:
logger.error('Given position is not free space.')
return node
def add_break(graph: Graph, segment_ids: [(str, str)]) -> str:
"""
Adds a node that breaks proper segment.
Proper segment is a segment with the smallest angle with positive x-axis.
`segment_ids` - list of tuples. Each tuple consists of two vertexes ids that represents a segment. This means
that there has to be an edge between these vertexes.
Returns id of newly created vertex.
"""
(v1, v2) = get_segment_with_smallest_angle(graph, segment_ids)
layer = graph.nodes[v1]['layer']
v1_pos = graph.nodes[v1]['position']
v2_pos = graph.nodes[v2]['position']
v_x = (v1_pos[0] + v2_pos[0]) / 2
v_y = (v1_pos[1] + v2_pos[1]) / 2
v_pos = (v_x, v_y)
v = gen_name()
graph.add_node(v, layer=layer, position=v_pos, label='E')
graph.remove_edge(v1, v2)
graph.add_edge(v1, v)
graph.add_edge(v2, v)
return v
def to_networkx(self, graph: nx.Graph = None) -> nx.Graph:
"""
Return networkx graph of entities.
Parameters
----------
graph : nx.Graph, optional
Graph to add entities to. If not supplied the function
creates and returns a new graph.
By default None
Returns
-------
nx.Graph
Graph with entity and any connected entities.
"""
graph = graph or nx.Graph()
if not graph.has_node(self):
graph.add_node(self, **self.node_properties)
for edge in self.edges:
if graph.has_edge(edge.source, edge.target):
continue
graph.add_edge(edge.source, edge.target, **edge.attrs)
for node in (edge.source, edge.target):
# If this node has edges that are not in our graph
# call to_networkx recursively on that node.
if any(edge for edge in node.edges
if not graph.has_edge(edge.source, edge.target)):
ent_node = typing.cast(Entity, node)
ent_node.to_networkx(graph)
return graph
def shortest_paths(graph: Graph):
"""
Returns the shortest paths tree from the node with the highest betweenness centrality among trees.
:param graph: graph to consider
:return: shortest path tree
"""
betweenness = nx.betweenness_centrality(graph)
center = max(betweenness, key=betweenness.get)
distances, paths = nx.algorithms.shortest_paths.single_source_dijkstra(
graph, center)
edges = set()
for path in paths.values():
prev = None
for node in path:
if prev is not None:
edges.add((prev, node, graph[prev][node]['weight']))
prev = node
new = Graph()
if edges:
for edge in edges:
new.add_edge(edge[0], edge[1], weight=edge[2])
else:
new.add_node(center)
return new
def find_connected():
for stemmer in [
'Lancaster', 'WordNetLemmatizer', 'PorterStemmer',
'SnowballStemmer'
]:
with open('output_files/window50/%s_dice_filtered.txt' % stemmer, 'r') as sin, \
open('output_files/window50/%s_dice_connected.txt' % stemmer, 'w') as out, \
open('output_files/window50/%s_dice_sconnected.txt' % stemmer, 'w') as out2:
print('building clusters for %s' % stemmer)
g = DiGraph()
g2 = Graph()
nodes = set()
edges = set()
for line in sin:
stemC1C2, dice = line.rstrip().split(' ')
stem, c1, c2 = stemC1C2.split(',')
nodes.add(stem)
nodes.add(c1)
nodes.add(c2)
edges.add((stem, c1, float(dice)))
edges.add((stem, c2, float(dice)))
edges.add((c1, stem, float(dice)))
edges.add((c2, stem, float(dice)))
for n in nodes:
g.add_node(n)
g2.add_node(n)
for stem, term, dice in edges:
g.add_edge(stem, term, weight=dice)
g2.add_edge(stem, term, weight=dice)
for connected in sorted(nx.connected_components(g2),
key=lambda s: list(s)[0]):
out.write('%s\n' % ' '.join(connected))
for connected in sorted(nx.strongly_connected_components(g),
key=lambda s: list(s)[0]):
out2.write('%s\n' % ' '.join(connected))
def network(qmatrix):
""" Creates networkx graph object from a :class:`QMatrix` object.
Vertices have an "open" attribute to indicate whether they are open or shut. Edges have a
"k+" and "k-" attribute containing the transition rates for the node with smaller index to
the node with larger index, and vice-versa.
:param qmatrix:
A :class:`QMatrix` instance for which to construct a graph
:return: A `networkx.Graph` object which contains all the information held by the qmatrix
object, but in a graph format.
"""
from networkx import Graph
graph = Graph()
for i in range(qmatrix.nopen): graph.add_node(i, open=True)
for j in range(qmatrix.nshut): graph.add_node(i+j, open=False)
for i in range(qmatrix.matrix.shape[0]):
for j in range(i, qmatrix.matrix.shape[1]):
if abs(qmatrix.matrix[i,j]) > 1e-8:
graph.add_edge(i, j)
graph[i][j]['k+'] = qmatrix.matrix[i, j]
graph[i][j]['k-'] = qmatrix.matrix[j, i]
return graph
def make_pairings(plrs):
graph = Graph()
plr_ids = [plr["id"] for plr in plrs]
for pid in plr_ids:
graph.add_node(pid)
for pair in combinations(plr_ids, 2):
p1 = get_player(pair[0])
p2 = get_player(pair[1])
corp_player_id, runner_player_id, side_bias_cost = get_side_tuple(
p1, p2)
if side_bias_cost is None:
# print(f"{p1.p_name} v. {p2.p_name} cannot play")
continue
score_cost = calc_score_cost(p1["score"], p2["score"])
# print(f"{p1.p_name} v. {p2.p_name}: {side_bias_cost+score_cost}")
graph.add_edge(
p1,
p2,
weight=1000 - (side_bias_cost + score_cost),
corp_player=corp_player_id,
runner_player=runner_player_id,
)
pairings = max_weight_matching(graph, maxcardinality=True)
aug_pairings = {}
for i, pair in enumerate(pairings):
aug_pairings[i] = {
"corp": graph[pair[0]][pair[1]]["corp_player"],
"runner": graph[pair[0]][pair[1]]["runner_player"],
}
return aug_pairings
def plot_partial_graph(self, action='save'):
""" Plot graphs for edge unveiling. """
uid = 200
while os.path.isfile(f'{uid}_{self.D.name}.png'):
uid += 1
r = lambda: np.random.randint(low=0, high=256)
ng = Graph()
for i in range(self.D.N):
ng.add_node(i + 1)
for u, v in self.D.E:
ng.add_edge(u, v, entropy='')
for w in range(len(self.D.UK)):
ng.add_edge(self.D.UK[w][0],
self.D.UK[w][1],
entropy='{:.3f}'.format(self.action_entropys[w]))
colormap = []
for ee in ng.edges:
if ee in self.D.UK:
colormap.append('red')
else:
colormap.append('black')
plt.figure()
plt.title('Edge Unveiling')
pos = spring_layout(ng)
draw_networkx(ng, pos, node_color='#D3D3D3', edge_color=colormap)
edge_labels = get_edge_attributes(ng, 'entropy')
draw_networkx_edge_labels(ng, pos, edge_labels=edge_labels)
if action == 'save':
plt.savefig(f'{uid}_{self.D.name}.png')
plt.close()
elif action == 'show':
plt.show()
def create_src_tokengraph(dataset,
vocab,
G: nx.Graph = None,
window_size: int = 2):
""" Given a corpus create a token Graph.
Append to graph G if provided.
:param edge_attr: Name of the edge attribute, should match with param name
when calling add_edge().
:param window_size: Sliding window size
:param G:
:param dataset: TorchText dataset
:param vocab: TorchText field containing vocab.
:return:
"""
## Create graph if not exist:
if G is None:
G = nx.Graph()
## Add token's id as node to the graph
for token_txt, token_id in vocab['str2idx_map'].items():
# try:
# token_emb = glove_embs[token_txt]
# except KeyError:
# emb_shape = glove_embs[list(glove_embs.keys())[0]].shape
# glove_embs['<UNK>'] = np.random.uniform(low=0.5, high=0.5,
# size=emb_shape)
# token_emb = glove_embs['<UNK>']
# G.add_node(token_id, node_txt=token_txt, s_co=field.vocab.freqs[
# token_txt], t_co=0, emb=token_emb)
G.add_node(token_id,
node_txt=token_txt,
s_co=vocab['freqs'][token_txt],
t_co=0)
## Add edges based on token co-occurrence within a sliding window:
for txt_toks in dataset:
j = 0
txt_len = len(txt_toks)
if window_size is None or window_size > txt_len:
window_size = txt_len
slide = txt_len - window_size + 1
for k in range(slide):
txt_window = txt_toks[j:j + window_size]
## Co-occurrence in tweet:
occurrences = find_cooccurrences(txt_window)
## Add edges with attribute:
for token_pair, wt in occurrences.items():
node1 = vocab['str2idx_map'][token_pair[0]]
node2 = vocab['str2idx_map'][token_pair[1]]
if G.has_edge(node1, node2):
wt = G.get_edge_data(node1, node2)['s_pair'] + wt
G.add_edge(node1, node2, s_pair=wt, t_pair=0)
j = j + 1
return G
def build_graph_from_tree(G: nx.Graph, level, image_pattern):
for node in level:
G.add_node(node[0], image=image_pattern.format(node[0]))
if node[1] is not None:
build_graph_from_tree(G, node[1], image_pattern)
for child in node[1]:
G.add_edge(node[0], child[0])
def test_integrity(self):
graph = Graph()
initial_node_name = gen_name()
graph.add_node(initial_node_name,
layer=0,
position=(0.5, 0.5),
label='E')
[i1, i2] = P1().apply(graph, [initial_node_name])
[i1_1, i1_2] = P2().apply(graph, [i1])
[i2_1, i2_2] = P2().apply(graph, [i2])
[i3_1, i3_2] = P2().apply(graph, [i1_1])
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
[i4_1, i4_2] = P2().apply(graph, [i1_2])
self.check_graph_integrity(graph, i1, 'i')
self.check_graph_integrity(graph, i2, 'i')
self.check_graph_integrity(graph, i1_1, 'i')
self.check_graph_integrity(graph, i1_2, 'i')
self.check_graph_integrity(graph, i2_1, 'I')
self.check_graph_integrity(graph, i2_2, 'I')
self.check_graph_integrity(graph, i3_1, 'I')
self.check_graph_integrity(graph, i3_2, 'I')
self.check_graph_integrity(graph, i4_1, 'I')
self.check_graph_integrity(graph, i4_2, 'I')
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def derive_b():
graph = Graph()
initial_node_name = gen_name()
graph.add_node(initial_node_name, layer=0, position=(0.5, 0.5), label='E')
visualize_graph_3d(graph)
pyplot.show()
[i1, i2] = P1().apply(graph, [initial_node_name])
visualize_graph_3d(graph)
pyplot.show()
[i1_1, i1_2] = P2().apply(graph, [i1], orientation=1)
[i2_1] = P9().apply(graph, [i2])
visualize_graph_3d(graph)
pyplot.show()
P10().apply(graph, [i1_1, i1_2, i2_1])
visualize_graph_3d(graph)
pyplot.show()
return graph
def network_UKGDS(filename,header=28):
"""
Load Excel file with UKGDS data format and build dict array of bus coordinates
and graph structure suitable for plotting with the networkx module.
"""
from numpy import array,where
from pandas import ExcelFile
from networkx import Graph
data = ExcelFile(filename)
bus = data.parse("Buses",header=header)
branch = data.parse("Branches",header=header)
pos = {}
for node in range(len(bus["BNU"])):
pos.update({node:array([bus["BXC"][node],bus["BYC"][node]])})
net = []
for k in range(len(branch["CFB"])):
von = where(bus["BNU"]==branch["CFB"][k])[0][0]
zu = where(bus["BNU"]==branch["CTB"][k])[0][0]
net.append([von,zu])
nodes = set([n1 for n1,n2 in net] + [n2 for n1,n2 in net])
G = Graph()
for node in nodes:
G.add_node(node)
for edge in net:
G.add_edge(edge[0],edge[1])
return G,pos
def draw_network(bus,branch,bus_names=None,coordinates=None,ax=None):
"""Generate networkx Graph object and draw network diagram
It is assumed that bus and branch ordering corresponds to PyPower format
"""
from networkx import Graph,draw
from matplotlib.pyplot import show
if isinstance(coordinates,np.ndarray):
pos = {}
if coordinates.shape[0]==2:
coordinates = coordinates.T
for node in range(len(bus)):
pos.update({node:coordinates[node,:]})
else:
pos = None
net = []
for k in range(len(branch)):
von = np.where(bus[:,BUS_I]==branch[k,F_BUS])[0][0]
zu = np.where(bus[:,BUS_I]==branch[k,T_BUS])[0][0]
net.append([von,zu])
nodes = set([n1 for n1,n2 in net] + [n2 for n1,n2 in net])
G = Graph()
for node in nodes:
G.add_node(node)
for edge in net:
G.add_edge(edge[0],edge[1])
draw(G,pos,ax=ax)
show()
def test_bad_input_i_label(self):
graph = Graph()
e1 = gen_name()
e2 = gen_name()
e3 = gen_name()
graph.add_node(e1, layer=1, position=(1.0, 2.0), label='E')
graph.add_node(e2, layer=1, position=(1.0, 1.0), label='E')
graph.add_node(e3, layer=1, position=(2.0, 1.0), label='E')
graph.add_edge(e1, e2)
graph.add_edge(e1, e3)
graph.add_edge(e2, e3)
i = add_interior(graph, e1, e2, e3)
graph.nodes[i]['label'] = 'i'
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
with self.assertRaises(AssertionError):
P2().apply(graph, [i])
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def test_happy_path(self):
graph = Graph()
initial_node = gen_name()
graph.add_node(initial_node, layer=0, position=(0.5, 0.5), label='E')
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
P1().apply(graph, [initial_node])
nodes_data = graph.nodes(data=True)
self.assertEqual(len(graph.nodes()), 7)
self.assertEqual(len(graph.edges()), 13)
# check the initial node
initial_node_data = nodes_data[initial_node]
self.assertEqual(initial_node_data['layer'], 0)
self.assertEqual(initial_node_data['position'], (0.5, 0.5))
self.assertEqual(initial_node_data['label'], 'e')
# check other nodes
vx_bl = get_node_at(graph, 1, (0, 0))
vx_br = get_node_at(graph, 1, (1, 0))
vx_tl = get_node_at(graph, 1, (0, 1))
vx_tr = get_node_at(graph, 1, (1, 1))
self.assertIsNotNone(vx_bl)
self.assertIsNotNone(vx_br)
self.assertIsNotNone(vx_tl)
self.assertIsNotNone(vx_tr)
self.assertEqual(nodes_data[vx_bl]['label'], 'E')
self.assertEqual(nodes_data[vx_br]['label'], 'E')
self.assertEqual(nodes_data[vx_tl]['label'], 'E')
self.assertEqual(nodes_data[vx_tr]['label'], 'E')
vx_i1 = get_node_at(graph, 1, (2 / 3, 1 / 3))
vx_i2 = get_node_at(graph, 1, (1 / 3, 2 / 3))
self.assertIsNotNone(vx_i1)
self.assertIsNotNone(vx_i2)
self.assertEqual(nodes_data[vx_i1]['label'], 'I')
self.assertEqual(nodes_data[vx_i2]['label'], 'I')
self.assertTrue(graph.has_edge(initial_node, vx_i1))
self.assertTrue(graph.has_edge(initial_node, vx_i2))
self.assertTrue(graph.has_edge(vx_tl, vx_tr))
self.assertTrue(graph.has_edge(vx_tr, vx_br))
self.assertTrue(graph.has_edge(vx_br, vx_bl))
self.assertTrue(graph.has_edge(vx_bl, vx_tl))
self.assertTrue(graph.has_edge(vx_bl, vx_tr))
self.assertTrue(graph.has_edge(vx_i1, vx_bl))
self.assertTrue(graph.has_edge(vx_i1, vx_br))
self.assertTrue(graph.has_edge(vx_i1, vx_tr))
self.assertTrue(graph.has_edge(vx_i2, vx_bl))
self.assertTrue(graph.has_edge(vx_i2, vx_tl))
self.assertTrue(graph.has_edge(vx_i2, vx_tr))
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def create_render(state): # Should be done once.
g = Graph()
pos = {}
edges = []
index = 0
target = state
dim = len(target)
y_start = dim
x_start = 0
for i in range(dim):
row_dim = len(target[i])
for j in range(row_dim):
g.add_node(index)
# Add Edges
if j > 0 and i + 1 < dim: # Next column, previous row.
edges.append((index, index + row_dim - 1))
if j + 1 < row_dim: # Next in row.
edges.append((index, index + 1))
if i + 1 < dim and j < len(
target[i + 1]): # Next column, next row.
edges.append((index, index + row_dim))
pos[index] = (j + x_start, y_start - j)
index += 1
x_start -= 1
y_start -= 1
g.add_edges_from(edges)
return g, pos
def visualize(self,
g: nx.Graph,
maps: Tuple[Dict[str, str], Dict[int, List[str]]],
path: str = '',
depth: int = 0) -> None:
"""
Helper for creating a visualization of this ExprTree using networkx
and matplotlib.
You do not need to understand this code.
"""
label_map, at_depth = maps
# record all nodes at each depth and create
# nodes (with unique names) and edges in the networkx graph g.
if depth not in at_depth:
at_depth[depth] = []
node_label = path + str(depth) + str(self._root)
at_depth[depth].append(node_label)
label_map[node_label] = str(self._root)
g.add_node(node_label)
i = 0
for c in self._subtrees:
# recursively call visualize on each subtree
c.visualize(g, (label_map, at_depth), path + str(i), depth + 1)
# connect self to each of its children in the graph
g.add_edge(node_label,
path + str(i) + str(depth + 1) + str(c._root))
i += 1
def test_different_position(self):
graph = Graph()
initial_node = gen_name()
graph.add_node(initial_node, layer=0, position=(0, 0), label='E')
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
P1().apply(graph, [initial_node],
positions=[
(0, 0),
(2, 1.5),
(1.5, 2),
(-0.5, 1.5),
])
# check other nodes
vx_bl = get_node_at(graph, 1, (0, 0))
vx_br = get_node_at(graph, 1, (2, 1.5))
vx_tl = get_node_at(graph, 1, (1.5, 2))
vx_tr = get_node_at(graph, 1, (-0.5, 1.5))
self.assertIsNotNone(vx_bl)
self.assertIsNotNone(vx_br)
self.assertIsNotNone(vx_tl)
self.assertIsNotNone(vx_tr)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def test_exceptions():
test = Graph()
test.add_node('a')
assert_raises(NetworkXError, asyn_fluidc, test, 'hi')
assert_raises(NetworkXError, asyn_fluidc, test, -1)
assert_raises(NetworkXError, asyn_fluidc, test, 3)
test.add_node('b')
assert_raises(NetworkXError, asyn_fluidc, test, 1)
def polygon_skeleton(polygon, density=10):
""" Given a buffer polygon, return a skeleton graph.
"""
skeleton = Graph()
points = []
for ring in polygon_rings(polygon):
points.extend(densify_line(list(ring.coords), density))
if len(points) <= 4:
# don't bother with this one
return skeleton
print >> stderr, ' ', len(points), 'perimeter points',
rbox = '\n'.join( ['2', str(len(points))] + ['%.2f %.2f' % (x, y) for (x, y) in points] + [''] )
qvoronoi = Popen('qvoronoi o'.split(), stdin=PIPE, stdout=PIPE)
output, error = qvoronoi.communicate(rbox)
voronoi_lines = output.splitlines()
if qvoronoi.returncode:
raise _QHullFailure('Failed with code %s' % qvoronoi.returncode)
vert_count, poly_count = map(int, voronoi_lines[1].split()[:2])
for (index, line) in enumerate(voronoi_lines[2:2+vert_count]):
point = Point(*map(float, line.split()[:2]))
if point.within(polygon):
skeleton.add_node(index, dict(point=point))
for line in voronoi_lines[2+vert_count:2+vert_count+poly_count]:
indexes = map(int, line.split()[1:])
for (v, w) in zip(indexes, indexes[1:] + indexes[:1]):
if v not in skeleton.node or w not in skeleton.node:
continue
v1, v2 = skeleton.node[v]['point'], skeleton.node[w]['point']
line = LineString([(v1.x, v1.y), (v2.x, v2.y)])
if line.within(polygon):
skeleton.add_edge(v, w, dict(line=line, length=line.length))
removing = True
while removing:
removing = False
for index in skeleton.nodes():
if skeleton.degree(index) == 1:
depth = skeleton.node[index].get('depth', 0)
if depth < 20:
other = skeleton.neighbors(index)[0]
skeleton.node[other]['depth'] = depth + skeleton.edge[index][other]['line'].length
skeleton.remove_node(index)
removing = True
print >> stderr, 'contain', len(skeleton.edge), 'internal edges.'
return skeleton
def main(argv):
if len(argv) < 3:
print("call: translations_spanish_graph.py data_path (bibtex_key|component)")
sys.exit(1)
cr = CorpusReaderDict(argv[1])
dictdata_ids = cr.dictdata_ids_for_bibtex_key(argv[2])
if len(dictdata_ids) == 0:
dictdata_ids = cr.dictdata_ids_for_component(argv[2])
if len(dictdata_ids) == 0:
print("did not find any dictionary data for the bibtex_key or component {0}.".format(argv[2]))
sys.exit(1)
for dictdata_id in dictdata_ids:
gr = Graph()
src_language_iso = cr.src_languages_iso_for_dictdata_id(dictdata_id)
tgt_language_iso = cr.tgt_languages_iso_for_dictdata_id(dictdata_id)
if (src_language_iso != ['spa']) and (tgt_language_iso != ['spa']):
continue
if (len(src_language_iso) > 1) or (len(tgt_language_iso) > 1):
continue
language_iso = None
if tgt_language_iso == [ 'spa' ]:
language_iso = src_language_iso[0]
else:
language_iso = tgt_language_iso[0]
dictdata_string = cr.dictdata_string_id_for_dictata_id(dictdata_id)
bibtex_key = dictdata_string.split("_")[0]
for head, translation in cr.heads_with_translations_for_dictdata_id(dictdata_id):
if src_language_iso == [ 'spa' ]:
(head, translation) = (translation, head)
head_with_source = escape_string("{0}|{1}".format(head, bibtex_key))
translation = escape_string(translation)
#translation_with_language = "{0}|{1}".format(translation, language_iso)
#if head_with_source not in gr:
gr.add_node(head_with_source, attr_dict={ "lang": language_iso, "source": bibtex_key })
#if translation not in gr:
gr.add_node(translation, attr_dict={ "lang": "spa" })
#if not gr.has_edge((head_with_source, translation)):
gr.add_edge(head_with_source, translation)
output = codecs.open("{0}.dot".format(dictdata_string), "w", "utf-8")
output.write(write(gr))
output.close()
def test_single_node():
test = Graph()
test.add_node('a')
# ground truth
ground_truth = set([frozenset(['a'])])
communities = asyn_fluidc(test, 1)
result = {frozenset(c) for c in communities}
assert_equal(result, ground_truth)
def read_gml(graph_file):
graph = Graph()
data = read_gml_data(graph_file)
for n in data['graph']['node']:
graph.add_node(int(n['id']))
for e in data['graph']['edge']:
graph.add_edge(int(e['source']), int(e['target']))
return graph
def read(string):
"""
Read a graph from a string in Dot language and return it. Nodes and
edges specified in the input will be added to the current graph.
Args:
- string: Input string in Dot format specifying a graph.
Returns:
- networkx.Graph object
"""
lines = string.split("\n")
first_line = lines.pop(0)
if not re.match("graph \w+ {$", first_line):
raise WrongDotFormatException("string contains no parseable graph")
re_node = re.compile('^"([^"]*)"(?: \[([^]]*)\])?;?$')
re_edge = re.compile('^"([^"]*)" -- "([^"]*)"(?: \[([^]]*)\])?;?$')
gr = Graph()
for line in lines:
line = line.strip()
match_node = re_node.search(line)
match_edge = re_edge.search(line)
if match_node:
g = match_node.groups()
gr.add_node(g[0])
if g[1]:
for attribute_string in g[1].split(", "):
key, value = attribute_string.split("=")
if value == "True":
value = True
elif value == "False":
value = False
gr.node[g[0]][key] = value
elif match_edge:
g = match_edge.groups()
gr.add_edge(g[0], g[1])
if g[2]:
for attribute_string in g[2].split(", "):
key, value = attribute_string.split("=")
gr.edge[g[0]][g[1]][key] = value
elif line != "}" and len(line) > 0:
raise WrongDotFormatException("Could not parse line:\n\t{0}".format(line))
return gr
def simplify(tree, keepers):
""" Given a tree and a set of nodes to keep, create a new tree
where only the nodes to keep and the branch points between them are preserved.
WARNING: will reroot the tree at the first of the keepers.
WARNING: keepers can't be empty. """
# Ensure no repeats
keepers = set(keepers)
# Add all keeper nodes to the minified graph
mini = Graph()
for node in keepers:
mini.add_node(node)
# Pick the first to be the root node of the tree, removing it
root = keepers.pop()
reroot(tree, root)
# For every keeper node, traverse towards the parent until
# finding one that is in the minified graph, or is a branch node
children = defaultdict(int)
seen_branch_nodes = set(keepers) # a copy
paths = []
# For all keeper nodes except the root
for node in keepers:
path = [node]
paths.append(path)
parents = tree.predecessors(node)
while parents:
parent = parents[0]
if parent in mini:
# Reached one of the keeper nodes
path.append(parent)
break
elif len(tree.successors(parent)) > 1:
# Reached a branch node
children[parent] += 1
path.append(parent)
if parent in seen_branch_nodes:
break
seen_branch_nodes.add(parent)
parents = tree.predecessors(parent)
for path in paths:
# A path starts and ends with desired nodes for the minified tree.
# The nodes in the middle of the path are branch nodes
# that must be added to mini only if they have been visited more than once.
origin = path[0]
for i in xrange(1, len(path) -1):
if children[path[i]] > 1:
mini.add_edge(origin, path[i])
origin = path[i]
mini.add_edge(origin, path[-1])
return mini
def polygon_dots_skeleton(polygon, points):
'''
'''
skeleton = Graph()
rbox = '\n'.join( ['2', str(len(points))] + ['%.2f %.2f' % (x, y) for (x, y) in points] + [''] )
qvoronoi = Popen('qvoronoi o'.split(), stdin=PIPE, stdout=PIPE)
output, error = qvoronoi.communicate(rbox)
voronoi_lines = output.splitlines()
if qvoronoi.returncode:
raise _QHullFailure('Failed with code %s' % qvoronoi.returncode)
vert_count, poly_count = map(int, voronoi_lines[1].split()[:2])
for (index, line) in enumerate(voronoi_lines[2:2+vert_count]):
point = Point(*map(float, line.split()[:2]))
if point.within(polygon):
skeleton.add_node(index, dict(point=point))
for line in voronoi_lines[2+vert_count:2+vert_count+poly_count]:
indexes = map(int, line.split()[1:])
for (v, w) in zip(indexes, indexes[1:] + indexes[:1]):
if v not in skeleton.node or w not in skeleton.node:
continue
v1, v2 = skeleton.node[v]['point'], skeleton.node[w]['point']
line = LineString([(v1.x, v1.y), (v2.x, v2.y)])
if line.within(polygon):
skeleton.add_edge(v, w, dict(line=line, length=line.length))
removing = True
while removing:
removing = False
for index in skeleton.nodes():
if skeleton.degree(index) == 1:
depth = skeleton.node[index].get('depth', 0)
if depth < 20:
other = skeleton.neighbors(index)[0]
skeleton.node[other]['depth'] = depth + skeleton.edge[index][other]['line'].length
skeleton.remove_node(index)
removing = True
logging.debug('found %d skeleton edges' % len(skeleton.edge))
return skeleton
def add_node(self, node=None, pos=None, ori=None, commRange=None, find_random=False):
"""
Add node to network.
Attributes:
`node` -- node to add, default: new node is created
`pos` -- position (x,y), default: random free position in environment
`ori` -- orientation from 0 to 2*pi, default: random orientation
"""
if (not node):
node = Node(commRange=commRange or self.comm_range)
if not node.commRange:
node.commRange = commRange or self.comm_range
assert(isinstance(node, Node))
if not node.network:
node.network = self
else:
logger.warning('Node is already in another network, can\'t add.')
return None
pos = pos if (pos is not None and not isnan(pos[0])) else self.find_random_pos(n=100)
ori = ori if ori is not None else rand() * 2 * pi
ori = ori % (2 * pi)
got_random = False
if find_random and not self._environment.is_space(pos):
pos = self.find_random_pos(n=100)
got_random = True
if (self._environment.is_space(pos)):
Graph.add_node(self, node)
self.pos[node] = array(pos)
self.ori[node] = ori
self.labels[node] = ('C' if node.type == 'C' else "") + str(node.id)
logger.debug('Node %d is placed on position %s %s %s'
% (node.id, pos,
'[energy=%5.3f]' %node.power.energy
if node.power.energy != EnergyModel.E_INIT else '',
'Random' if got_random else ''))
self.recalculate_edges([node])
else:
Node.cid -= 1
logger.error('Given position is not free space. [%s] %s' % (Node.cid, pos))
node = None
return node
def get_coauthor_graph_by_author_name(self, name):
coauthors = set()
for p in self.publications:
for a in p.authors:
if a == self.author_idx[name]:
for a2 in p.authors:
if a != a2:
coauthors.add(a2)
graph = Graph()
# the nodes format will be {"id":int, "name":str}
graph.add_node(self.author_idx[name], name = name)
# graph.add_nodes_from([(i, {"name": all_data[0][i][0]}) for i in range(len(all_data[0]))])
graph.add_nodes_from([(ca, {"name": self.authors[ca].name}) for ca in coauthors])
graph.add_edges_from([(self.author_idx[name], ca) for ca in coauthors])
return graph
def create_graph(sentences):
"""Creates a complete NetworkX graph with the text_place of every sentence
as the nodes. The edge weights are values indicating the similarity
between each sentence.
"""
graph = Graph()
for sentence in sentences:
graph.add_node(sentence.text_place)
# Turn graph into a complete graph
for (s1, s2) in combinations(sentences, 2):
# The weight is derived from the textrank sentence similarity equation
# applied to the reduced forms of the sentences.
similarity_value = similarity(s1.reduced,s2.reduced)
graph.add_edge(s1.text_place, s2.text_place, weight=similarity_value)
return graph
def post_process(self):
trackings = self.parents['irit_harmo_tracking'].results['irit_harmo_tracking'].data_object.value
graph = Graph()
for t, h in [(track, track.harmo_link(trackings)) for track in trackings]:
graph.add_node(t)
if len(h) > 0:
graph.add_edges_from([(t, o) for o in h])
res = self.new_result(time_mode='global')
res.data_object.value = [c2 for c in connected_components(graph) for c2 in Cluster(c).harmo_sub()]
self.add_result(res)
return
def fast_sbm(c_cc, c_cp, c_pp, n):
mav_cc = c_cc * n / 4
mav_cp = c_cp * n / 2
mav_pp = c_pp * n / 4
m_in1 = poisson.rvs(mav_cc)
m_in2 = poisson.rvs(mav_pp)
m_out = poisson.rvs(mav_cp)
G = Graph()
for i in range(n):
G.add_node(i)
# Generate first comm edges
counter = 0
while counter < m_in1:
u = randrange(0,n//2)
v = randrange(0,n//2)
if u != v:
G.add_edge(u,v)
counter += 1
# Generate second comm edges
counter = 0
while counter < m_in2:
u = randrange(n//2,n)
v = randrange(n//2,n)
if u != v:
G.add_edge(u,v)
counter += 1
# Generate between comm edges
counter = 0
while counter < m_out:
u = randrange(0,n//2)
v = randrange(n//2,n)
if u != v:
G.add_edge(u,v)
counter += 1
# Create sparse adjacency matrix
return G
def fast_sbm(c_in, c_out, n):
mav_in = c_in * n / 4.
mav_out = c_out * n / 2.
m_in1 = poisson.rvs(mav_in)
m_in2 = poisson.rvs(mav_in)
m_out = poisson.rvs(mav_out)
G = Graph()
for i in range(n):
G.add_node(i)
# Generate first comm edges
counter = 0
while counter < m_in1:
u = randrange(0,n//2)
v = randrange(0,n//2)
if u != v:
G.add_edge(u,v)
counter += 1
# Generate second comm edges
counter = 0
while counter < m_in2:
u = randrange(n//2,n)
v = randrange(n//2,n)
if u != v:
G.add_edge(u,v)
counter += 1
# Generate between comm edges
counter = 0
while counter < m_out:
u = randrange(0,n//2)
v = randrange(n//2,n)
if u != v:
G.add_edge(u,v)
counter += 1
# Create sparse adjacency matrix
return G
def run(location_geotable):
graph = Graph()
for index, row in location_geotable.iterrows():
graph.add_node(index, {
'lat': row['Latitude'], 'lon': row['Longitude']})
for node1_id in xrange(min(graph), max(graph)):
for node2_id in xrange(node1_id + 1, max(graph) + 1):
node1_d = graph.node[node1_id]
node2_d = graph.node[node2_id]
node1_ll = node1_d['lat'], node1_d['lon']
node2_ll = node2_d['lat'], node2_d['lon']
distance = get_distance(node1_ll, node2_ll).m
graph.add_edge(node1_id, node2_id, weight=distance)
tree = minimum_spanning_tree(graph)
total_distance = sum(edge_d[
'weight'] for node1_id, node2_id, edge_d in tree.edges(data=True))
location_count = len(graph)
average_distance = divide_safely(total_distance, location_count, 0)
return [
('total_distance_between_locations_in_meters', total_distance),
('location_count', location_count),
('average_distance_between_locations_in_meters', average_distance),
]
def generate_dictdata_graph():
gr = Graph()
src_language_iso = cr.src_language_iso_for_dictdata_id(dictdata_id)
tgt_language_iso = cr.tgt_language_iso_for_dictdata_id(dictdata_id)
if src_language_iso != 'spa' and tgt_language_iso != 'spa':
raise(NoSpanishException)
language_iso = None
if tgt_language_iso == 'spa':
language_iso = src_language_iso
else:
language_iso = tgt_language_iso
bibtex_key = dictdata_string.split("_")[0]
for head, translation in cr.heads_with_translations_for_dictdata_id(dictdata_id):
if src_language_iso == 'spa':
(head, translation) = (translation, head)
head_with_source = escape_string("{0}|{1}".format(head, bibtex_key))
translation = escape_string(translation)
#translation_with_language = "{0}|{1}".format(translation, language_iso)
#if head_with_source not in gr:
gr.add_node(head_with_source, attr_dict={ "lang": language_iso, "source": bibtex_key })
#if translation not in gr:
gr.add_node(translation, attr_dict={ "lang": "spa" })
#if not gr.has_edge((head_with_source, translation)):
gr.add_edge(head_with_source, translation)
output = codecs.open(target_file, "w", "utf-8")
output.write(write(gr))
output.close()
class SimpleSectorNetworkCase(unittest.TestCase): def setUp(self): self.G = Graph() self.G.add_node(0, coord=(0., 0.)) self.G.add_node(1, coord=(1., 0.)) self.G.add_node(2, coord=(-0.5, np.sqrt(3.)/2.)) self.G.add_node(3, coord=(0.5, np.sqrt(3.)/2.)) self.G.add_node(4, coord=(1.5, np.sqrt(3.)/2.)) self.G.add_node(5, coord=(0., np.sqrt(3.))) self.G.add_node(6, coord=(1., np.sqrt(3.))) def show_network(self, show=True): plt.scatter(*zip(*[self.G.node[n]['coord'] for n in self.G.nodes()]), marker='s', color='r', s=50) if show: plt.show() def show_polygons(self, show=True): for pol in self.G.polygons.values(): plt.fill(*zip(*list(pol.exterior.coords)), alpha=0.4) if show: plt.show()
def solve():
from networkx import Graph, number_connected_components
from heap.heap import heap
def up(p):
r, c = divmod(p,C)
return (R-1 if r==0 else r-1)*C + c
def down(p):
r, c = divmod(p,C)
return (0 if r==R-1 else r+1)*C + c
def left(p):
r, c = divmod(p,C)
return r*C + (C-1 if c==0 else c-1)
def right(p):
r, c = divmod(p,C)
return r*C + (0 if c==C-1 else c+1)
def link(a,b):
G.add_edge(('start',a),('end',b))
H[b] += 1
R, C = map(int,input().split())
N = R*C
G = Graph()
H = heap({n:0 for n in range(N)})
for p in range(N):
G.add_node(('start',p))
G.add_node(('end',p))
for p, x in enumerate(x for _ in range(R) for x in input().strip()):
if x == '|':
link(p,up(p))
link(p,down(p))
elif x == '-':
link(p,left(p))
link(p,right(p))
elif x == '/':
link(p,down(left(p)))
link(p,up(right(p)))
elif x == '\\':
link(p,up(left(p)))
link(p,down(right(p)))
while H[H.peek()] <= 1:
p, ins = H.popitem()
if ins == 0:
# There is a sqaure such that no other square points to it.
# It's impossible for a lemming to get here.
# So there are no proper ways to arrange this.
return 0
else:
# There is exactly one edge leading into p.
# Remove the relevant nodes.
_, q = next(iter(G['end',p]))
r = next(r for _, r in G['start',q] if r != p)
G.remove_node(('end',p))
G.remove_node(('start',q))
# If q now points to p, the other square that q points to
# has one fewer square pointing to it.
H[r] -= 1
# Now all remaining nodes are cycles, and there are exatly two ways
# to choose the directions for each cycle.
return pow(2,number_connected_components(G),1000003)
class Topo(object):
'''Data center network representation for structured multi-trees.'''
def __init__(self):
'''Create Topo object.
'''
self.g = Graph()
self.node_info = {} # dpids hash to Node objects
self.edge_info = {} # (src_dpid, dst_dpid) tuples hash to Edge objects
self.ports = {} # ports[src][dst] is port on src that connects to dst
self.id_gen = NodeID # class used to generate dpid
def add_node(self, dpid, node):
'''Add Node to graph.
@param dpid dpid
@param node Node object
'''
self.g.add_node(dpid)
self.node_info[dpid] = node
def add_edge(self, src, dst, edge = None):
'''Add edge (Node, Node) to graph.
@param src src dpid
@param dst dst dpid
@param edge Edge object
'''
src, dst = tuple(sorted([src, dst]))
self.g.add_edge(src, dst)
if not edge:
edge = Edge()
self.edge_info[(src, dst)] = edge
self.add_port(src, dst)
def add_port(self, src, dst):
'''Generate port mapping for new edge.
@param src source switch DPID
@param dst destination switch DPID
'''
src_base = SWITCH_PORT_BASE if self.is_switch(src) else 0
dst_base = SWITCH_PORT_BASE if self.is_switch(dst) else 0
if src not in self.ports:
self.ports[src] = {}
if dst not in self.ports[src]:
# num outlinks
self.ports[src][dst] = len(self.ports[src]) + src_base
if dst not in self.ports:
self.ports[dst] = {}
if src not in self.ports[dst]:
# num outlinks
self.ports[dst][src] = len(self.ports[dst]) + dst_base
def node_enabled(self, dpid):
'''Is node connected, admin on, powered on, and fault-free?
@param dpid dpid
@return bool node is enabled
'''
ni = self.node_info[dpid]
return ni.connected and ni.admin_on and ni.power_on and not ni.fault
def nodes_enabled(self, dpids, enabled = True):
'''Return subset of enabled nodes
@param dpids list of dpids
@param enabled only return enabled nodes?
@return dpids filtered list of dpids
'''
if enabled:
return [n for n in dpids if self.node_enabled(n)]
else:
return dpids
def nodes(self, enabled = True):
'''Return graph nodes.
@param enabled only return enabled nodes?
@return dpids list of dpids
'''
return self.nodes_enabled(self.g.nodes(), enabled)
def nodes_str(self, dpids):
'''Return string of custom-encoded nodes.
@param dpids list of dpids
@return str string
'''
return [str(self.id_gen(dpid = dpid)) for dpid in dpids]
def is_switch(self, n):
'''Returns true if node is a switch.'''
return self.node_info[n].is_switch
def switches(self, enabled = True):
'''Return switches.
@param enabled only return enabled nodes?
@return dpids list of dpids
'''
nodes = [n for n in self.g.nodes() if self.is_switch(n)]
return self.nodes_enabled(nodes, enabled)
def hosts(self, enabled = True):
'''Return hosts.
@param enabled only return enabled nodes?
@return dpids list of dpids
'''
def is_host(n):
'''Returns true if node is a host.'''
return not self.node_info[n].is_switch
nodes = [n for n in self.g.nodes() if is_host(n)]
return self.nodes_enabled(nodes, enabled)
def edge_enabled(self, edge):
'''Is edge admin on, powered on, and fault-free?
@param edge (src, dst) dpid tuple
@return bool edge is enabled
'''
src, dst = edge
src, dst = tuple(sorted([src, dst]))
ei = self.edge_info[tuple(sorted([src, dst]))]
return ei.admin_on and ei.power_on and not ei.fault
def edges_enabled(self, edges, enabled = True):
'''Return subset of enabled edges
@param edges list of edges
@param enabled only return enabled edges?
@return edges filtered list of edges
'''
if enabled:
return [e for e in edges if self.edge_enabled(e)]
else:
return edges
def edges(self, enabled = True):
'''Return edges.
@param enabled only return enabled edges?
@return edges list of dpid pairs
'''
return self.edges_enabled(self.g.edges(), enabled)
def edges_str(self, dpid_pairs):
'''Return string of custom-encoded node pairs.
@param dpid_pairs list of dpid pairs (src, dst)
@return str string
'''
edges = []
for pair in dpid_pairs:
src, dst = pair
src = str(self.id_gen(dpid = src))
dst = str(self.id_gen(dpid = dst))
edges.append((src, dst))
return edges
def port(self, src, dst):
'''Get port number.
@param src source switch DPID
@param dst destination switch DPID
@return tuple (src_port, dst_port):
src_port: port on source switch leading to the destination switch
dst_port: port on destination switch leading to the source switch
'''
if src in self.ports and dst in self.ports[src]:
assert dst in self.ports and src in self.ports[dst]
return (self.ports[src][dst], self.ports[dst][src])
def enable_edges(self):
'''Enable all edges in the network graph.
Set admin on, power on, and fault off.
'''
for e in self.g.edges():
src, dst = e
ei = self.edge_info[tuple(sorted([src, dst]))]
ei.admin_on = True
ei.power_on = True
ei.fault = False
def enable_nodes(self):
'''Enable all nodes in the network graph.
Set connected on, admin on, power on, and fault off.
'''
for node in self.g.nodes():
ni = self.node_info[node]
ni.connected = True
ni.admin_on = True
ni.power_on = True
ni.fault = False
def enable_all(self):
'''Enable all nodes and edges in the network graph.'''
self.enable_nodes()
self.enable_edges()
def name(self, dpid):
'''Get string name of node ID.
@param dpid DPID of host or switch
@return name_str string name with no dashes
'''
return self.id_gen(dpid = dpid).name_str()
def ip(self, dpid):
'''Get IP dotted-decimal string of node ID.
@param dpid DPID of host or switch
@return ip_str
'''
return self.id_gen(dpid = dpid).ip_str()
def add_node(self, n, attr_dict=None, **attr):
Graph.add_node(self,n,attr_dict=attr_dict,**attr)
self.fh.write("Add node: %s\n"%n)
class Topo(object):
"Data center network representation for structured multi-trees."
def __init__(self, hopts=None, sopts=None, lopts=None, ropts=None):
"""Topo object:
hinfo: default host options
sopts: default switch options
lopts: default link options"""
self.g = Graph()
self.node_info = {}
self.link_info = {} # (src, dst) tuples hash to EdgeInfo objects
self.hopts = {} if hopts is None else hopts
self.ropts = {} if ropts is None else ropts
self.sopts = {} if sopts is None else sopts
self.lopts = {} if lopts is None else lopts
self.ports = {} # ports[src][dst] is port on src that connects to dst
def addNode(self, name, **opts):
"""Add Node to graph.
name: name
opts: node options
returns: node name"""
self.g.add_node(name)
self.node_info[name] = opts
return name
def addHost(self, name, **opts):
"""Convenience method: Add host to graph.
name: host name
opts: host options
returns: host name"""
if not opts:
if self.hopts:
opts = self.hopts
elif self.ropts:
opts = self.ropts
return self.addNode(name, **opts)
def addSwitch(self, name, **opts):
"""Convenience method: Add switch to graph.
name: switch name
opts: switch options
returns: switch name"""
if not opts and self.sopts:
opts = self.sopts
result = self.addNode(name, isSwitch=True, **opts)
return result
def addLink(self, node1, node2, port1=None, port2=None,
**opts):
"""node1, node2: nodes to link together
port1, port2: ports (optional)
opts: link options (optional)
returns: link info key"""
if not opts and self.lopts:
opts = self.lopts
self.addPort(node1, node2, port1, port2)
key = tuple(self.sorted([node1, node2]))
self.link_info[key] = opts
self.g.add_edge(*key)
return key
def addPort(self, src, dst, sport=None, dport=None):
'''Generate port mapping for new edge.
@param src source switch name
@param dst destination switch name
'''
self.ports.setdefault(src, {})
self.ports.setdefault(dst, {})
# New port: number of outlinks + base
src_base = 1 if self.isSwitch(src) else 0
dst_base = 1 if self.isSwitch(dst) else 0
if sport is None:
sport = len(self.ports[src]) + src_base
if dport is None:
dport = len(self.ports[dst]) + dst_base
self.ports[src][dst] = sport
self.ports[dst][src] = dport
def nodes(self, sort=True):
"Return nodes in graph"
if sort:
return self.sorted( self.g.nodes() )
else:
return self.g.nodes()
def isSwitch(self, n):
'''Returns true if node is a switch.'''
info = self.node_info[n]
return info and info.get('isSwitch', False)
def switches(self, sort=True):
'''Return switches.
sort: sort switches alphabetically
@return dpids list of dpids
'''
return [n for n in self.nodes(sort) if self.isSwitch(n)]
def hosts(self, sort=True):
'''Return hosts.
sort: sort hosts alphabetically
@return dpids list of dpids
'''
return [n for n in self.nodes(sort) if not self.isSwitch(n)]
def links(self, sort=True):
'''Return links.
sort: sort links alphabetically
@return links list of name pairs
'''
if not sort:
return self.g.edges()
else:
links = [tuple(self.sorted(e)) for e in self.g.edges()]
return sorted( links, key=naturalSeq )
def port(self, src, dst):
'''Get port number.
@param src source switch name
@param dst destination switch name
@return tuple (src_port, dst_port):
src_port: port on source switch leading to the destination switch
dst_port: port on destination switch leading to the source switch
'''
if src in self.ports and dst in self.ports[src]:
assert dst in self.ports and src in self.ports[dst]
return (self.ports[src][dst], self.ports[dst][src])
def linkInfo( self, src, dst ):
"Return link metadata"
src, dst = self.sorted([src, dst])
return self.link_info[(src, dst)]
def setlinkInfo( self, src, dst, info ):
"Set link metadata"
src, dst = self.sorted([src, dst])
self.link_info[(src, dst)] = info
def nodeInfo( self, name ):
"Return metadata (dict) for node"
info = self.node_info[ name ]
return info if info is not None else {}
def setNodeInfo( self, name, info ):
"Set metadata (dict) for node"
self.node_info[ name ] = info
@staticmethod
def sorted( items ):
"Items sorted in natural (i.e. alphabetical) order"
return sorted(items, key=natural)
class HybridNetworkCase(unittest.TestCase):
def setUp(self):
#super(HybridNetworkCase, self).__init__()
self.G = Graph()
self.G.add_node(0, coord=(0., 0.))
self.G.add_node(1, coord=(1., 0.))
self.G.add_node(2, coord=(-0.5, np.sqrt(3.)/2.))
self.G.add_node(3, coord=(0.5, np.sqrt(3.)/2.))
self.G.add_node(4, coord=(1.5, np.sqrt(3.)/2.))
self.G.add_node(5, coord=(0., np.sqrt(3.)))
self.G.add_node(6, coord=(1., np.sqrt(3.)))
self.G.G_nav = Graph()
l = np.sqrt(3.)
#pouet = []
# Put six points inside the central sector
center = np.array([0.5, l/2.])
for i in range(6):
angle = float(i)/6.*2.*np.pi
point = center + 0.25*np.array([np.cos(angle), np.sin(angle)])
#pouet.append(list(point))
self.G.G_nav.add_node(i, coord=point)
# Put two points in the 6 outer sectors
for i in range(12):
angle = 1./24.*(2.*np.pi) + float(i)/12.*(2.*np.pi)
point = center + 1.25*np.array([np.cos(angle), np.sin(angle)])
self.G.G_nav.add_node(6 + i, coord=point)
self.G.G_nav.add_node(18, coord=center)
self.G.airports = []
self.G.G_nav.airports = []
def get_airports(G):
return G.airports
self.G.get_airports = types.MethodType(get_airports, self.G)
self.G.G_nav.get_airports = types.MethodType(get_airports, self.G.G_nav)
self.G.G_nav.navpoints_borders = []
def give_nodes_to_secs(self):
self.G.node[3]['navs'] = list(range(6)) + [18]
self.G.node[0]['navs'] = [13, 14]
self.G.node[1]['navs'] = [15, 16]
self.G.node[2]['navs'] = [11, 12]
self.G.node[4]['navs'] = [6, 17]
self.G.node[5]['navs'] = [9, 10]
self.G.node[6]['navs'] = [7, 8]
for i in range(6):
self.G.G_nav.node[i]['sec'] = 3
self.G.G_nav.node[18]['sec'] = 3
self.G.G_nav.node[6]['sec'] = self.G.G_nav.node[17]['sec'] = 4
self.G.G_nav.node[7]['sec'] = self.G.G_nav.node[8]['sec'] = 6
self.G.G_nav.node[9]['sec'] = self.G.G_nav.node[10]['sec'] = 5
self.G.G_nav.node[11]['sec'] = self.G.G_nav.node[12]['sec'] = 2
self.G.G_nav.node[13]['sec'] = self.G.G_nav.node[14]['sec'] = 0
self.G.G_nav.node[15]['sec'] = self.G.G_nav.node[16]['sec'] = 1
def give_full_connections(self):
for i in range(7):
if i!=3:
self.G.add_edge(3, i)
periph_secs = [0, 1, 4, 6, 5, 2]
for idx, n in enumerate(periph_secs):
self.G.add_edge(n, periph_secs[(idx+1)%len(periph_secs)])
for i in range(6):
self.G.G_nav.add_edge(18, i)
self.G.G_nav.add_edge(i, (i+1)%6)
self.G.G_nav.add_edge(i, 2*i+6)
coin = (2*i+5) if (2*i+5)!=5 else 17
self.G.G_nav.add_edge(i, coin)
for i in range(6, 18):
coin = i+1 if i+1 != 18 else 6
self.G.G_nav.add_edge(i, coin)
# print "TEST: Creating the following edges:"
# print self.G.G_nav.edges()
def do_voronoi(self):
self.G, vor = compute_voronoi(self.G, xlims=(-1., 2.), ylims=(-0.5, 2.5))
self.G.polygons = {i:pol for i, pol in self.G.polygons.items() if type(pol)==type(Polygon())}
self.G.global_shape = cascaded_union(self.G.polygons.values())
def show_network(self, secs=True, navs=True, show=True):
if secs:
plt.scatter(*zip(*[self.G.node[n]['coord'] for n in self.G.nodes()]), marker='s', color='r', s=50)
if navs:
plt.scatter(*zip(*[self.G.G_nav.node[n]['coord'] for n in self.G.G_nav.nodes()]), marker='o')
if show:
plt.show()
def show_polygons(self, show=True):
for pol in self.G.polygons.values():
plt.fill(*zip(*list(pol.exterior.coords)), alpha=0.4)
if show:
plt.show()
class GapGraph():
"""
Holds Nodes and Edges of Contig Ends and their Connections.
"""
def __init__(self, gapInfo=None):
self.gapInfo = gapInfo
self.graph = Graph()
if gapInfo is not None:
self.__createGraph()
def __createGraph(self):
"""
Create a graph with
Nodes = Contig Ends (5 and 3) and an arbitrary gap name
Edges = inScaffolding A super heavy PointTo
And reads that map across
Taking these notes to testing/alignTestNotes.txt
Create a graph with nodes == contigNames, Edges == 5' or 3'
"""
for key in self.gapInfo:
gap = self.gapInfo[key]
if gap.endsFlag == (Gap.BEGIN + Gap.END):
if gap.start == 'na': # singleton
prevNode = gap.scaffoldId + "e5"
nextNode = gap.scaffoldId + "e3"
self.graph.add_node(prevNode, extenders=[])
self.graph.add_node(nextNode, extenders=[])
self.graph.add_edge(prevNode, nextNode, evidence=["Contig"])
else:#one gap weirdo
startNode = gap.scaffoldId + "e5"
prevNode = gap.leftContig + "e3"
nextNode = gap.rightContig + "e5"
endNode = gap.scaffoldId + "e3"
self.graph.add_node(startNode, extenders=[])
self.graph.add_node(prevNode, extenders=[])
self.graph.add_node(nextNode, extenders=[])
self.graph.add_node(endNode, extenders=[])
self.graph.add_edge(startNode, prevNode, evidence=["Contig"])
self.graph.add_edge(prevNode, nextNode, evidence=["Scaffold"])
self.graph.add_edge(nextNode, endNode, evidence=["Contig"])
continue
prevNode = gap.leftContig + "e3"
if gap.endsFlag & Gap.BEGIN:#is first gap - get that first contig
startNode = gap.scaffoldId + "e5"
self.graph.add_node(startNode, extenders=[])
self.graph.add_node(prevNode, extenders=[])
self.graph.add_edge(startNode, prevNode, evidence=["Contig"])
nextNode = gap.rightContig + "e5"
if gap.endsFlag & Gap.END:#is last gap
endNode = gap.scaffoldId + "e3"
else:
endNode = gap.rightContig + "e3"
self.graph.add_node(nextNode, extenders=[])
self.graph.add_node(endNode, extenders=[])
self.graph.add_edge(prevNode, nextNode, evidence=["Scaffold"])
self.graph.add_edge(nextNode, endNode, evidence=["Contig"])
def saveBML(self, fileName="briefGraph.bml"):
"""
Only saves the evidence and extenders for the graph.
This is for programatically building a graph quickly.
evidence start end name,name,name
extend start name,name,name
"""
fout = open(fileName,'w')
newGraph = copy.deepcopy(self.graph)
for node in newGraph.nodes_iter():
if len(newGraph.node[node]['extenders']) > 0:
if newGraph.node[node].has_key('extenders'):
fout.write("extend\t%s\t%s\n" % (node, \
"::".join(newGraph.node[node]['extenders'])))
for edgeA, edgeB in newGraph.edges_iter():
ev = filter(lambda x: x != "Scaffold" and x != "Contig", \
newGraph[edgeA][edgeB]['evidence'])
if len(ev) > 0:
fout.write("evidence\t%s\t%s\t%s\n" % (edgeA, edgeB, "::".join(ev)))
fout.close()
def loadBML(self, fileName):
"""
load the evidence and extenders from the BML file
"""
fh = open(fileName,'r')
for line in fh.readlines():
data = line.strip().split('\t')
if data[0] == 'extend':
self.add_extend(data[1].replace('/','.'), data[2].split('::'))
if data[0] == 'evidence':
self.add_evidence(data[1].replace('/','.'), data[2].replace('/','.'), data[3].split('::'))
fh.close()
def saveGraph(self, fileName="graph.gml", spanOnly=False):
"""
Save a gml (default fileName is graph.gml).
if spanOnly, we won't write extenders evidence
"""
newGraph = copy.deepcopy(self.graph)
for node in newGraph.nodes_iter():
if spanOnly:
newGraph.node[node]['extenders'] = ""
else:
newGraph.node[node]['extenders'] = ":".join(newGraph.node[node]['extenders'])
for edge in newGraph.edges_iter():
newGraph[edge[0]][edge[1]]['evidence'] = ":".join(newGraph.get_edge_data(*edge)['evidence'])
write_gml(newGraph, fileName)
def add_extend(self, nodeName, extName):
"""
Takes a string or a list
"""
logging.debug("%s extends %s" % (extName, nodeName))
if not isinstance(extName, list):
extName = [str(extName)]
logging.debug(nodeName)
if nodeName not in self.graph.node:
self.graph.add_node(nodeName, extenders=extName)
else:
self.graph.node[nodeName]['extenders'].extend(extName)
def add_evidence(self, source, target, readName):
"""
Add linkage support to the graph
for span, we add left and then right
same for contains
readName can be a string or a list
"""
if not isinstance(readName, list):
readName = [str(readName)]
if source == target:
logging.warning(("Read %s self-extends Node %s " \
"Possible Evidence of Tandem Repeat on Singleton")\
% (readName, source))
self.add_extend(source, readName)
return
logging.debug("%s gives evidence %s -> %s" % (readName, source, target))
if source not in self.graph.node:
self.graph.add_node(source, extenders=[])
if target not in self.graph.node:
self.graph.add_node(target, extenders=[])
try:
l = [source, target]; l.sort(); source, target = l
self.graph.edge[source][target]['evidence'].extend(readName)
except KeyError:#New edge
self.graph.add_edge(source, target, evidence=readName)
def make_steiner_tree(G, voi, generator=None):
mst = Graph()
for v in voi:
if not v in G:
raise ValueError, "make_steiner_tree(): Some vertice not in original graph"
if len(voi) == 0:
return mst
if len(voi) == 1:
mst.add_node(voi[0])
return mst
# Initially, use (a version of) Kruskal's algorithm to extract a minimal spanning tree
# from a weighted graph. This algorithm differs in that only a subset of vertices are
# going to be present in the final subgraph (which is not truely a MST - must use Prim's
# algorithm later.
# extract all shortest paths among the voi
heapq = []
paths = {}
# load all the paths bwteen the Steiner vertices. Store them in a heap queue
# and reconstruct the MST of the complete graph using Kruskal's algorithm
for i in range(len(voi) - 1):
v1 = voi[i]
for v2 in voi[i+1:]:
result = bidirectional_dijkstra(G, v1, v2)
if result == False:
raise RuntimeError, "The two vertices given (%s, %s) don't exist on the same connected graph" % (v1, v2)
#print "The two vertices given (%s, %s) don't exist on the same connected graph" % (v1, v2)
distance, vertList = result
keys = [v1, v2]
keys.sort()
key = "%s:%s" % tuple(keys)
paths[key] = (vertList)
heappush(heapq, (distance, v1, v2))
# construct the minimum spanning tree of the complete graph
while heapq:
w, v1, v2 = heappop(heapq)
# if no path exists yet between v1 and v2, add this one
if v1 not in mst or v2 not in mst or not has_path(mst, v1, v2):
mst.add_edge(v1, v2,weight=w)
# check if the graph is tree and correct
sTree = set(mst.nodes())
sSteiner = set(voi)
if sTree ^ sSteiner:
raise RuntimeError, 'Failed to construct MST spanning tree'
# reconstruct subgraph of origGraph using the paths
if generator is None:
subgraph = Graph()
else:
subgraph = generator()
for edge in mst.edges_iter(data=True):
keys = [edge[0],edge[1]]
keys.sort()
key = "%s:%s" % tuple(keys)
vList = paths[key]
for i in range(len(vList) - 1):
v1 = vList[i]
v2 = vList[i+1]
w = G[v1][v2]
subgraph.add_edge(v1, v2, w)
# get rid of possible loops - result will be a true MST
subgraph = make_prim_mst(subgraph, generator)
# remove intermediate nodes in paths that are not in list of voi
return _trimTree(subgraph, voi)
class SocialNetwork(object):
"""Object oriented interface for conducting social network analysis."""
valid_indexes = []
for index_name in conf.INDEXES.keys():
valid_indexes.append(index_name)
cache = None
def __init__(self):
logging.info("libSNA object created.")
self.graph = Graph()
self.measures = {}
self.nodesmeasures = {}
self.edgesmeasures = {}
for index in self.valid_indexes: self.measures[index] = None
def getNodes(self):
nodes = self.graph.nodes()
nodes.sort()
return nodes
def getEdges(self):
edges = self.graph.edges()
return edges
def loadGraph(self, nodes, edges):
logging.info("Loading network from input variables")
for node in nodes:
self.graph.add_node(node)
for edge in edges:
self.graph.add_edge(edge[0], edge[1])
self.graph.name = "Social Network"
logging.info("Finished loading network.")
def runMeasure(self, measure_name, backend):
if measure_name in self.valid_indexes:
eval('self.calculate_' + measure_name.replace(' ', '_') + '(backend)')
else:
logging.error("Unable to calculate the measure (%s)"%(measure_name))
def returnResults(self, measure_name, value = 'value'):
if measure_name in self.valid_indexes:
if value == 'value': return self.measures[measure_name]
elif value == 'nodes': return self.nodesmeasures[measure_name]
elif value == 'edges': return self.edgesmeasures[measure_name]
else:
return None
def displayResults(self, measure_name, value = 'value'):
if measure_name in self.valid_indexes:
if value == 'value': logging.info((conf.INDEX_TYPES[measure_name] + '.') % self.measures[measure_name])
elif value == 'nodes': logging.info(str(self.nodesmeasures[measure_name] or '<null>'))
elif value == 'edges': logging.info(str(self.edgesmeasures[measure_name] or '<null>'))
else:
logging.error("Unable to calculate the measure (%s)"%(measure_name))
def calculateMeasures(self, backend=False):
for measure_name in self.valid_indexes:
self.runMeasure(measure_name, backend=False)
def calculate_density(self, backend=False):
logging.info("Calculating density.")
nodes = self.graph.nodes()
edges = self.graph.edges()
tot_edges = float(len(nodes) * (len(nodes)-1))
tot_edges = tot_edges / 2
num_edges = float(len(edges))
w = {}
for n1 in nodes:
for n2 in nodes:
w[n1,n2] = 0.0
for n1,n2 in edges:
w[n1,n2] = 1.0
self.measures['density'] = num_edges / tot_edges * 100
self.nodesmeasures['density'] = None
self.edgesmeasures['density'] = w
def calculate_geodesic(self, backend=False):
logging.info("Calculating geodesic.")
path = self.floyd_warshall(backend)
nodes = self.graph.nodes()
dividend = 0
geodesic = float(0)
geodesic_edges = {}
for i in nodes:
for j in nodes:
try:
geodesic_edges[i,j] = path[i,j]
geodesic += path[i,j]
dividend += 1
except KeyError:
pass
geodesic /= dividend
self.measures['geodesic'] = geodesic
self.nodesmeasures['geodesic'] = None
self.edgesmeasures['geodesic'] = geodesic_edges
def calculate_fragmentation(self, backend=False):
logging.info("Calculating fragmentation.")
nodes = self.graph.nodes()
w = self.floyd_warshall(backend)
fragmentation = float(0)
for i in nodes:
for j in nodes:
try:
w[i,j]
except KeyError:
fragmentation += 1
pass
fragmentation /= len(nodes)*(len(nodes)-1)
self.measures['fragmentation'] = fragmentation * 100
self.nodesmeasures['fragmentation'] = None
self.edgesmeasures['fragmentation'] = w
def calculate_diameter(self, backend=False):
logging.info("Calculating diameter.")
path = self.floyd_warshall(backend)
nodes = self.graph.nodes()
diameter = float(0)
for i in nodes:
for j in nodes:
try:
diameter = max(diameter, path[i,j])
except KeyError:
pass
self.measures['diameter'] = diameter
self.nodesmeasures['diameter'] = None
self.edgesmeasures['diameter'] = path
def calculate_degree(self, backend=False):
logging.info("Calculating degree.")
degrees = degree_centrality(self.graph)
degree = float(sum(degrees.values())/len(degrees.values()))
self.measures['degree'] = degree * 100
self.nodesmeasures['degree'] = degrees
self.edgesmeasures['degree'] = None
def calculate_centralization(self, backend=False):
logging.info("Calculating centralization.")
degrees = degree_centrality(self.graph)
centralization = float(0)
maxdegree = max(degrees.values())
for degree in degrees.values():
centralization += maxdegree-degree
centralization /= len(degrees.values())-1
self.measures['centralization'] = centralization * 100
self.nodesmeasures['centralization'] = degrees
self.edgesmeasures['centralization'] = None
def calculate_closeness(self, backend=False):
logging.info("Calculating closeness.")
closenesses = closeness_centrality(self.graph)
closeness = float(sum(closenesses.values())/len(closenesses.values()))
self.measures['closeness'] = closeness * 100
self.nodesmeasures['closeness'] = closenesses
self.edgesmeasures['closeness'] = None
def calculate_eigenvector(self, backend=False):
logging.info("Calculating eigenvector.")
eigenvectors = eigenvector_centrality(self.graph)
eigenvector = float(sum(eigenvectors.values())/len(eigenvectors.values()))
self.measures['eigenvector'] = eigenvector * 100
self.nodesmeasures['eigenvector'] = eigenvectors
self.edgesmeasures['eigenvector'] = None
def calculate_betweenness(self, backend=False):
logging.info("Calculating betweenness.")
betweennesses = betweenness_centrality(self.graph)
betweenness = float(sum(betweennesses.values())/len(betweennesses.values()))
self.measures['betweenness'] = betweenness * 100
self.nodesmeasures['betweenness'] = betweennesses
self.edgesmeasures['betweenness'] = None
def calculate_cliques(self, backend=False):
logging.info("Calculating cliques.")
cliques = list(find_cliques(self.graph))
w = {}
nodes = self.graph.nodes()
for node in nodes:
w[node] = 0.0
for clique in cliques:
if node in clique:
w[node] += 1
self.measures['cliques'] = len(cliques)
self.nodesmeasures['cliques'] = w
self.edgesmeasures['cliques'] = None
def calculate_comembership(self, backend=False):
logging.info("Calculating comembership.")
nodes = self.graph.nodes()
n = len(nodes)
if not backend and n > 500:
raise network_big.NetworkTooBigException(n)
cliques = list(find_cliques(self.graph))
w = {}
for clique in cliques:
for node1 in clique:
for node2 in clique:
try:
w[node1,node2] += 1
except KeyError:
w[node1,node2] = 1
nodes = w.keys()
comembership = float(0)
for node1, node2 in nodes:
if node1 != node2: comembership += w[node1,node2]
num_nodes = len(self.graph.nodes())
comembership /= num_nodes*(num_nodes-1)
self.measures['comembership'] = comembership
self.nodesmeasures['comembership'] = None
self.edgesmeasures['comembership'] = w
def calculate_components(self, backend=False):
logging.info("Calculating components.")
components = nx.connected_component_subgraphs(self.graph)
w = {}
nodes = self.graph.nodes()
for node in nodes:
w[node] = 0.0
for component in components:
if len(component) > 1:
for node in component:
w[node] += 1
self.measures['components'] = len(components)
self.nodesmeasures['components'] = w
self.edgesmeasures['components'] = None
def floyd_warshall(self, backend):
nodes = self.graph.nodes()
if not backend and len(nodes) > 400:
raise network_big.NetworkTooBigException(len(nodes))
logging.info("Computing Floyd-Warshall.")
infvalue = 127 #sys.maxint
F = nx.floyd_warshall_numpy(self.graph, dtype=np.int8, infvalue=infvalue)
w = {}
for i in range(0, len(nodes)):
for j in range(0, len(nodes)):
if not F[i,j] == infvalue:
w[nodes[i],nodes[j]] = F[i,j]
return w
