def nagamochi_capforest(g):
unscanned_edges = set(multigraph_edges_as_triples(g))
r = dict((node, 0) for node in g)
q = {}
graph_to_heap = {}
unscanned_r_heap = Fibonacci_heap()
for node in g:
graph_to_heap[node] = unscanned_r_heap.enqueue(node, 0)
while unscanned_r_heap:
x_heap_node = unscanned_r_heap.dequeue_min()
x = x_heap_node.get_value()
for y, xy_dict in g[x].items():
for i, edge_data in xy_dict.items():
edge = (x, y, i)
if not edge in unscanned_edges:
continue
unscanned_edges.remove(edge)
unscanned_edges.remove((y, x, i))
c = edge_data[EDGE_CAPACITY_ATTR]
q[edge] = r[y] + c
r[y] = r[y] + c
y_heap_node = graph_to_heap[y]
y_prio = y_heap_node.get_priority()
unscanned_r_heap.decrease_key(y_heap_node, y_prio - c)
return q
def nagamochi_forest(g):
unscanned_edges = set(multigraph_edges_as_triples(g))
r = dict((node, 0) for node in g)
graph_to_heap = {}
unscanned_r_heap = Fibonacci_heap()
for node in g:
graph_to_heap[node] = unscanned_r_heap.enqueue(node, 0)
partitions = {}
while unscanned_r_heap:
x_heap_node = unscanned_r_heap.dequeue_min()
x = x_heap_node.get_value()
graph_to_heap[x] = None
for y, xy_es in g[x].items():
for i, edge_dict in xy_es.items():
edge = (x, y, i)
if not edge in unscanned_edges:
continue
unscanned_edges.remove(edge)
unscanned_edges.remove((y, x, i))
k = r[y] + 1
if not k in partitions:
partitions[k] = set()
partitions[k].add(edge)
if r[x] is r[y]:
r[x] += 1
r[y] += 1
y_heap_node = graph_to_heap[y]
y_prio = y_heap_node.get_priority()
unscanned_r_heap.decrease_key(y_heap_node, y_prio - 1)
return partitions
def prims_fh(graph, start):
""" Prim's algorithm with fibonacci heap """
pq = Fibonacci_heap()
explored = {start}
selected_edges = []
incident_edges = [(weight, start, v) for (v, weight) in graph[start]]
for edge in incident_edges:
weight, start, v = edge
pq.enqueue((start, v), weight)
while pq.__nonzero__():
selected_edge = pq.dequeue_min()
value = selected_edge.get_value()
selected_node = value[1]
parent_node = value[0]
selected_weight = selected_edge.m_priority
if selected_node in explored:
continue
selected_edges.append((selected_weight, parent_node, selected_node))
explored.add(selected_node)
for edge in graph[selected_node]:
v, weight = edge[0], edge[1]
if v not in explored:
pq.enqueue((selected_node, v), weight)
return selected_edges
def createGraph(self):
nodes = []
g = Graph(nodes)
f = open("GeneratedGraph.txt", "r")
lines = f.readlines()
linesSize = len(lines)
f.close()
numberOfNodes = int(lines[0])
allNodeLinks = []
for i in range(0, numberOfNodes):
for j in range(1, numberOfNodes):
nodeAndLinks = lines[j].split("->")
links = nodeAndLinks[1].split(",")
allNodeLinks.append(links)
n = Node(i, i + 1, allNodeLinks[i])
g.getNodes().append(n)
actual = 1
for j in range(numberOfNodes, linesSize):
arcAndCost = lines[j].split("=")
arcElements = arcAndCost[0].split(",")
entry = (int(arcElements[0]), int(arcElements[1]))
priority = int(arcAndCost[1])
if actual == int(arcElements[0]):
self.fibHeap.enqueue(entry, priority)
else:
actual = int(arcElements[0])
self.fibHeaps.append(self.fibHeap)
self.fibHeap = Fibonacci_heap()
self.fibHeap.enqueue(entry, priority)
if j == linesSize - 1:
self.fibHeaps.append(self.fibHeap)
for i in range(0, numberOfNodes):
if i == 0:
g.getNodes()[i].setWeight(0)
else:
g.getNodes()[i].setWeight(999999)
return g
def uprooting(G, X, ds, dsconf):
C = dict()
L = dict()
I = dict()
for x in G.nodes():
MakeSet(C, x)
L[x] = Fibonacci_heap()
for u in G.edges():
if (u in X.edges()):
I[(min(u), max(u))]=0
else:
I[(min(u), max(u))]=-1
for u in X.edges():
xp=find(C,u[0])
yp=find(C,u[1])
if (xp!=yp):
Link(C,xp,yp)
for u in G.edges():
if (u in X.edges()):
continue
cVal=ds.distance(u[0],u[1],dsconf)
x=find(C,u[0])
y=find(C,u[1])
if (x!=y):
L[x].enqueue((y,u),cVal)
L[y].enqueue((x,u),cVal)
merges=[]
nCC=sum([1 for x in L if len(L[x])>0])
for i in range(1,nCC):
x=None
xmin=np.inf
for xx in L:
if (len(L[xx])==0):
continue
cP=L[xx].min().get_priority()
if (cP < xmin):
x=xx
xmin=cP
xp=find(C,x)
while len(L[xp])>0:
(y,v)=L[xp].dequeue_min().get_value()
yp=find(C,y)
if (xp!=yp):
break
merges.append((min(v),max(v)))
I[(min(v),max(v))]=i
z=Link(C,xp,yp)
L[z]=meld(C,L,xp,yp)
return(I,merges)
def nagamochi_forest(g):
unscanned_edges = set(multigraph_edges_as_triples(g))
r = dict((node, 0) for node in g)
graph_to_heap = {}
unscanned_r_heap = Fibonacci_heap()
for node in g:
graph_to_heap[node] = unscanned_r_heap.enqueue(node, 0)
partitions = {}
while unscanned_r_heap:
x_heap_node = unscanned_r_heap.dequeue_min()
x = x_heap_node.get_value()
graph_to_heap[x] = None
for y, xy_es in g[x].items():
for i, edge_dict in xy_es.items():
edge = (x, y, i)
if not edge in unscanned_edges:
continue
unscanned_edges.remove(edge)
unscanned_edges.remove((y, x, i))
k = r[y] + 1
if not k in partitions:
partitions[k] = set()
partitions[k].add(edge)
if r[x] is r[y]:
r[x] += 1
r[y] += 1
y_heap_node = graph_to_heap[y]
y_prio = y_heap_node.get_priority()
unscanned_r_heap.decrease_key(y_heap_node, y_prio - 1)
return partitions
def nagamochi_capforest(g):
unscanned_edges = set(multigraph_edges_as_triples(g))
r = dict((node, 0) for node in g)
q = {}
graph_to_heap = {}
unscanned_r_heap = Fibonacci_heap()
for node in g:
graph_to_heap[node] = unscanned_r_heap.enqueue(node, 0)
while unscanned_r_heap:
x_heap_node = unscanned_r_heap.dequeue_min()
x = x_heap_node.get_value()
for y, xy_dict in g[x].items():
for i, edge_data in xy_dict.items():
edge = (x, y, i)
if not edge in unscanned_edges:
continue
unscanned_edges.remove(edge)
unscanned_edges.remove((y, x, i))
c = edge_data[EDGE_CAPACITY_ATTR]
q[edge] = r[y] + c
r[y] = r[y] + c
y_heap_node = graph_to_heap[y]
y_prio = y_heap_node.get_priority()
unscanned_r_heap.decrease_key(y_heap_node, y_prio - c)
return q
def dijkstra(source: OrientedWay) -> SingleSourceMap:
"""Dijkstra algorithm."""
info: DefaultDict[OrientedWay, _NodeInfo]
node: OrientedWay
visited: Set[OrientedWay]
queue = FibonacciHeap()
visited = set()
source_info = _NodeInfo(0.0)
source_info.entry = queue.enqueue(source, 0)
info = defaultdict(_NodeInfo, {source: source_info})
while queue:
node = queue.dequeue_min().get_value()
node_info = info[node]
visited.add(node)
weight = node.weight
for neighbor in node.way_connections:
if neighbor in visited:
continue
neighbor_info = info[neighbor]
new_dist = node_info.dist + weight
if new_dist < neighbor_info.dist:
if neighbor_info.dist == INF:
neighbor_info.entry = queue.enqueue(neighbor, new_dist)
else:
queue.decrease_key_unchecked(neighbor_info.entry, new_dist)
neighbor_info.dist = new_dist
neighbor_info.prev = node
neighbor_info.depth = node_info.depth + 1
return {n: (i.prev, i.depth) for n, i in info.items()}
def buildMST(self, startx, starty):
print 'building MST'
mstT0 = time.time()
heap = Fibonacci_heap()
self.startpt = (startx, starty)
heapTempGraph = {}
for neighCoor, neighCost in self.pixelNodeList2D[
self.startpt].neighbors.iteritems():
heapTempGraph[neighCoor] = heap.enqueue(value=neighCoor,
priority=neighCost)
self.pixelNodeList2D[neighCoor].totalCost = neighCost
self.pixelNodeList2D[neighCoor].prevNode = self.startpt
while heap.m_size != 0:
# print 'deq'
# deqt0 = time.time()
q = heap.dequeue_min()
# mark q as EXPANDED (state = 0)
self.pixelNodeList2D[q.m_elem].state = 0
self.pixelNodeList2D[q.m_elem].totalCost = q.m_priority
for rCoor, rCost in self.pixelNodeList2D[
q.m_elem].neighbors.iteritems():
rState = self.pixelNodeList2D[rCoor].state
if rState != 0:
if rState == -1:
self.pixelNodeList2D[rCoor].prevNode = q.m_elem
self.pixelNodeList2D[
rCoor].totalCost = self.pixelNodeList2D[
q.m_elem].totalCost + rCost
heapTempGraph[rCoor] = heap.enqueue(
value=rCoor,
priority=self.pixelNodeList2D[rCoor].totalCost)
self.pixelNodeList2D[rCoor].state = 1
else:
if self.pixelNodeList2D[
rCoor].totalCost > self.pixelNodeList2D[
q.m_elem].totalCost + rCost:
self.pixelNodeList2D[rCoor].prevNode = q.m_elem
self.pixelNodeList2D[
rCoor].totalCost = self.pixelNodeList2D[
q.m_elem].totalCost + rCost
heap.decrease_key(
heapTempGraph[rCoor],
self.pixelNodeList2D[rCoor].totalCost)
# deqTime = time.time() - deqt0
# print deqTime
self.pixelNodeList2D[self.startpt].prevNode = None
mstTime = time.time() - mstT0
print mstTime
self.built_MST = True
def dijkstra_search(self, source_vertex: V,
target_vertex: V) -> Tuple[List[V], E]:
self._assert_contains_vertices(source_vertex, target_vertex)
# short-circuit for search for source
if source_vertex == target_vertex:
return [source_vertex], 0
graph = self.graph
parents = {}
queue = Fibonacci_heap()
# enqueue source vertex
parents[source_vertex] = (source_vertex, 0,
queue.enqueue(source_vertex, 0))
# do search
while len(queue) > 0:
vertex = queue.dequeue_min().get_value()
# check for target vertex
if vertex == target_vertex:
break
for edge in graph.edges_from_vertex(vertex):
adjacent_vertex = edge.get_target_vertex()
priority = edge.get_weight() + parents[vertex][1]
if adjacent_vertex not in parents:
# push new vertex
parents[adjacent_vertex] = (vertex, priority,
queue.enqueue(
adjacent_vertex, priority))
elif priority < parents[adjacent_vertex][1]:
# adjust priority of adjacent_vertex
entry = parents[adjacent_vertex][2]
queue.decrease_key(entry, priority)
parents[adjacent_vertex] = (vertex, priority, entry)
if target_vertex not in parents:
raise NoGraphPathException(
"Source and target vertices are not linked in the graph")
parent = parents[target_vertex][0]
path = [target_vertex, parent]
while parent != source_vertex:
parent = parents[parent][0]
path.append(parent)
return reversed(path), parents[target_vertex][1]
def meld(C, L, x, y):
res=Fibonacci_heap()
while (len(L[x])>0):
el=L[x].dequeue_min()
_,v=el.get_value()
if (find(C,v[0])!=find(C,v[1])):
res.enqueue(el.get_value(),el.get_priority())
while (len(L[y])>0):
el=L[y].dequeue_min()
_,v=el.get_value()
if (find(C,v[0])!=find(C,v[1])):
res.enqueue(el.get_value(),el.get_priority())
return(res)
def observations_iterator(probs):
# yield first obs with all outputs probs > 0.5
max_obs = {name: (0,p) if p > 0.5 else (1,1-p) for name,p in probs.items()}
sorted_outputs = sorted(max_obs.items(), key=lambda x: x[1][1])
output_names, pack = zip(*sorted_outputs)
max_obs_values, output_probs = zip(*pack)
yield dict(zip(output_names, max_obs_values))
size = len(output_names) - 1
heap = Fibonacci_heap()
values = list(max_obs_values)
max_index = 0
values[max_index] = 1 - values[max_index]
prob = observation_prob(dict(zip(output_names, values)), probs)
heap.enqueue((values, max_index, prob, None), -prob)
while len(heap) > 0:
values, max_index, prob, next_node = heap.dequeue_min().m_elem
if next_node:
heap.enqueue(next_node, -next_node[2])
yield dict(zip(output_names, values))
if max_index == size:
continue
# add left child - switch max index key i with i+1 : update values and probability
# create right child for later - add i+1 key
values_right_node = values[:]
max_index_right_node = max_index + 1
values_right_node[max_index_right_node] = 1 - values_right_node[max_index_right_node]
prob_right_node = prob * ((1 / output_probs[max_index_right_node]) - 1)
right_node = (values_right_node, max_index_right_node, prob_right_node, None)
values_left_node = values_right_node[:]
values_left_node[max_index] = 1 - values_left_node[max_index]
prob_left_node = prob_right_node / ((1/output_probs[max_index]) - 1)
heap.enqueue((values_left_node, max_index + 1, prob_left_node, right_node), -prob_left_node)
def dijkstra(graph, start, end, flag="shortest"):
"""Calculate the shortest path between a start- and an end-vertex.
`graph` needs to support at least neighbors(n) which returns a list of new
nodes and weight(a,b) returning a float value. Smaller weights are
preferred by the algorithm.
"""
prev = {}
costs = {}
entry = {}
remaining = set([end])
weight_fn = COST_FN[flag]
costs[start] = 0.0
queue = Fibonacci_heap()
entry[start] = queue.enqueue(start, 0.0)
while queue:
system = queue.dequeue_min().get_value()
if system in remaining:
remaining.remove(system)
# Early exit as we found everything
if not remaining:
break
for neighbor in graph.neighbors(system):
if neighbor in prev: # we have already seen this neighbor
continue
new_cost = costs[system] + weight_fn(graph, neighbor)
if neighbor in costs and new_cost < costs[neighbor]:
costs[neighbor] = new_cost
prev[neighbor] = system
queue.decrease_key(entry[neighbor], costs[neighbor])
if neighbor not in costs:
costs[neighbor] = new_cost
prev[neighbor] = system
entry[neighbor] = queue.enqueue(neighbor, costs[neighbor])
return path(prev, start, end)
def dijkstra(graph, start, ends):
prev = {}
costs = {}
entry = {}
remaining = set(ends)
costs[start] = 0.0
q = Fibonacci_heap()
entry[start] = q.enqueue(start, 0.0)
while q:
u = q.dequeue_min().get_value()
if u in remaining:
remaining.remove(u)
if not remaining:
break
for v in graph[u]:
if v in prev:
continue
new_cost = costs[u] + 1
if v in costs and new_cost < costs[v]:
costs[v] = new_cost
prev[v] = u
q.decrease_key(entry[v], costs[v])
if v not in costs:
costs[v] = new_cost
prev[v] = u
entry[v] = q.enqueue(v, costs[v])
result = []
for end in ends:
result.append(path(prev, start, end))
return result
def dijkstra_search(self, source_vertex: V, target_vertex: V) -> Tuple[List[V], E]:
self._assert_contains_vertices(source_vertex, target_vertex)
# short-circuit for search for source
if source_vertex == target_vertex:
return [source_vertex], 0
graph = self.graph
parents = {}
queue = Fibonacci_heap()
# enqueue source vertex
parents[source_vertex] = (source_vertex, 0, queue.enqueue(source_vertex, 0))
# do search
while len(queue) > 0:
vertex = queue.dequeue_min().get_value()
# check for target vertex
if vertex == target_vertex:
break
for edge in graph.edges_from_vertex(vertex):
adjacent_vertex = edge.get_target_vertex()
priority = edge.get_weight() + parents[vertex][1]
if adjacent_vertex not in parents:
# push new vertex
parents[adjacent_vertex] = (vertex, priority, queue.enqueue(adjacent_vertex, priority))
elif priority < parents[adjacent_vertex][1]:
# adjust priority of adjacent_vertex
entry = parents[adjacent_vertex][2]
queue.decrease_key(entry, priority)
parents[adjacent_vertex] = (vertex, priority, entry)
if target_vertex not in parents:
raise NoGraphPathException("Source and target vertices are not linked in the graph")
parent = parents[target_vertex][0]
path = [target_vertex, parent]
while parent != source_vertex:
parent = parents[parent][0]
path.append(parent)
return reversed(path), parents[target_vertex][1]
class MyFibonacciHeap(dict):
# ------------------------------------------------------
# have 3 container
# itemlist: a list to store key
# super : a dict to store entry
# heap : a fibonacci heap to maintain the priority
# ------------------------------------------------------
def __init__(self, *args, **kw):
self.itemlist = []
self.heap = Fibonacci_heap()
self.update(*args, **kw)
# ------------------------------------------------------
# __setitem__
# key: item name
# value: (int)priority
#
# ------------------------------------------------------
def __setitem__(self, key, priority):
if type(priority) is not int:
raise TypeError, "priority type is " + str(type(priority))
if key in self.itemlist:
if self[key] < priority:
raise ValueError, "priority cannot be increase."
else:
entry = super(MyFibonacciHeap, self).__getitem__(key)
self.heap.decrease_key(entry, priority)
else:
self.itemlist.append(key)
super(MyFibonacciHeap,
self).__setitem__(key, self.heap.enqueue(key, priority))
# ------------------------------------------------------
# __getitem__
# key: the value of the item or item name
#
# return the priority of the entry of the key
# ------------------------------------------------------
def __getitem__(self, key):
return super(MyFibonacciHeap, self).__getitem__(key).get_priority()
def __delitem__(self, key):
entry = super(MyFibonacciHeap, self).pop(key)
self.heap.delete(entry)
self.itemlist.remove(key)
"""
def __iter__(self):
'''
if self.heap.__len__() is not 0:
i = 1
entry = self.heap.min()
yield entry.get_value()
while i < self.heap.__len__():
entry = entry.m_next
yield entry.get_value()
i += 1
'''
while self.heap.__len__() is not 0:
entry = self.heap.dequeue_min()
yield entry.get_value()
self.itemlist.remove(entry.get_value())
super(MyFibonacciHeap, self).pop(entry.get_value())
"""
def __repr__(self):
string = '{\n '
string += ', \n '.join(
[str(key) + ': ' + str(self[key]) for key in self])
string += '\n}'
return string
def __len__(self):
return super(MyFibonacciHeap, self).__len__()
def keys(self):
return self.itemlist
def update(self, *args, **kw):
if len(args) is not 0:
if type(args[0]) is dict: # dict in tuple
for key in args[0]:
self.__setitem__(key, args[0][key])
elif type(args[0]) is list: # tuple in list in tuple
for item in args[0]:
self.__setitem__(item[0], item[1])
for key in kw:
self.__setitem__(key, kw[key])
def enqueue(self):
self.__setitem__(value, priority)
def dequeue(self, value, priority):
entry = self.heap.dequeue_min()
self.itemlist.remove(entry.get_value())
super(MyFibonacciHeap, self).pop(entry.get_value())
return entry
def hierMWW(D, Gr, NbyInd, dsconf, maxClusters=20):
IndByN = {NbyInd[i]: i for i in NbyInd}
T = np.percentile(D, 25)
G = Gr.copy()
lName = 'data'
for e in G.edges():
i1 = IndByN[e[0]]
i2 = IndByN[e[1]]
cD = D[i1, i2]
G[e[0]][e[1]][lName] = cD
psi = watershed(G, lName)
nClusters = len(set(psi.values()))
lastNClusters = nClusters
while (nClusters > maxClusters):
clInds = dict()
for L in set(psi.values()):
clInds[L] = []
for n in psi:
clInds[psi[n]].append(IndByN[n])
H = Fibonacci_heap()
Lused = dict()
for e in G.edges():
l1 = min(psi[e[0]], psi[e[1]])
l2 = max(psi[e[0]], psi[e[1]])
if (l1 != l2):
if (l1 not in Lused):
Lused[l1] = dict()
if (l2 not in Lused[l1]):
Lused[l1][l2] = True
H.enqueue((l1, l2),
np.nanmedian((D[clInds[l1], :])[:, clInds[l2]]))
used = []
while len(H) > 0:
el = H.dequeue_min()
if (el.get_priority() > T):
if (nClusters != lastNClusters):
lastNClusters = nClusters
print('skip', nClusters, el.get_priority())
break
l1, l2 = el.get_value()
if (l1 in used) or (l2 in used):
continue
used.extend([l1, l2])
for n in psi:
if (psi[n] == l2):
psi[n] = l1
nClusters -= 1
if (nClusters == maxClusters):
break
labels = list(sorted(set(psi.values())))
print('now with ', len(labels))
for n in psi:
psi[n] = labels.index(psi[n])
corr = []
corr.append(list(range(len(labels))))
nextlabel = len(labels)
while (nClusters > 1):
print('#clusters', nClusters)
H = Fibonacci_heap()
Lused = dict()
clInds = dict()
for L in corr[-1]:
clInds[L] = []
for n in psi:
clInds[corr[-1][psi[n]]].append(IndByN[n])
for e in G.edges():
l1 = min(corr[-1][psi[e[0]]], corr[-1][psi[e[1]]])
l2 = max(corr[-1][psi[e[0]]], corr[-1][psi[e[1]]])
if (l1 != l2):
if (l1 not in Lused):
Lused[l1] = dict()
if (l2 not in Lused[l1]):
Lused[l1][l2] = True
H.enqueue((l1, l2),
np.nanmedian((D[clInds[l1], :])[:, clInds[l2]]))
el = H.dequeue_min()
l1, l2 = el.get_value()
print(el.get_priority())
tVec = corr[-1][:]
for i in range(len(tVec)):
if (tVec[i] == l1) or (tVec[i] == l2):
tVec[i] = nextlabel
corr.append(tVec)
nextlabel += 1
nClusters -= 1
clusters = dict()
for i in range(len(corr)):
for n in psi:
c = corr[i][psi[n]]
if c not in clusters:
clusters[c] = []
clusters[c].append(n)
for c in clusters:
clusters[c] = list(set(clusters[c]))
return (psi, corr, clusters)
class MyFibonacciHeap(dict):
# ------------------------------------------------------
# have 3 container
# itemlist: a list to store key
# super : a dict to store entry
# heap : a fibonacci heap to maintain the priority
# ------------------------------------------------------
def __init__(self, *args, **kw):
self.itemlist = []
self.heap = Fibonacci_heap()
self.update(*args, **kw)
# ------------------------------------------------------
# __setitem__
# key: item name
# value: (int)priority
#
# ------------------------------------------------------
def __setitem__(self, key, priority):
if type(priority) is not int:
raise TypeError, "priority type is " + str(type(priority))
if key in self.itemlist:
if self[key] < priority:
raise ValueError, "priority cannot be increase."
else:
entry = super(MyFibonacciHeap, self).__getitem__(key)
self.heap.decrease_key(entry, priority)
else:
self.itemlist.append(key)
super(MyFibonacciHeap, self).__setitem__(key, self.heap.enqueue(key, priority))
# ------------------------------------------------------
# __getitem__
# key: the value of the item or item name
#
# return the priority of the entry of the key
# ------------------------------------------------------
def __getitem__(self, key):
return super(MyFibonacciHeap, self).__getitem__(key).get_priority()
def __delitem__(self, key):
entry = super(MyFibonacciHeap, self).pop(key)
self.heap.delete(entry)
self.itemlist.remove(key)
"""
def __iter__(self):
'''
if self.heap.__len__() is not 0:
i = 1
entry = self.heap.min()
yield entry.get_value()
while i < self.heap.__len__():
entry = entry.m_next
yield entry.get_value()
i += 1
'''
while self.heap.__len__() is not 0:
entry = self.heap.dequeue_min()
yield entry.get_value()
self.itemlist.remove(entry.get_value())
super(MyFibonacciHeap, self).pop(entry.get_value())
"""
def __repr__(self):
string = '{\n '
string += ', \n '.join([str(key) + ': ' + str(self[key]) for key in self])
string += '\n}'
return string
def __len__(self):
return super(MyFibonacciHeap, self).__len__()
def keys(self):
return self.itemlist
def update(self, *args, **kw):
if len(args) is not 0:
if type(args[0]) is dict: # dict in tuple
for key in args[0]:
self.__setitem__(key, args[0][key])
elif type(args[0]) is list: # tuple in list in tuple
for item in args[0]:
self.__setitem__(item[0], item[1])
for key in kw:
self.__setitem__(key, kw[key])
def enqueue(self):
self.__setitem__(value, priority)
def dequeue(self, value, priority):
entry = self.heap.dequeue_min()
self.itemlist.remove(entry.get_value())
super(MyFibonacciHeap, self).pop(entry.get_value())
return entry
def __init__(self, *args, **kw):
self.itemlist = []
self.heap = Fibonacci_heap()
self.update(*args, **kw)
class FibonacciHeapDijkstra:
def __init__(self):
pass
nodeLinkAndCost = []
fibHeaps = []
fibHeap = Fibonacci_heap()
def createGraph(self):
nodes = []
g = Graph(nodes)
f = open("GeneratedGraph.txt", "r")
lines = f.readlines()
linesSize = len(lines)
f.close()
numberOfNodes = int(lines[0])
allNodeLinks = []
for i in range(0, numberOfNodes):
for j in range(1, numberOfNodes):
nodeAndLinks = lines[j].split("->")
links = nodeAndLinks[1].split(",")
allNodeLinks.append(links)
n = Node(i, i + 1, allNodeLinks[i])
g.getNodes().append(n)
actual = 1
for j in range(numberOfNodes, linesSize):
arcAndCost = lines[j].split("=")
arcElements = arcAndCost[0].split(",")
entry = (int(arcElements[0]), int(arcElements[1]))
priority = int(arcAndCost[1])
if actual == int(arcElements[0]):
self.fibHeap.enqueue(entry, priority)
else:
actual = int(arcElements[0])
self.fibHeaps.append(self.fibHeap)
self.fibHeap = Fibonacci_heap()
self.fibHeap.enqueue(entry, priority)
if j == linesSize - 1:
self.fibHeaps.append(self.fibHeap)
for i in range(0, numberOfNodes):
if i == 0:
g.getNodes()[i].setWeight(0)
else:
g.getNodes()[i].setWeight(999999)
return g
def dijkstraWithFibonacciHeap(self):
graph = self.createGraph()
nodes = graph.getNodes()
temporaryNodes = nodes
selected = temporaryNodes[0].getNodeId()
print("Init " + str(selected))
sink = nodes[len(nodes) - 1].getNodeId()
print("The sink is " + str(sink))
predecessors = []
trigger = selected
next = 0
start = time.clock()
while trigger != sink:
print("Node actually selected is: " + str(selected))
trigger = selected
if selected != sink:
elementInExam = ((
self.fibHeaps[next]).dequeue_min()).get_value()[1]
next = elementInExam - 1
predecessors.append(selected)
selected = elementInExam
predecessors.append(sink)
print("Dijkstra Algorithm performed in " + str((time.clock() - start)))
return predecessors
def __init__(self, *args, **kw):
self.itemlist = []
self.heap = Fibonacci_heap()
self.update(*args, **kw)
