def AStar(self):
'''Returns the minimum costing result from currenState and the
time spent for computing it.'''
# This part uses the A* algorithm to find the best solution for
# the puzzle. The algorithm is accompanied by a priority queue
# implemented by a fibonacci heap with inserting complexity of
# O(1) and popping the minimum with O(logn). The fibonacci heap
# mod by a third party is used here
# (https://pypi.python.org/pypi/fibonacci-heap-mod).
startTime = time.time()
visited = list(False for i in range(363000))
queue = fh.Fibonacci_heap()
queue.enqueue(self.currentState, self.currentState.F())
visited[self.currentState.hash()] = True
while True:
current = queue.min().get_value()
queue.dequeue_min()
if current.goalTest():
finTime = time.time()
return current, finTime - startTime
suc = current.getSuccessors()
for s in suc:
if not visited[s.hash()]:
visited[s.hash()] = True
queue.enqueue(s, s.cost + s.heuristic)
def __init__(self, g):
self.__g = g
self.__g_norm = 0
self.__pos_heap = fhm.Fibonacci_heap()
self.__neg_heap = fhm.Fibonacci_heap()
self.__pos_g_elems = []
self.__neg_g_elems = []
if max(g.shape) <= 1e8: # dense vectors work significantly better if not blow memory
for i, val in enumerate(np.squeeze(g.toarray())):
self.__pos_g_elems.append(self.__pos_heap.enqueue(i, val))
self.__neg_g_elems.append(self.__neg_heap.enqueue(i, -val))
self.__g_norm += val**2
else:
raise Exception("This method hasn't been tested yet on dimensions n > 10^8, sorry :(")
def charikar_densest(G):
E = G.number_of_edges()
N = G.number_of_nodes()
fib_heap = fibonacci_heap_mod.Fibonacci_heap()
entries = {}
order = []
S = copy.deepcopy(G)
for node, deg in G.degree_iter():
entries[node] = fib_heap.enqueue(node, deg)
best_avg = 0.0
iter = 0
while fib_heap:
avg_degree = (1.0 * E)/N
if best_avg <= avg_degree:
best_avg = avg_degree
best_iter = iter
min_deg_obj = fib_heap.dequeue_min()
min_deg_node = min_deg_obj.get_value()
order.append(min_deg_node)
for n in S.neighbors_iter(min_deg_node):
fib_heap.decrease_key(entries[n], 1)
S.remove_node(min_deg_node)
E -= min_deg_obj.get_priority()
N -= 1
iter += 1
return best_avg
def dijkstra(G, s):
#Inicialização
for node in G.nodes():
G.node[node]['d'] = sys.maxsize
G.node[node]['py'] = None
G.node[node]['visited'] = False
G.node[node]['heap_entry'] = False
G.node[s]['d'] = 0
S = [] #Guarda o caminho mais curto
Q = fb.Fibonacci_heap()
for node in G.nodes():
G.node[node]['heap_entry'] = Q.enqueue(node, G.node[node]['d'])
while Q.m_size != 0:
fb_entry = Q.dequeue_min()
u = fb_entry.m_elem
G.node[u]['visited'] = True
for v in G.neighbors(u):
if G.node[v]['d'] > G.node[u]['d'] + G.edge[u][v]['weight']:
new_distance = G.node[u]['d'] + G.edge[u][v]['weight']
if (not G.node[v]['visited']):
Q.decrease_key(G.node[v]['heap_entry'], new_distance)
G.node[v]['d'] = new_distance
G.node[v]['py'] = u
def init(engine):
tier1 = fibonacci_heap_mod.Fibonacci_heap()
global infTime
infTime = int(engine.infTime) + 1
#for e in engine.entities:
# for x in engine.entities[e]:
# tier = tier2(infTime)
# tierDict[(e,x)] = tier1.enqueue(tier,tier.key)
return tier1
def __init__(self, data):
self.__heap = fhm.Fibonacci_heap()
self.__elements = []
if sparse.issparse(data):
data = np.squeeze(data.toarray())
for k, v in enumerate(data):
self.insert(k, v)
t = 1
def __find(self, beta):
E = self.G.number_of_edges()
N = self.G.number_of_nodes()
number_of_nodes = self.G.number_of_nodes()
fib_heap = fb.Fibonacci_heap()
entries = {}
self.node2set, set2nodes = {}, {}
S = copy.deepcopy(self.G)
for node, deg in S.degree_iter():
entries[node] = fib_heap.enqueue(node, deg)
best_avg = 0.0
iter = 0
avg_degree = 1.0 * S.number_of_edges() / S.number_of_nodes()
if best_avg <= avg_degree:
best_avg = avg_degree
best_iter = iter
maxiter = np.ceil(math.log(float(number_of_nodes), self.eps + 1))
while fib_heap and iter < maxiter and fib_heap.min().get_priority(
) < 2. * (1 + self.eps) * beta:
set2nodes[iter] = []
while fib_heap and fib_heap.min().get_priority() < 2. * (
1 + self.eps) * beta:
min_deg_obj = fib_heap.dequeue_min()
min_deg_node = min_deg_obj.get_value()
set2nodes[iter].append(min_deg_node)
self.node2set[min_deg_node] = iter
for n in set2nodes[iter]:
for neigh in S.neighbors_iter(n):
if neigh not in set2nodes[iter]:
fib_heap.decrease_key(entries[neigh], 1)
S.remove_nodes_from(set2nodes[iter])
iter += 1
avg_degree = 1.0 * S.number_of_edges() / S.number_of_nodes(
) if S else 0.0
if best_avg <= avg_degree:
best_avg = avg_degree
best_iter = iter
i = min(iter, maxiter)
while fib_heap:
min_deg_node = fib_heap.dequeue_min().get_value()
self.node2set[min_deg_node] = i
self.bestiter = best_iter
return best_avg
def dijkstra(aGraph, start):
#print("Dijkstra's shortest path")
# Define como zero a distancia para o ponto inicial
start.set_distance(0)
# Inicializa a pripority queu
unvisited_queue = fibonacci_heap_mod.Fibonacci_heap()
for v in aGraph:
v.set_heap(unvisited_queue.enqueue(v,v.get_distance()))
while unvisited_queue.m_size != 0: #Este loop será feito uma vez para cada vértice do Grafo - O(n)
# Pega o vertice com a menor distancia da priority queu
# Pops a vertex with the smallest distance
# O(n) - percorre o vetor unvisited_queue inteiro por lista - O(n) no pior caso
#print("elementos na queue: %i" %len(unvisited_queue))
#uv = heapq.heappop(unvisited_queue)
distancia_minima = sys.maxsize
uv = []
node = []
node = unvisited_queue.dequeue_min()
uv = node.m_elem
if uv == None:
break
current = uv
current.set_visited()
modify = False
#Para todo vértice na lista de adjacencia do vertice atual: -
for next in current.adjacent: # este for leva no máximo
# Pula caso já tenha sido visitado
if next.visited:
continue
new_dist = current.get_distance() + current.get_weight(next)
if new_dist < next.get_distance():
unvisited_queue.decrease_key(next.get_heap(),new_dist)
next.set_distance(new_dist)
next.set_previous(current)
modify = True
def charikarBasic(G, mode='unweighted'):
if mode == 'weighted':
attr = 'weight'
else:
attr = None
E = G.number_of_edges()
N = G.number_of_nodes()
fib_heap = fibonacci_heap_mod.Fibonacci_heap()
entries = {}
order = []
S = copy.deepcopy(G)
for node, deg in G.degree_iter():
entries[node] = fib_heap.enqueue(node, deg)
best_avg = 0.0
iter = 0
while fib_heap:
avg_degree = (2.0 * E) / N
if best_avg <= avg_degree:
best_avg = avg_degree
best_iter = iter
min_deg_obj = fib_heap.dequeue_min()
min_deg_node = min_deg_obj.get_value()
order.append(min_deg_node)
for n in G.neighbors_iter(min_deg_node):
fib_heap.decrease_key(entries[n], -1)
E -= 1
G.remove_node(min_deg_node)
N -= 1
iter += 1
for i in xrange(best_iter):
S.remove_node(order[i])
return S, best_avg
def Dijkstra(graph, s, V):
#init
v = len(graph)
dist = np.zeros(v)
#prev = np.zeros(v)
dist[:] = np.inf
dist[s] = 0
#prev[:] = np.NaN
#S= []
Entry_list = []
#Q_list = range(v)
Q_FHeap = fhp.Fibonacci_heap()
for i in range(v):
Entry_list = Entry_list + [Q_FHeap.enqueue(i, dist[i])]
#while len(Q_list) > 0:
while (Q_FHeap):
#r_list = extract_min ( Q_list , dist )
r_FHeap = Q_FHeap.dequeue_min()
#print "r.elem= " , r_FHeap.m_elem , " r.pri = ", r_FHeap.m_priority
#print "r.list= " , r_list , " dist[r] = ", dist[r_list]
#S = S + [ r_list ]
#r = r_list
r = r_FHeap.m_elem
#S = S + [ r ]
for c in V[r]:
if dist[r] + graph[r][c] < dist[c]:
dist[c] = dist[r] + graph[r][c]
Q_FHeap.decrease_key(Entry_list[c], dist[c])
'''
for c in range(v):
if graph[r][c] < np.inf:
if dist[r] + graph[r][c] < dist[c]:
dist[c] = dist[r] + graph[r][c]
#print Entry_list[c].m_elem , ", ", Entry_list[c].m_priority, ", " , dist[c]
Q_FHeap.decrease_key( Entry_list[c] , dist[c] )
# prev[c] = r
'''
return dist
def a_star(self, start, end, heur):
dist = {start: 0}
visited = set()
Q = hq.Fibonacci_heap()
Q_index = {}
Q_index[start] = Q.enqueue(start, 0)
while Q:
current = Q.dequeue_min().get_value()
visited.add(current)
if heur(current, end) < 0.1:
return dist[current]
for child in self.get_children(current):
if child in visited:
continue
if child not in dist:
dist[child] = dist[current] + 1
Q_index[child] = Q.enqueue(child,
dist[child] + heur(child, end))
elif child in dist and dist[child] > dist[current] + 1:
dist[child] = dist[current] + 1
Q.decrease_key(Q_index[child],
dist[child] + heur(child, end))
def __init__(self, locations, densities, target_samples, is_volume, mesh_area):
self.locations = locations
# Setup a KD Tree of all lcations
self.tree = mathutils.kdtree.KDTree(len(locations))
for index, location in enumerate(locations):
self.tree.insert(location, index)
self.tree.balance()
self.alpha = 8
self.target_samples = target_samples
self.current_samples = len(self.locations)
M = self.current_samples
N = self.target_samples
# Choose rmax via heuristic
bounds = [max(p[i] for p in locations) - min(p[i] for p in locations)
for i in range(3)]
# Volume based constraint
A = bounds[0] * bounds[1] * bounds[2]
rmax3 = (A / 4 / math.sqrt(2) / N) ** (1 / 3)
# Volume estimate only valid for reasonably squarish things
is_thin = rmax3 <= min(bounds)
if is_thin:
rmax3 = float('inf')
if is_thin or not is_volume:
# If we are constrained to 2d surface, then it is possible to
# get a better bound for rmax. Depends on the mesh geometry.
rmax2 = math.sqrt(mesh_area / 2 / math.sqrt(3) / N)
else:
rmax2 = float('inf')
self.rmax = min(rmax2, rmax3)
if densities is not None:
# Need to be a bit more conservative if the faces are imbalanced.
# This could still go wrong with extreme vertex weights...
self.rmax *= 3
dmax = max(densities)
self.densities = [d / dmax for d in densities]
else:
self.densities = [1] * len(locations)
# Choose rmin via heuristic
gamma = 1.5
beta = 0.65
self.rmin = self.rmax * (1 - (N / M) ** gamma) * beta
# Build initial heap
self.heap = fibonacci_heap_mod.Fibonacci_heap()
self.heap_items = {}
for index, location in enumerate(locations):
tot_weight = 0
for location2, index2, d in self.tree.find_range(location, 2 * self.rmax):
tot_weight += self.w(d, index, index2)
item = self.heap.enqueue(index, -tot_weight)
self.heap_items[index] = item
def __init__(self, queue_type="default"):
self.queue_format = queue_type
self.basic_queue = {}
self.fib_queue = fib.Fibonacci_heap()
def __init__(self, key):
self.key = key
self.arr = fibonacci_heap_mod.Fibonacci_heap()
def init(engine):
return fibonacci_heap_mod.Fibonacci_heap()