def shortestPath(self,n): wl=priority_dict.priority_dict() found=priority_dict.priority_dict() for ele in self.__node: if ele!=n: wl[ele]=999999999999 found[n]=0 #initialize: relaxation for ele in found: if ele in self.__edge: for key,value in self.__edge[ele].iteritems(): wl[key]=value while wl: # dequeue the cloest node found[wl.smallest()]=wl[wl.smallest()] #print wl.smallest(), wl[wl.smallest()] wl.pop_smallest() # relaxation for k1,v1 in wl.iteritems(): for k2,v2 in found.iteritems(): if k2 in self.__edge: if k1 in self.__edge[k2]: if found[k2]+self.__edge[k2][k1]<wl[k1]: wl[k1]=found[k2]+self.__edge[k2][k1] return found
def dijkstras_search(origin_key, goal_key, graph):
open_queue = priority_dict.priority_dict({})
open_queue[origin_key] = 0.0
closed_dict = {}
predecessors = {}
goal_found = False
while (open_queue):
u, u_length = open_queue.pop_smallest()
if u == goal_key:
goal_found = True
break
for edge_dict in graph.out_edges([u], data=True):
v = edge_dict[1]
if v in closed_dict:
continue
uv_length = edge_dict[2]['length']
if v not in open_queue:
open_queue[v] = u_length + uv_length
predecessors[v] = u
else:
v_length = open_queue[v]
if u_length + uv_length < v_length:
open_queue[v] = u_length + uv_length
predecessors[v] = u
closed_dict[u] = 1
if not goal_found:
raise ValueError("Goal not found in search.")
return get_path(origin_key, goal_key, predecessors)
def calculateGraphDiameter(self):
connected=self.__graph.isConnected()
if connected==1:
diameter={}
for s in self.__switch:
self.__sp[s]=priority_dict.priority_dict()
diameter[s]=0
sp=shortest_path.shortest_path(self.__switch,self.__edges)
dist=sp.shortestPath(s)
self.__sp[s]=dist.copy()
while (dist and dist[dist.smallest()]!=999999999999):
diameter[s]=dist[dist.smallest()]
dist.pop_smallest()
i=0
max_d=0
for k,v in diameter.iteritems():
if i==0:
max_d=diameter[k]
else:
if (diameter[k]>max_d):
max_d=diameter[k]
i=i+1
self.__graphDiameter=max_d
def set_priority_queue(
V
): # retourne un dictionnaire de priorité dont les clés sont les éléménts de la liste V
F = priority_dict()
for v in V:
F[v] = float('inf')
return F
def spanning_tree(graph, source):
distance_table = {}
for i in range(graph.numVertices):
distance_table[i] = (None, None)
distance_table[source] = (0, source)
priority_queue = priority_dict.priority_dict()
priority_queue[source] = 0
visited_vertices = set()
spanning_tree = set()
while len(priority_queue.keys()) > 0:
current_vertex = priority_queue.pop_smallest()
if current_vertex in visited_vertices:
continue
visited_vertices.add(current_vertex)
if current_vertex != source:
last_vertex = distance_table[current_vertex][1]
edge = str(last_vertex) + "--->" + str(current_vertex)
if edge not in spanning_tree:
spanning_tree.add(edge)
for neighbour in graph.get_adjacent_vertices(current_vertex):
distance = graph.get_edge_weight(current_vertex, neighbour)
neighbour_distance = distance_table[neighbour][0]
if neighbour_distance is None or neighbour_distance > distance:
distance_table[neighbour] = (distance, current_vertex)
priority_queue[neighbour] = distance
for edge in spanning_tree:
print(edge)
def MSTPRIM(G,w,r):
r[0] = 0
Q = priority_dict(G);
while Q:
Q._rebuild_heap()
#print Q
u = Q.smallest()
#print u
global b
if not b:
if not u[0]==None:
if int(u[0])<int(u[1]):
listi.append(u)
else:
v = [u[1],u[0]]
listi.append(v)
w += int(Q[u[1]][0])
u = Q.pop_smallest()
#print u
for v in G[u]:
if isinstance(v, list):
stri = str(v[0])
if v[0] in Q:
if float(v[1]) < float(Q[v[0]][0]):
Q[v[0]][1] = u
Q[v[0]][0] = float(v[1])
b = True
return w
def prim(graph):
'''
>>> graph = {'a': {'b': 7, 'd': 5},
'b': {'a': 7, 'c': 8, 'd': 9, 'e': 7},
'c': {'b': 8, 'e': 5},
'd': {'a': 5, 'e': 15, 'f': 6},
'e': {'b': 7, 'c': 5, 'd': 15, 'f': 8, 'g': 9},
'f': {'d': 6, 'e': 8, 'g': 11},
'g': {'e': 9, 'f': 11}}
>>> prim(graph)
{'d': {'a': 5, 'f': 6},
'a': {'b': 7},
'b': {'e': 7},
'e': {'c': 5, 'g': 9}}
'''
if not connected(graph): raise NotConnectedError('graph is not connected')
predecessor = {}
frontier = priority_dict({iter(graph).next(): 0})
explored = set()
for nearest in frontier.sorted_iter():
for neighbor in graph[nearest]:
if neighbor in explored: continue
displacement = graph[nearest][neighbor]
if neighbor in frontier and displacement > frontier[neighbor]:
continue
else:
frontier[neighbor] = displacement
predecessor[neighbor] = nearest
explored.add(nearest)
return reconstruct_tree(graph, predecessor)
def ACM_Prim():
""" calcule un ACM du graphe stocké sur le serveur en utilisant l'algorithme de Prim """
F = priority_dict()
r = getAVertex()
sommets = set()
sommets.add(r)
F[r] = 0
pere = dict()
pere[r] = None
while F:
u = F.pop_smallest()
for v in getNeighbors(u):
if v not in sommets:
sommets.add(v)
F[v] = float('+infinity')
if v in F and getWeight(u, v) < F[v]:
pere[v] = u
F[v] = getWeight(u, v)
#Calcul du poids w de l'arbre couvrant
w = 0
for v in sommets:
if v != r:
w += getWeight(pere[v], v)
SpanningTreeWeight(w)
def build_distance_table(graph, source):
distance_table = {}
for i in range(graph.numVertices):
distance_table[i] = (None, None)
distance_table[source] = (0, source)
priority_queue = priority_dict.priority_dict()
priority_queue[source] = 0
while len(priority_queue.keys()) > 0:
current_vertex = priority_queue.pop_smallest()
current_distance = distance_table[current_vertex][0]
for neighbor in graph.get_adjacent_vertices(current_vertex):
distance = current_distance + g.get_edge_weight(current_vertex, neighbor)
neighbor_distance = distance_table[neighbor][0]
if neighbor_distance is None or neighbor_distance > distance:
distance_table[neighbor] = (distance, current_vertex)
priority_queue[neighbor] = distance
return distance_table
def dijkstras_search(origin_key, goal_key, graph):
open_queue = priority_dict.priority_dict({})
closed_dict = {}
predecessors = {}
open_queue[origin_key] = 0.0
goal_found = False
while (open_queue):
u, ucost = open_queue.pop_smallest()
if u == goal_key:
goal_found = True
break
for edge in graph.out_edges([u], data=True):
v = edge[1]
if v in closed_dict:
continue
uvcost = edge[2]['length']
if v in open_queue.keys():
if ucost + uvcost < open_queue[v]:
open_queue[v] = ucost + uvcost
predecessors[v] = u
else:
open_queue[v] = ucost + uvcost
predecessors[v] = u
closed_dict[u] = 1
if not goal_found:
raise ValueError("Goal not found in search.")
return get_path(origin_key, goal_key, predecessors)
def build_distance_table(graph, source):
distance_table = {}
for i in range(graph.numVertices):
distance_table[i] = (None, None)
distance_table[source] = (0, source)
# Holding mapping of vertex id to distance from source
# Access the highest priority (lowest distance) item
# first
priority_queue = priority_dict()
priority_queue[source] = 0
while len(priority_queue.keys()) > 0:
current_vertex = priority_queue.pop_smallest(
) # vertex with smallest distance value
# the distance of current node
current_distance = distance_table[current_vertex][0]
for neighbor in graph.get_adjacent_vertices(current_vertex):
distance = current_distance + graph.get_edge_weight(
current_vertex, neighbor)
neighbor_distance = distance_table[neighbor][0]
if neighbor_distance is None or neighbor_distance > distance:
distance_table[neighbor] = (distance, current_vertex)
priority_queue[neighbor] = distance
return distance_table
def build_distance_table(graph, source):
distance_table = {} # vertex and tuple (distance and last preceding node)
for i in range(graph.numVertices):
distance_table[i] = (None, None)
distance_table[source] = (0, source)
priority_queue = priority_dict.priority_dict()
priority_queue[source] = 0
while len(priority_queue.keys()) > 0:
current_vertex = priority_queue.pop_smallest()
current_distance = distance_table[current_vertex][0]
for neighbour in graph.get_adjacent_vertices(current_vertex):
if distance_table[neighbour][0] is None:
distance = (g.get_edge_weight(current_vertex, neighbour) +
current_distance)
neighbour_distance = distance_table[neighbour][0]
if neighbour_distance is None or neighbour_distance > distance > 0:
distance_table[neighbour] = (distance, current_vertex)
priority_queue[neighbour] = distance
return distance_table
def dijkstra(graph, start, end=None):
""" Dijkstra's algorithm for finding shortest paths.
Finds shortest paths from a start node in a graph of Node objects with
graph edges represented as an adjacency list in Node.neighbors. If end is
not None, the algorithm stops when a path to the end node is found.
Otherwise, it continues until a path to all nodes is found.
graph: dict of dicts -- graph[v][k] is weight of edge from nodes v to k
start: start node
end: end node -- if None, paths will be calculated to all reachable nodes
"""
predecessors = {}
distances = {}
queue = priority_dict()
queue[start] = 0
for (dist, node) in queue.sorted_iter():
distances[node] = dist
if node == end:
break
for neigh in graph[node]:
new_dist = dist + graph[node][neigh]
if (neigh not in distances
and (neigh not in queue or new_dist < queue[neigh])):
queue[neigh] = new_dist
predecessors[neigh] = node
return (distances, predecessors)
def find_path_between_points(self, start_tile, end_tile, pathfinder_screen_s):
"""
:param point_a: Tuple(int, int)
:param point_b: Tuple(int, int)
:rtype : List(Tuple)
:rtype time_module: pygame.time
"""
assert isinstance(start_tile, tuple)
assert isinstance(end_tile, tuple)
method_init_time = time.get_ticks()
counter = 0
# Create start and end nodes.
start_node = self.grid.nodes[start_tile]
target_node = self.grid.nodes[end_tile]
# Keep track of the open and closed nodes.
# Add the start node as the first node to start the flood from.
open_nodes = priority_dict()
open_nodes[start_node] = 0
closed_nodes = set()
# start looping
while open_nodes.__len__() > 0:
current_node = open_nodes.pop_smallest()
# Remove the current node from open set and add it to closed set.
#open_nodes.remove(current_node)
closed_nodes.add(current_node)
# Found the end tile.
if current_node == target_node:
complete_path = self.retrace_path(start_node, target_node)
method_run_time = time.get_ticks() - method_init_time
print 'Pathfinding completed in {}ms'.format(method_run_time)
return complete_path
for neighbour_node in self.get_neighbours(current_node):
if neighbour_node in closed_nodes:
continue
assert isinstance(current_node, PathFinder.Node)
assert isinstance(neighbour_node, PathFinder.Node)
new_movement_cost_to_neighbor = current_node.g_cost + 10
# Try to find a lower cost for neighbor, or calculate if it doesn't have one.
if new_movement_cost_to_neighbor < neighbour_node.g_cost or neighbour_node not in open_nodes.keys():
# Calculate the costs for the neighbor
neighbour_node.g_cost = new_movement_cost_to_neighbor
neighbour_node.h_cost = self.get_distance(neighbour_node, target_node)
neighbour_node.parent = current_node
open_nodes[neighbour_node] = neighbour_node.f_cost
def prim(G):
""" calcule un ACM du graphe stocké sur le serveur en utilisant l'algorithme de Prim """
F = priority_dict() # init file priorite
# sommet racine choisit arbitrairement
r = next(iter(G)) # recupere le premier sommet dans le graphe G
F[r] = 0
sommet_atteint = set() # init sommets decouvert
sommet_atteint.add(r) # ajout de r a l ensemble des sommets atteint
pere = dict() # init pere
pere[r] = None # pere du premier = rien
weight = dict(
) # init pour stocker le poids entre 2 sommets, cela evite de le redemander au serveur a la fin pour calculer le poids w de l arbre couvrant
list_sommet_extrait = [] # init liste des sommets extrait
while F:
u = F.pop_smallest()
list_sommet_extrait.append(
u) # ajout de u a la fin de la liste des sommets extrait
for v in getNeighbors(G, u):
if v not in sommet_atteint:
sommet_atteint.add(
v) # si pas atteint alors on l ajoute a l essemble atteint
F[v] = float(
'+infinity'
) # on l ajoute dans la file de prioriter avec comme valeur : +oo
weight_u_v = getWeight(
G, u, v) # stocke dans une var le poids entre u et v
if v in F and weight_u_v < F[v]:
pere[
v] = u # ajoute(ou modifie si deja existant) au dictionaire pere, le pere du sommet v
F[v] = weight_u_v # modifie le poids de v
weight[(u, v)] = weight_u_v # stocker le poids entre u et v
list_pere_sommet = list() # init liste pere sommet
for sommet in list_sommet_extrait:
list_pere_sommet.append(
[pere[sommet], sommet]
) # on ajoute a la fin de la lite une liste tel que : le premier element est le pere et le second est le sommet
#test
#print("algo prim = ", list_sommet_extrait)
#print("\nlist pere sommet = ", list_pere_sommet)
return [
list_sommet_extrait, list_pere_sommet
] # return liste chronologique des sommets atteint, la liste des [pere[sommet], sommet]
def __init__(self, k, t, b):
self.A = priority_dict() # heap of top k elemenets so far
self.k = k
self.t = t
self.b = b
# h_hashes is a family of t hashes from an item to {1,...,b}
self.h_hashes = HashFamily(self.t, self.b)
# s_hashes is a family of t hashes from an item to {+1,-1}
self.s_hashes = HashFamily(self.t, 2)
self.count_sketch = [[0 for i in range(self.b)] for j in range(self.t)]
def find_port(self, router_src, router_dest):
ports = priority_dict()
print "FIND PORT:",router_src.dpid, router_dest.dpid
for edge in self.edges:
print "EDGE: ",edge[0].router.dpid, edge[1].router.dpid
if router_src == edge[0].router and router_dest == edge[1].router:
ports[edge[0]] = self.edges[edge]
if router_src == edge[1].router and router_dest == edge[0].router:
ports[edge[1]] = self.edges[edge]
print ports
return ports.pop_smallest()
def find_port(self, router_src, router_dest):
ports = priority_dict()
for edge in self.edges:
if router_src == edge[0].router and router_dest == edge[1].router:
ports[edge[0]] = self.edges[edge]
if router_src == edge[1].router and router_dest == edge[0].router:
ports[edge[1]] = self.edges[edge]
return ports.pop_smallest()
def __init__(self, information, seq, expSeq):
super(TCPHost, self).__init__(information)
self.seq = seq
self.ack = seq
self.expectACK = seq
self.expectSEQ = expSeq
self.retransqueue = priority_dict.priority_dict()
self.winsize = 0
self.status = 1
# This is the default value if there is no specific MSS given.
self.mss = 512
def spanning_tree(graph):
# Holds a mapping from a pair of edges to the edge weight
# The edge weight is the priority of the edge
priority_queue = priority_dict.priority_dict()
for v in range(graph.numVertices):
for neighbor in graph.get_adjacent_vertices(v):
priority_queue[(v, neighbor)] = graph.get_edge_weight(v, neighbor)
visited_vertices = set()
# Maps a node to all its adjacent nodes which are in the
# minimum spanning tree
spanning_tree = {}
for v in range(graph.numVertices):
spanning_tree[v] = set()
# Number of edges we have got so far
num_edges = 0
while len(priority_queue.keys()) > 0 and num_edges < graph.numVertices - 1:
v1, v2 = priority_queue.pop_smallest()
if v1 in spanning_tree[v2]:
continue
# Arrange the spanning tree so the node with the smaller
# vertex id is always first. This greatly simplifies the
# code to find cycles in this tree
vertex_pair = sorted([v1, v2])
spanning_tree[vertex_pair[0]].add(vertex_pair[1])
# Check if adding the current edge causes a cycle
if has_cycle(spanning_tree):
spanning_tree[vertex_pair[0]].remove(vertex_pair[1])
continue
num_edges = num_edges + 1
visited_vertices.add(v1)
visited_vertices.add(v2)
print("Visited vertices: ", visited_vertices)
if len(visited_vertices) != graph.numVertices:
print("Minimum spanning tree not found")
else:
print("Minimum spanning tree:")
for key in spanning_tree:
for value in spanning_tree[key]:
print(key, "-->", value)
def a_star_search(origin_key, goal_key, graph):
node_data = graph.nodes(True)
open_queue = priority_dict.priority_dict({})
open_queue[origin_key] = distance_heuristic(origin_key, goal_key,
node_data)
closed_dict = {}
predecessors = {}
costs = {}
costs[origin_key] = 0.0
goal_found = False
while open_queue:
u, u_heuristic = open_queue.pop_smallest()
u_length = costs[u]
if u == goal_key:
goal_found = True
break
for edge_dict in graph.out_edges([u], data=True):
v = edge_dict[1]
if v in closed_dict:
continue
uv_length = edge_dict[2]['length']
if v not in open_queue:
costs[v] = u_length + uv_length
open_queue[v] = u_length + uv_length + distance_heuristic(
v, goal_key, node_data)
predecessors[v] = u
else:
v_length = costs[v]
if u_length + uv_length < v_length:
costs[v] = u_length + uv_length
open_queue[v] = u_length + uv_length + distance_heuristic(
v, goal_key, node_data)
predecessors[v] = u
closed_dict[u] = 1
if not goal_found:
raise ValueError("Goal not found in search.")
return get_path(origin_key, goal_key, predecessors)
def calculateNodeFreq(self): self.ctrCover() nodefreqpair=priority_dict.priority_dict() for ele in self.__switch: nodefreqpair[ele]=0 maxFreq=0 for k,v in self.__ctrCover.iteritems(): countNode=0 for ele in self.__switch: if ele in v: nodefreqpair[ele]=nodefreqpair[ele]+1 self.__nf=nodefreqpair
def spanning_tree(graph):
priority_queue = priority_dict.priority_dict()
for v in range(graph.numVertices):
for neighbor in graph.get_adjacent_vertices(v):
print(neighbor)
priority_queue[(v, neighbor)] = graph.get_edge_weight(v, neighbor)
visited_vertices = set()
spanning_tree = {}
for v in range(graph.numVertices):
spanning_tree[v] = set()
num_edges = 0
while len(priority_queue.keys()) > 0 and num_edges < graph.numVertices - 1:
v1, v2 = priority_queue.pop_smallest()
print(v1, v2)
if v1 in spanning_tree[v2]:
continue
vertex_pair = sorted([v1, v2])
spanning_tree[vertex_pair[0]].add(vertex_pair[1])
if has_cycle(spanning_tree):
spanning_tree[vertex_pair[0]].remove(vertex_pair[1])
continue
num_edges = num_edges + 1
visited_vertices.add(v1)
visited_vertices.add(v2)
print("Visited vertices: ", visited_vertices)
if len(visited_vertices) != graph.numVertices:
print("Minimum spanning tree not found")
else:
print("Minimum spanning tree:")
for key in spanning_tree:
for value in spanning_tree[key]:
print(key, "-->", value)
def dijkstras_search(origin_key, goal_key, graph):
# The priority queue of open vertices we've reached.
# Keys are the vertex keys, vals are the distances.
open_queue = priority_dict.priority_dict({})
# The dictionary of closed vertices we've processed.
closed_dict = {}
# The dictionary of predecessors for each vertex.
predecessors = {}
# Add the origin to the open queue.
open_queue[origin_key] = 0.0
# Iterate through the open queue, until we find the goal.
# Each time, perform a Dijkstra's update on the queue.
# TODO(done): Implement the Dijstra update loop.
goal_found = False
while (open_queue):
vtx, dis = open_queue.pop_smallest()
if (vtx == goal_key):
goal_found = True
break
for edge in graph.out_edges([vtx], data=True):
next_vtx = edge[1]
if next_vtx in closed_dict:
continue
weight = edge[2]['length']
if next_vtx in open_queue:
if dis + weight < open_queue[next_vtx]:
open_queue[next_vtx] = dis + weight
predecessors[next_vtx] = vtx
else:
open_queue.update({next_vtx: dis + weight})
predecessors.update({next_vtx: vtx})
closed_dict.update({vtx: dis})
# If we get through entire priority queue without finding the goal,
# something is wrong.
if not goal_found:
raise ValueError("Goal not found in search.")
# Construct the path from the predecessors dictionary.
return get_path(origin_key, goal_key, predecessors)
def __init__(self,ng,ca,d,theta,ctr,mu): self.__ng=ng self.__switch=self.__ng.getSwitch() self.__edge=self.__ng.getGraph() self.__controller=ctr self.__ca=ca self.__d=d self.__theta=theta self.__sp=shortest_path.shortest_path(self.__switch,self.__edge) self.__nf=priority_dict.priority_dict() self.__minFreq=dict() self.__avgFreq=dict() self.__res=dict() for k in self.__controller: self.__res[k]=mu self.__cost=[] self.__initialSet=dict() self.__ctrCover=dict() self.__mu=mu
def tsp(
n, edges
): # Dijkstra, bit, heap-dict from from https://gist.github.com/matteodellamico/4451520
import priority_dict
def solution(nodeset, v):
if nodeset == 1: return [0]
u = back[nodeset, v]
return solution(nodeset - (1 << v), u) + [v % n]
t0 = time.time()
edge = defaultdict(lambda: defaultdict(lambda: float('inf')))
for u, v, w in edges:
edge[u][v] = min(edge[u][v], w) # possible duplicate edges
edge[v][u] = min(edge[v][u], w) # undirected
for u in range(1, n):
edge[u][n] = edge[u][0] # clone a dummy sink n, which is 0
d = priority_dict.priority_dict()
d[1, 0] = (
0, None
) # d[nodeset,last] = (dist,prev), the best dist for 0->nodeset->last is dist, and we have the prev of last
back = {}
npop = npush = 0
fullset, fullsetplus = (1 << n) - 1, (
1 << n + 1) - 1 # + has high priority than <<
while d:
(nodeset, u), (dist, prev) = d.pop_smallest()
npop += 1
if (nodeset, u) in back: continue
back[nodeset, u] = prev
if nodeset == fullsetplus:
print('Dijkstra, heapdict, time: {0:.3f}, push: {1}, pop: {2}'.
format(time.time() - t0, npush, npop))
return dist, solution(nodeset, u)
for v in range(1, n) if nodeset < fullset else [n]:
if v in edge[u] and not (1 << v & nodeset):
newset = 1 << v | nodeset
if (newset, v) in back: continue
newdis = dist + edge[u][v]
if (newset, v) in d and newdis >= d[newset, v][0]: continue
d[newset, v] = newdis, u
npush += 1
def tsp_dijk_bit_pqdict(n, _edges): # the Dijkstra implementation
def backtrace(nodeset, j):
if nodeset == 1:
return [0]
last = fixed[nodeset, j]
return backtrace(nodeset - (1 << j), last) + [j % n]
start_time = time.time()
edges = defaultdict(lambda: defaultdict(lambda: float("inf")))
for (u, v, c) in _edges:
edges[u][v] = min(edges[u][v], c) # possible duplicate edges
edges[v][u] = min(edges[v][u], c) # undirected
for u in range(1,
n): # Matthew's suggestion: clone a special sink n from 0
edges[u][n] = edges[u][0]
queue = priority_dict() #heapdict()
queue[1, 0] = (0, -1)
fixed = {}
pushes = pops = 0
full, fullplus = 2**n - 1, 2**(n + 1) - 1
while queue:
(nodeset, last), (value, back) = queue.popitem()
pops += 1
fixed[nodeset, last] = back
if nodeset == fullplus: # full set + [0]
print(
"Dijkstra, bit, pqdict, time: %.2f" %
(time.time() - start_time), "pushes:", pushes, "pops:", pops)
return (value, backtrace(nodeset, last))
for j in range(1, n) if nodeset < full else [n]:
if j in edges[last] and not (1 << j & nodeset):
newvalue = value + edges[last][j]
newset = nodeset | (1 << j)
if (newset, j) not in fixed and \
((newset, j) not in queue or newvalue < queue[newset, j][0]):
#print("push", newvalue, newset, j)
queue[newset, j] = (newvalue, last)
pushes += 1
def dijkstra(S, A, sdeb):
edges = set(A.keys())
distances = {x: float("inf") for x in S}
distances[sdeb] = 0
distances = priority_dict(distances)
final_distance = {}
predecessors = {x: None for x in S}
while len(distances) != 0:
a = distances.smallest()
min_dist = distances[a]
distances.pop_smallest()
final_distance[a] = min_dist
voisins = [b for b in distances.keys() if (a, b) in edges]
for b in voisins:
distance_through_a = final_distance[a] + A[(a, b)]
if distances[b] > distance_through_a:
distances[b] = distance_through_a
predecessors[b] = a
return final_distance, predecessors
def graphReconstruct(self): edge=self.__ng.getGraph() edge_new=dict() switch=self.__ng.getSwitch() sp=shortest_path.shortest_path(switch,edge) self.__geoCord=self.__gi.getGeoCord() for s in switch: dist=sp.shortestPath(s) if s not in edge_new: edge_new[s]=priority_dict.priority_dict() edge_new[s]=dist self.__newGraph=edge_new for k,v in self.__geoCord.iteritems(): lat=v[0] longi=v[1] if v[1]<0: longi=180+abs(v[1]) self.__geoCord[k]=(float(lat),float(longi))
def a_star_search(origin_key, goal_key, graph):
open_queue = priority_dict.priority_dict({})
closed_dict = {}
predecessors = {}
costs = {}
node_data = graph.nodes(True)
costs[origin_key] = 0.0
open_queue[origin_key] = distance_heuristic(origin_key, goal_key,
node_data)
goal_found = False
while (open_queue):
u, u_h = open_queue.pop_smallest()
ucost = costs[u]
if u == goal_key:
goal_found = True
break
for edge in graph.out_edges([u], data=True):
v = edge[1]
if v in closed_dict:
continue
uvcost = edge[2]['length']
if v in open_queue.keys():
if ucost + uvcost + distance_heuristic(
v, goal_key, node_data) < open_queue[v]:
open_queue[v] = ucost + uvcost + distance_heuristic(
v, goal_key, node_data)
costs[v] = ucost + uvcost
predecessors[v] = u
else:
open_queue[v] = ucost + uvcost + distance_heuristic(
v, goal_key, node_data)
costs[v] = ucost + uvcost
predecessors[v] = u
closed_dict[u] = 1
if not goal_found:
raise ValueError("Goal not found in search.")
return get_path(origin_key, goal_key, predecessors)
def compute_dijkstra(self, src_router_id):
src_router = self.get_router_by_id(src_router_id)
q = priority_dict()
prev = {}
for r_id, r in self.routers.iteritems():
q[r] = float("inf")
q[src_router] = 0
while q:
dist = q[q.smallest()]
u = q.pop_smallest()
# v[0] = Router-neighbor, v[1] = cost
for v in self.get_neighbors(u):
if v[0] in q:
alt = dist + v[1]
if alt < q[v[0]]:
q[v[0]] = alt
prev[v[0]] = u
next_hop = self.get_next_hop(src_router, prev)
return next_hop
def MSTPRIM(G,w,r):
r[0] = 0
Q = priority_dict(G);
print Q
while Q:
u = Q.smallest()
if 0 in Q:
print "yeah"
w += Q[u][0]
u = Q.pop_smallest()
for v in G[u]:
if isinstance(v, list):
print "ok"
stri = str(v[0])
print ''+stri
if stri in Q and v[1] < Q[v[0]][0]:
print "common"
Q[v[0]][1] = u
Q[v[0]][0] = v[1]
return w
def build_distance_table(graph, source):
# A dictionary mapping from the vertex number to a tuple of
# (distance from source, last vertex on path from source)
distance_table = {}
for i in range(graph.numVertices):
distance_table[i] = (None, None)
# The distance to the source from itself is 0
distance_table[source] = (0, source)
# Holds mapping of vertex id to distance from source
# Access the highest priority (lowest distance) item
# first
priority_queue = priority_dict.priority_dict()
priority_queue[source] = 0
while len(priority_queue.keys()) > 0:
current_vertex = priority_queue.pop_smallest()
# The distance of the current node from the source
current_distance = distance_table[current_vertex][0]
for neighbor in graph.get_adjacent_vertices(current_vertex):
distance = current_distance + g.get_edge_weight(
current_vertex, neighbor)
# The last recorded distance of this neighbor from the source
neighbor_distance = distance_table[neighbor][0]
# If there is a currently recorded distance from the source and this is
# greater than the distance of the new path found, update the current
# distance from the source in the distance table
if neighbor_distance is None or neighbor_distance > distance:
distance_table[neighbor] = (distance, current_vertex)
priority_queue[neighbor] = distance
return distance_table
def dijkstra(graph, start, goal, heuristic=lambda x, y: 0):
'''
Find the shortest path from start to goal.
>>> graph = {'a': {'w': 14, 'x': 7, 'y': 9},
'b': {'w': 9, 'z': 6},
'w': {'a': 14, 'b': 9, 'y': 2},
'x': {'a': 7, 'y': 10, 'z': 15},
'y': {'a': 9, 'w': 2, 'x': 10, 'z': 11},
'z': {'b': 6, 'x': 15, 'y': 11}}
>>> dijkstra(graph,'a','b')
['a', 'y', 'w', 'b']
By supplying a heuristic, you can transform the algorithm into the
a* search algorithm.
'''
predecessor = {}
frontier = priority_dict({start: 0})
explored = set()
traveled = {start: 0}
remaining = {start: heuristic(start, goal)} #cached for speed
for nearest in frontier.sorted_iter():
if nearest == goal: break
explored.add(nearest)
for neighbor in graph[nearest]:
if neighbor in explored: continue
displacement = traveled[nearest] + graph[nearest][neighbor]
if neighbor in frontier and displacement > traveled[neighbor]:
continue
traveled[neighbor] = displacement
if not neighbor in remaining:
remaining[neighbor] = heuristic(neighbor, goal)
frontier[neighbor] = displacement + remaining[neighbor]
predecessor[neighbor] = nearest
del traveled[nearest]
return reconstruct_path(predecessor, goal, start)
def shortestPaths(self, src, it_edges):
distances = {}
queue = pd.priority_dict({})
queue[src.id] = 0
## priority_dict requires __lt__ operator
## which is undefined for tlp.node
ancestors = {src : []}
stack = []
nb_paths = tlp.DoubleProperty(self.graph)
nb_paths.setAllNodeValue(1)
nb_paths[src] = 1
while len(queue) > 0:
v_id = queue.smallest()
d = queue[v_id]
v = tlp.node(v_id)
queue.pop_smallest()
stack.append(v)
distances[v] = d
for e in it_edges(v):
val = 1.
if self.cost is not None:
val = self.cost[e]
w = self.graph.opposite(e, v)
alt = d + val
if w in distances:
if alt < distances[w]:
self.pluginProgress.setError("Dijkstra: found better path to already-final vertex")
else:
if (w.id not in queue) or (alt < queue[w.id]):
queue[w.id] = alt
ancestors[w] = [v]
nb_paths[w] = nb_paths[v]
elif (alt == queue[w.id]) :
ancestors[w].append(v)
nb_paths[w] = nb_paths[w] + nb_paths[v]
return ancestors, stack, nb_paths
def dijkstra(G,posInit):
attribut=dict()
for v in G:
attribut[v]= [ float('+infinity'), None] #[dsitance,pere]
attribut[posInit][DIST]=0
F= priority_dict() #cree file prioriter
# on peuple la file de prioriter avec las sommet et leur distance
for v in G:
F[v]=attribut[v][DIST]
while F:
u=F.pop_smallest() #extraire le sommet de plus petit distance
for v in G[u]:
#relacher
if attribut[v][DIST] > (attribut[u][DIST] + G[u][v]) :
attribut[v][DIST]=attribut[u][DIST] + G[u][v]
F[v]=attribut[v][DIST] # mise a jour des poids dans la file
attribut[v][PERE]=u
return attribut
def dijkstra(G, pos_init):
''' retourne un dictionaire avec la plus petite distance a partir de la position inital jusqu'a chaque sommet du graphe G '''
POID = 0 # init constante poid ~ l[0]
PERE = 1 # init constante pere ~ l[1]
attribut = dict(
) # init du dict attribut pour y stocker le poid et le pere
for v in G:
attribut[v] = [
float('+infinity'), None
] # on fixe pour chaque sommet une POIDante a +oo et un pere a None
attribut[pos_init][
POID] = 0 # fixe le premier poid a partir de la position initiale a 0
F = priority_dict() # cree file prioriter
# on peuple la file de prioriter avec les sommets et leurs poid respectifs
for v in G:
F[v] = attribut[v][POID]
while F:
u = F.pop_smallest() # extrai le sommet avec le plus petit poid
for v in G[u]:
#relacher
if attribut[v][POID] > (attribut[u][POID] + G[u][v]):
attribut[v][POID] = attribut[u][POID] + G[u][
v] # on modifie la poid du sommet v car on a trouver une arete qui reduit la poid pour atteindre v depuis u
F[v] = attribut[v][
POID] # on met a jour les poids dans la file
attribut[v][PERE] = u # change le pere de v par u
return attribut
def ACM_Prim():
""" calcule un ACM du graphe stocké sur le serveur en utilisant l'algorithme de Prim """
F = priority_dict() #init file priorite
r = getAVertex() # recupere un somet au hazard
F[r] = 0
sommet_atteint = set() # init sommets decouvert
sommet_atteint.add(r) # ajout de r a l ensemble des sommets atteint
pere = dict() # init pere
pere[r] = None # pere du premier = rien
weight = dict() # init pour stocker le poids entre 2 sommets, cela evite de le redemander au serveur a la fin pour calculer le poids w de l arbre couvrant
while F :
u = F.pop_smallest()
for v in getNeighbors(u):
if v not in sommet_atteint:
sommet_atteint.add(v) # si pas atteint alors on l ajoute a l essemble atteint
F[v]=float('+infinity') # on l ajoute dans la file de prioriter avec comme valeur : +oo
weight_u_v = getWeight(u,v) # stocke dans une var le poids entre u et v
if v in F and weight_u_v<F[v] :
pere[v]=u # ajoute(ou modifie si deja existant) au dictionaire pere, le pere du sommet v
F[v]=weight_u_v # modifie le poids de v
weight[(u,v)] = weight_u_v # stocker le poids entre u et v
# Calcul du poids w de l arbre couvrant
w=0 # init du poids a 0
for s in sommet_atteint:
if s != r:
w += weight[(pere[s],s)] # somme des poids des arrets
# test si le poid de l arbre couvrant est bien le min
SpanningTreeWeight(w)
def spanning_tree(graph, source):
# A dictionary mapping from the vertex number to a tuple of
# (distance from source, last vertex on path from source)
distance_table = {}
for i in range(graph.numVertices):
distance_table[i] = (None, None)
# The distance to the source from itself is 0
distance_table[source] = (0, source)
# Holds mapping of vertex id to distance from source
# Access the highest priority (lowest distance) item
# first
priority_queue = priority_dict.priority_dict()
priority_queue[source] = 0
visited_vertices = set()
# Set of edges where each edge is represented as a string
# "1->2": is an edge between vertices 1 and 2
spanning_tree = set()
while len(priority_queue.keys()) > 0:
current_vertex = priority_queue.pop_smallest()
# If we've visited a vertex earlier then we have all
# outbound edges from it, we do not process it again
if current_vertex in visited_vertices:
continue
visited_vertices.add(current_vertex)
# If the current vertex is the source, we haven't traversed an
# edge yet, no edge to add to our spanning tree
if current_vertex != source:
# The current vertex is connected by the lowest weighted edge
last_vertex = distance_table[current_vertex][1]
edge = str(last_vertex) + "-->" + str(current_vertex)
if edge not in spanning_tree:
spanning_tree.add(edge)
for neighbor in graph.get_adjacent_vertices(current_vertex):
# The distance to the neighbor is only the weight of the edge
# connecting the neighbor
distance = g.get_edge_weight(current_vertex, neighbor)
# The last recorded distance of this neighbor
neighbor_distance = distance_table[neighbor][0]
# If this neigbor has been seen for the first time or the new edge
# connecting this neighbor is of a lower weight than the last
if neighbor_distance is None or neighbor_distance > distance:
distance_table[neighbor] = (distance, current_vertex)
priority_queue[neighbor] = distance
for edge in spanning_tree:
print(edge)
def __init__(self, duration=DEFAULT_DURATION):
self.duration = duration
self.latest_ts = int(time.time())
self.counts = priority_dict()
self.count = 0
self.history = {}
G = {
"a": {"b": 1, "c": 2},
"b": {"a": 1, "f": 5, "c": 10},
"c": {"a": 2, "b": 10, "f": 2, "e": 4},
"d": {"f": 8, "e": 3},
"e": {"c": 4, "d": 3},
"f": {"b": 5, "c": 2, "d": 8}
}
for u in G:
for v in G[u]:
print("L'arête (%s,%s) a pour poids %d" % (u, v, G[u][v]))
print("################################################\n\n\n")
from priority_dict import priority_dict
F = priority_dict() # F est maintenant définie comme une file de priorité
F['x'] = 30 # l'élément x a pour clé 30
F['y'] = 10
F['z'] = 20
while F:
u = F.pop_smallest()
print(u)
if u=='y':
F['x'] = 5
def greedySelection(self,mu,theta,d_dict):
s=list(self.__switch)
c=list(self.__switch)
switch=self.__ng.getSwitch()
edge=self.__ng.getGraph()
sp=shortest_path.shortest_path(switch,edge)
node_dist=dict()
for n in s:
node_dist[n]=sp.shortestPath(n)
ctr_cnt=0
ctr=[]
ns=dict()
while s:
node_asg={}
nodehp=priority_dict.priority_dict()
for ele in c:
node_asg[ele]=[]
neighbour=[]
cnt=0
ca=queuing.queuing(mu)
for n,dist in node_dist[ele].iteritems():
if n in s:
if n!=ele:
d=d_dict[n]
t=2*dist/300000000+ca.queuingTime(n,ele,d)
if t<=theta:
ca.updateAssignment(n,ele,d)
neighbour.append(n)
cnt=cnt+1
nodehp[ele]=cnt
node_asg[ele]=neighbour
largest=""
c_node=""
while nodehp:
c_node=nodehp.smallest()
nodehp.pop_smallest()
ctr.append(c_node)
ns[c_node]=node_asg[c_node]
ctr_cnt=ctr_cnt+1
s.remove(c_node)
c.remove(c_node)
for node in node_asg[c_node]:
if node in s:
s.remove(node)
if node in c:
c.remove(node)
#print ns
#print ctr
for k,v in ns.iteritems():
ns[k].append(k)
self.__ns=ns
return ctr_cnt
import sys
from priority_dict import priority_dict
import matplotlib as mpl
from matplotlib import rc
import matplotlib.pyplot as plt
import numpy as np
mpl.rcParams.update({'font.size': 22})
#Will open and read the results for find_halos.py
#note that find_halos.py ouputs three lists, the first is true, second mg, third cs
#list is [(item, freq_est), (),...()] sorted worst too best (lowest freq first)
true_items = set()
true_counts = priority_dict()
#mg_freq = []
#cs_items = set()
#cs_freq = []
curr = ""
#First retrieve top 1000 elements of true most frequent
c = 0
for line in list(open("true_freqs.txt")):
if c == 1000:
break
data = line.strip().split(',')
true_items.add(data[0])
true_counts[data[0]] = data[1]
c += 1
k_vals = []
recall_points = []
false_pos_points = []
def run(self):
epsilon=0.1
beta=0.3
alpha=self.__alpha
d={}
light_speed=3*math.pow(10,5)
u=30000
d_lower=1500
d_upper=3000
mu=30000
self.__gi.graphParser()
edge=self.__gi.getGraph()
switch=self.__gi.getSwitch()
controller=self.__gi.getController()
ds=self.__ds
adj={}
for s1 in switch:
adj[s1]={}
d[s1]=0
for s2 in switch:
if s2!=s1:
adj[s1][s2]=0
#print adj
d_node={}
r_node={}
count=0
for node in adj:
d_node[node]=0
r_node[node]=0
count=count+1
x=math.pow(1+count*epsilon,(1-epsilon)/epsilon)
x=1/x
y=math.pow((1-epsilon)/(count*(count-1)),1/epsilon)
gamma=x*y
totalCost=4
for s in switch:
d[s]=d_lower+random.random()*(d_upper-d_lower)
path={}
while (totalCost<self.__B):
print "Current cost is: {}".format(totalCost)
u_edge={}
phi={}
flow={}
cost={}
ca=queuing.queuing(d,mu)
for node in d_node:
d_node[node]=d_node[node]+beta*d[node]
for node,edge in adj.iteritems():
if node not in u_edge:
u_edge[node]={}
if node not in flow:
flow[node]={}
for k,v in edge.iteritems():
if k not in u_edge:
u_edge[k]={}
if k not in flow:
flow[k]={}
phi[k]=gamma/self.__B
u_edge[node][k]=d_node[node]
u_edge[k][k]=u
flow[node][k]=0
flow[k][k]=0
cost[k]=0
mg=MCFGraph.MCFGraph(adj,u_edge,phi,flow,cost)
mg.graphUpdate(gamma)
adj_mcf=mg.getGraph()
path={}
sp=shortest_path.shortest_path(switch,adj_mcf)
#print adj_mcf
node_dist=priority_dict.priority_dict()
for s in switch:
print len(switch), totalCost
cur_demand=d_node[s]
u_edge=mg.getCapacity()
flow=mg.getFlow()
node_dist[s]=sp.shortestPath(s)
#print node_dist[s]
c_found=node_dist[s].smallest()
while (flow[c_found][c_found]+cur_demand>u_edge[c_found][c_found]):
node_dist[s].pop_smallest()
c_found=node_dist[s].smallest()
mg.updateFlow(s,c_found,cur_demand)
mg.updateCost(c_found)
path[s]=c_found
dist=ds[s][c_found]
#print s, c_found, node_dist[s][c_found]
ca.updateAssignment(s,c_found)
t=ca.queuingTime(s,c_found)
rtt=dist/light_speed*2+t
r_node[s]=cur_demand/d[s]+alpha*(self.__theta-rtt)
print rtt, self.__theta
self.__sub.append(self.__theta-rtt)
mg.relaxation(epsilon,self.__B,cur_demand,s,c_found)
adj_mcf=mg.getGraph()
sp=shortest_path.shortest_path(switch,adj_mcf)
totalCost=mg.calculateCost()
print len(switch), totalCost
#print "Current path is: {}".format(path)
i=0
min_obj=0
x=math.log((1+epsilon)/gamma,1+epsilon)
for node in r_node:
if (i==0):
r_node[node]=r_node[node]/x
min_obj=r_node[node]
else:
r_node[node]=r_node[node]/x
if (r_node[node]<min_obj):
min_obj=r_node[node]
i=i+1
self.__path=path
return min_obj
fo=open(demandPath+".txt","r+") for s in switch: line=fo.readline() d[str(s)]=float(line[:-2]) fo.close() c=ng.getController() ca=queuing.queuing(mu) nc=NodeCover.NodeCover(ng,ca,d,theta,c,mu) nc.ctrCover() nc.calculateNodeFreq() freq_pq=priority_dict.priority_dict() freq_pq=nc.getNodeFreqPair() ctrCover=nc.getCtrCover() cost=dict() for s in switch: cost[s]=0 ctrList=[] ctrCand=[] uncovered=list(switch) ns=dict() for c in ctrCover: ctrCand.append(c) while (freq_pq): #print freq_pq.smallest()
n_ctr=len(s)
c=ng.getController()
mapping=dict()
ctr=[]
sp=shortest_path.shortest_path(s,edge)
node_dist=dict()
for n in s:
node_dist[n]=sp.shortestPath(n)
ctr_cnt=0
while s:
node_asg={}
nodehp=priority_dict.priority_dict()
for ele in c:
#print node_dist[ele]
node_asg[ele]=[]
neighbour=[]
cnt=0
ca=queuing.queuing(mu)
for n,dist in node_dist[ele].iteritems():
if n!=ele:
#ca.updateAssignment(n,ele,d)
t=2*dist/300000000+ca.queuingTime(n,ele,d)
if t<=theta:
ca.updateAssignment(n,ele,d)
neighbour.append(n)
def A_star(origin_key, goal_key, graph):
# min heap for open vertices
open_queue = priority_dict.priority_dict({})
#closed dictionary
closed_dict = {}
#predecessor dictionary
predecessors = {}
#best cost of each vertices
costs = {}
#get spatial data of nodes
node_data = graph.nodes(True)
costs[origin_key] = 0.0
open_queue[origin_key] = distance_heuristic(origin_key, goal_key,
node_data)
#iterate through open_queue through all nodes till goal is found
goal_found = False
while (open_queue):
# pop the initial vertex
u, u_heu = open_queue.pop_smallest()
u_cost = costs[u]
# check condition if the start vertex is goal
if u == goal_key:
goal_found = True
break
for edge in graph.out_edges([u], data=True):
# out_edges provide information about the edges.
#The return value of this is a list of tuples, each of which represent an outgoing edge.
#The second element of each tuple is the outgoing vertex at the other end of the edge.
v = edge[1]
if v in closed_dict:
continue
uv_cost = edge[2]['length']
if v not in open_queue:
costs[v] = u_cost + uv_cost
open_queue[v] = u_cost + uv_cost + distance_heuristic(
v, goal_key, node_data)
predecessors[v] = u
else:
v_cost = costs[v]
if u_cost + uv_cost + distance_heuristic(
v, goal_key, node_data) < v_cost:
open_queue[v] = u_cost + uv_cost + distance_heuristic(
v, goal_key, node_data)
costs[v] = u_cost + uv_cost
predecessors[v] = u
closed_dict[v] = -1
# If we get through entire priority queue without finding the goal,
# something is wrong.
if not goal_found:
raise ValueError("Goal not found in search.")
# Construct the path from the predecessors dictionary.
return get_path(origin_key, goal_key, predecessors)
def run(self):
print "Running PTAS"
epsilon=0.1
beta=0.3
d=self.__d
light_speed=3*math.pow(10,8)
u=30000
mu=30000
numCluster=self.__numController
controllers=self.__km.initialCluster(numCluster/2)
maxControlDist=self.__ng.getMaxControlDist(controllers)
theta=maxControlDist*2/light_speed+5/1000
self.__B=theta
controllers=self.__km.initialCluster(numCluster)
self.__controllers=controllers
print controllers
edge=self.__ng.getGraph()
switch=self.__ng.getSwitch()
ds=self.__ds
adj={}
for s1 in switch:
adj[s1]={}
for s2 in self.__controllers:
adj[s1][s2]=0
d_node={}
count=0
for node in adj:
d_node[str(node)]=0
count=count+1
x=math.pow(1+count*epsilon,(1-epsilon)/epsilon)
x=1/x
y=math.pow((1-epsilon)/(count*(count-1)),1/epsilon)
gamma=x*y
curCost=float(0)
bv1=0
while (curCost<theta*len(switch)):
print "Current budget is: {}".format(theta*len(switch))
u_edge={}
phi={}
flow={}
cost={}
path={}
ca=queuing.queuing(mu)
for node,edge in adj.iteritems():
if node not in u_edge:
u_edge[str(node)]={}
if node not in flow:
flow[str(node)]={}
if node not in phi:
phi[str(node)]={}
for k,v in edge.iteritems():
if k not in u_edge:
u_edge[str(k)]={}
if k not in flow:
flow[str(k)]={}
if k not in phi:
phi[str(k)]={}
if node!=k:
phi[str(node)][str(k)]=gamma/self.__B
u_edge[str(node)][str(k)]=3*d[str(node)]
flow[str(node)][str(k)]=0
phi[str(k)][str(k)]=gamma/self.__B
u_edge[str(k)][str(k)]=u
flow[str(k)][str(k)]=0
cost[node]=0
mg=MCFGraph.MCFGraph(adj,u_edge,phi,flow,cost)
mg.graphUpdate(gamma,ca,ds,d)
adj_mcf=mg.getGraph()
sp=shortest_path.shortest_path(switch,adj_mcf)
node_dist=priority_dict.priority_dict()
for c in controllers:
d_node[str(c)]=d_node[str(c)]+beta*d[str(c)]
mg.updateFlow(str(c),str(c),d_node[str(c)])
path[c]=str(c)
dist=0
ca.updateAssignment(c,str(c),d_node)
t=ca.queuingTime(str(c))
rtt=t
cur_demand=d_node[str(c)]
mg.updateCost(c,rtt)
mg.relaxation(epsilon,self.__B,cur_demand,c,str(c),ca,ds)
adj_mcf=mg.getGraph()
sp=shortest_path.shortest_path(switch,adj_mcf)
totalDemand=0
for s in switch:
if s not in controllers:
if bv1==0:
d_node[str(s)]=d[str(s)]
totalDemand=totalDemand+d_node[str(s)]
cur_demand=d_node[str(s)]
u_edge=mg.getCapacity()
flow=mg.getFlow()
node_dist[s]=sp.shortestPath(s)
c_found=node_dist[s].smallest()
while (flow[str(c_found)][str(c_found)]+cur_demand>u_edge[str(c_found)][str(c_found)]):
node_dist[s].pop_smallest()
if len(node_dist[s])>0:
if node_dist[s].smallest() in self.__controllers:
c_found=node_dist[s].smallest()
else:
bv1=1
break
if bv1==0:
c_found=node_dist[s].smallest()
mg.updateFlow(str(s),str(c_found),cur_demand)
path[s]=str(c_found)
dist=ds[s][str(c_found)]
ca.updateAssignment(s,str(c_found),d_node)
t=ca.queuingTime(str(c_found))
rtt=dist*2/light_speed+t
mg.updateCost(s,rtt)
mg.relaxation(epsilon,self.__B,cur_demand,s,str(c_found),ca,ds)
adj_mcf=mg.getGraph()
sp=shortest_path.shortest_path(switch,adj_mcf)
totalCost=mg.calculateCost()
curCost=float(totalCost)
print "Total demand is {}.".format(totalDemand)
print "Cost is {}, K is {}.".format(curCost,len(controllers))
self.__path=path
self.__cost=curCost
if bv1==0:
numCluster=numCluster-1
else:
numCluster=numCluster+1
bv1=0
controllers=self.__km.initialCluster(numCluster)
self.__controllers=controllers
adj={}
for s1 in switch:
adj[s1]={}
for s2 in self.__controllers:
adj[s1][s2]=0
print controllers
print "Iteration ends."
