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()