def init_central_trading_system(): global glob stockInfoList = StockInfo.objects.all() securityStockInfoList = SecurityStockInfo.objects.all() # this is accounts!!! for iStock in stockInfoList: glob.InstQueue[iStock.StockID] = (PriorityQueue(),PriorityQueue()) for iAccount in securityStockInfoList: # iSecStock glob.InstNotDealt[iAccount.SecurityID] = {} return True
def prims(graphObj, start): pq = PriorityQueue() for vertex in graphObj.verticesList: if vertex == start: g.verticesList[vertex].distance = 0 pq.insert([0, vertex]) continue g.verticesList[vertex].distance = INFINITY pq.insert([INFINITY, vertex]) while(len(pq.pqueue)): currentVertex = pq.extractMin() if len(pq.pqueue) == 1: return for adjNode in graphObj.verticesList[currentVertex[1]].getConnections(): if adjNode in pq.lookup(adjNode): newDistance = graphObj.verticesList[currentVertex[1]].getCost(adjNode) if newDistance < graphObj.verticesList[adjNode].distance: graphObj.verticesList[adjNode].distance = newDistance graphObj.verticesList[adjNode].predecessor = currentVertex[1] return graphObj
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0, self.n): # Iterate through all vertex ID if (i == srcID): # If ID is srcID pq.set(i, 0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices # COMPLETE the Dijkstra code here return (d, pi)
def eventFC(scorer, url_scorer, options): # seedUrls = ["http://www.cnn.com/2013/09/27/world/africa/kenya-mall-attack/index.html", # "http://www.youtube.com/watch?v=oU9Oop892BQ", # "http://ifrc.org/en/news-and-media/press-releases/africa/kenya/kenya-red-cross-society-continues-to-provide-vital-support-to-victims-and-families-of-the-westgate-shopping-mall-attack/" # ] #keywords = ['demonstrations','protest','elections','egypt','revolution','uprising','arab','spring','tunisia','libya','military'] t = [(-1, p, -1) for p in options['seeds']] #t = [(-1,Url(p)) for p in seedUrls] priorityQueue = PriorityQueue(t) crawler = Crawler(priorityQueue, scorer, options) crawler.set_url_scorer(url_scorer) crawler.enhanced_crawl() print crawler.relevantPagesCount print crawler.pagesCount f = open("harverstRatioData.txt", "w") for r, p in crawler.harvestRatioData: f.write(str(r) + "," + str(p) + "\n") f.close() f = open("logData.txt", "w") furl = open("Output-URLs.txt", "w") for p in crawler.relevantPages: f.write(str(p.pageId) + "," + str(p.pageUrl[2]) + "\n") furl.write(p.pageUrl[1] + "\n") f.close() furl.close()
def AStar(maze, x, y, fpoint): startPoint = Point(x, y, None) startPoint.f = startPoint.g = startPoint.h = 0 openList = PriorityQueue() openList.insert(startPoint) while (not (openList.isEmpty())): current_node = openList.delete() maze[current_node.x][current_node.y] = 3 if (current_node.isEqual(fpoint)): return current_node children = [] for pos in [(0, -1), (0, 1), (-1, 0), (1, 0)]: curr_x = current_node.x + pos[0] curr_y = current_node.y + pos[1] if (not (isFeasible(maze, curr_x, curr_y))): continue child = Point(curr_x, curr_y, current_node) children.append(child) for child in children: child.g = current_node.g + 1 child.h = manhattanDist(child, fpoint) child.f = child.g + child.h openList.insert(child)
def djisktra(self, a, b): distances = [float("inf") for _ in self.vertices] distances[a] = 0 predecessors = [None for _ in self.vertices] # queue = PriorityQueue() queue = PriorityQueue() queue.enqueue((distances[a], self.vertices[a].label)) while True: if queue.empty(): break # print(queue) _, current = queue.dequeue() if current is b: break # dequeue a node we already looked at # this may not be necessary because it will just not decrease any travel times anyway else: # traverse adj list, and see if any are shorter than current dist for v in self.vertices[current].adj: temp = distances[current] + weight(self.vertices[current], self.vertices[v]) if distances[v] > temp: distances[v] = temp predecessors[v] = current queue.enqueue((temp, v)) # shouldn't this be (distances[v], v) count = 0 for distance in distances: if (distance != float("inf")): count+=1 #print((distances[b], predecessors[b], count)) return (distances, predecessors, count)
def performUCS(self, position, goal): to_explore = PriorityQueue() explored = set() prevNode = dict({position: 0}) to_explore.push(position, 0) while (not(to_explore.is_empty())): aux = to_explore.pop() node = aux[0] prevCost = aux[1] to_explore.remove(node) if (goal == node): return prevNode explored.add(node) actions = ['N','S','E','W'] for action in actions: child, actionCost = self.step(node, action) if not(child == node): cost = prevCost + actionCost if not(child in explored or child in to_explore): to_explore.push(child, cost) prevNode[child] = (node, action) elif child in to_explore and cost < to_explore.getCost(child): to_explore.update(child, cost) prevNode[child] = (node, action) return None
def color_most_constrained_first(graphs, color): global spills, unspillable, num_unused, used_registers #print 'starting color_most_constrained_first' for v in graphs.vertices(): used_registers[v] = set([]) num_unused[v] = len(registers) - len(used_registers[v]) left = set(graphs.vertices()) - set(reserved_registers) - set(registers) queue = PriorityQueue(left, avail_reg_then_unspill) while not queue.empty(): v = queue.pop() if debug: print 'next to color is ' + v if v not in color.keys(): c = choose_color(v, color, graphs, False) color[v] = c for u in graphs.interferes_with(v): #if u in graphs.vertices(): queue.update(u) used_registers[u] |= set([c]) num_unused[u] = len(registers) - len(used_registers[u]) if not is_reg(c): spills += 1 return color
def topKFrequent(self, nums, k): """ :type nums: List[int] :type k: int :rtype: List[int] """ dict_num = dict() for num in nums: if num not in dict_num: dict_num[num] = 1 else: dict_num[num] += 1 pq = PriorityQueue() for key in dict_num.keys(): if pq.getSize() < k: pq.enqueue(self.__Freq(key, dict_num[key])) continue if pq.getFront().freq < dict_num[key]: pq.dequeue() pq.enqueue(self.__Freq(key, dict_num[key])) re = [] while pq.isEmpty() is not True: re.insert(0, pq.dequeue().value) return re
def dijkstra(graphObj, startVertex): pq = PriorityQueue() for vertex in graphObj.getVertices(): if vertex == startVertex: pq.insert([0, vertex]) graphObj.verticesList[startVertex].distance = 0 else: pq.insert([INFINITY, vertex]) while(len(pq.pqueue)): currentVertex = pq.extractMin() if len(pq.pqueue) == 1: break # print(pq.pqueue, pq.lookup) for adjNode in graphObj.verticesList[currentVertex[1]].getConnections(): newDistance = graphObj.verticesList[currentVertex[1]].distance + graphObj.verticesList[currentVertex[1]].adjList[adjNode] if newDistance < graphObj.verticesList[adjNode].distance: graphObj.verticesList[adjNode].distance = newDistance graphObj.verticesList[adjNode].predecessor = currentVertex[1] index = pq.lookup[adjNode] pq.decreaseKey(index, newDistance) return graphObj
def hillClimb(self): PQ = PriorityQueue() ricList = self.findRIC() for nn in range(len(ricList)): # Add left leftMap = self.moveLeft(ricList[nn]) if (leftMap != None): PQ.push(leftMap, UPGetScore.getMapScore(leftMap)) # Add right rightMap = self.moveRight(ricList[nn]) if (rightMap != None): PQ.push(rightMap, UPGetScore.getMapScore(rightMap)) # Add up upMap = self.moveUp(ricList[nn]) if (upMap != None): PQ.push(upMap, UPGetScore.getMapScore(upMap)) # Add down downMap = self.moveDown(ricList[nn]) if (downMap != None): PQ.push(downMap, UPGetScore.getMapScore(downMap)) return PQ
def performAStar(self, position, goal): to_explore = PriorityQueue() explored = set() prevNode = dict({position: 0}) costs = dict({position: 0}) to_explore.push(position, 0 + self.model.h(position, goal)) stepCounter = 0 while (not (to_explore.is_empty())): node = to_explore.pop()[0] to_explore.remove(node) if (goal == node): return prevNode explored.add(node) actions = ['N', 'S', 'E', 'W'] for action in actions: child, actionCost = self.step(node, action) if not (child == node): prevCost = costs[node] + actionCost cost = prevCost + self.model.h(child, goal) if not (child in explored or child in to_explore): to_explore.push(child, cost) costs[child] = prevCost prevNode[child] = (node, action) elif child in to_explore and cost < to_explore.getCost( child): to_explore.update(child, cost) costs[child] = prevCost prevNode[child] = (node, action) return None
def baseFC(crawlParams): seedURLs = crawlParams['seedURLs'] t = [(-1, p, -1, "") for p in seedURLs] priorityQueue = PriorityQueue(t) classifierFileName = crawlParams['classifierFileName'] crawlParams["priorityQueue"] = priorityQueue try: classifierFile = open(classifierFileName, "rb") vsmClf = pickle.load(classifierFile) #self.classifier.error = 0.05 #self.classifier.relevanceth = 0.75 classifierFile.close() except: #vsmClf = VSMClassifier() vsmClf = VSM_CentroidClassifier() vsmClf.buildModel(crawlParams['model'], topK=10) #vsmClf.buildVSMClassifier(crawlParams['seedURLs'],classifierFileName,crawlParams['eventType'], crawlParams['minCollFreq']) print 'Saving model to file' classifierFile = open(classifierFileName, "wb") pickle.dump(vsmClf, classifierFile) classifierFile.close() crawlParams['scorer'] = vsmClf #keywordModel = KeywordModel() #keywordModel.buildModel(crawlParams['model'])#,crawlParams['No_Keywords']) #crawlParams['scorer']=keywordModel #crawler = Crawler(priorityQueue,scorer,options) crawler = Crawler(crawlParams) qu = crawler.crawl() quS = '\n'.join([str(-1 * s[0]) + "," + s[1] for s in qu]) with open('queueBase.txt', 'w') as fw: fw.write(quS.encode('utf8')) return crawler.relevantPages
def __init__(self,newsSeedList,socialSeedList,govSeedList): self.turn = 0 ''' if newsSeedList is not None: self.newsQueue = PriorityQueue(newsSeedList) if socialSeedList is not None: self.socialQueue = PriorityQueue(socialSeedList) if govSeedList is not None: self.govQueue = PriorityQueue(govSeedList) ''' self.newsQueue = PriorityQueue(newsSeedList) self.socialQueue = PriorityQueue(socialSeedList) self.govQueue = PriorityQueue(govSeedList) heapq.heapify(self.newsQueue.queue) heapq.heapify(self.socialQueue.queue) heapq.heapify(self.govQueue.queue)
def bipartite(w, discrepancy): Ebp_edges = [] Q = PriorityQueue() incident_edges = dict() for e in w: Q.add_task(e, -w[e]) incident_edges.setdefault(e[0], []).append((e[1], w[e])) incident_edges.setdefault(e[1], []).append((e[0], w[e])) processed_edges = [] while len(processed_edges) < len(w): (e, weight) = Q.pop_item() processed_edges.append(e) try: incident_edges[e[0]].remove((e[1], -weight)) incident_edges[e[1]].remove((e[0], -weight)) except ValueError: pass Ebp_edges.append(e) # discard all edges in Q incident to b (i.e. e[1]) for (a, weight) in incident_edges[e[1]]: try: Q.remove_task((a, e[1])) processed_edges.append((a, e[1])) except KeyError: pass try: incident_edges[a].remove((e[1], weight)) incident_edges[e[1]].remove((a, weight)) except ValueError: pass discrepancy[e[0]] += 1 discrepancy[e[1]] += 1 if -1 < discrepancy[e[0]] < .5: for (x, _) in incident_edges[e[0]]: try: Q.remove_task((e[0], x)) except KeyError: pass new_weight = abs( discrepancy[e[0]]) + 2 * abs(discrepancy[x]) - abs( discrepancy[e[0]]) - 1 if new_weight > 0: Q.add_task((e[0], x), -new_weight) else: processed_edges.append((e[0], x)) elif discrepancy[e[0]] > .5: for (x, _) in incident_edges[e[0]]: try: Q.remove_task((e[0], x)) processed_edges.append((e[0], x)) except KeyError: pass return Ebp_edges
def test_enqueue(self): priority_queue = PriorityQueue() priority_queue.enqueue(10, 6) priority_queue.enqueue(20, 5) priority_queue.enqueue(30, 4) priority_queue.enqueue(40, 3) priority_queue.enqueue(50, 2) priority_queue.enqueue(60, 1) priority_queue.enqueue(70, 0) self.assertEqual([{0: 70}, {3: 40}, {1: 60}, {6: 10}, {4: 30}, {5: 20}, {2: 50}], priority_queue.returnQueue())
def run(layout, heuristic): layoutText = load_maze(layout) currentMaze = Maze(layoutText) aMaze = Maze(layoutText) aProblem = Problem(aMaze) numberOfMoves = 0 fringe = PriorityQueue() visitedNodes = set() goal = a_star_search(aProblem, heuristic, fringe, visitedNodes) path = list() while goal is not None: path.insert(0, goal) numberOfMoves += 1 goal = goal.get_parent() move = 0 print("For Heuristics: ", heuristic) if len(path) > 0: print("|------------- STARTING MAZE--------------|\n") currentMaze.update_maze(path[0].get_x_coordinate(), path[0].get_y_coordinate(), "S") currentMaze.printMaze() print( "\n|------------- STARTING DICE ORIENTATION--------------|\n") path[0].dice.display() for currentNode in path: print("\n|-------------------- MOVE: " + str(move) + " -------------------|\n") print("|------------- MAZE--------------|\n") currentMaze.update_maze(currentNode.get_x_coordinate(), currentNode.get_y_coordinate(), '#') currentMaze.printMaze() print("\n|------------- DICE--------------|\n") currentNode.dice.display() move += 1 print("\n|---------------- PERFORMANCE METRICS -----------------|\n") print("No. of moves in the solution : ", numberOfMoves - 1) print("No. of nodes put on the queue : ", fringe.nodesPutOnQueue) print("No. of nodes visited / removed from the queue : ", len(visitedNodes)) print("\n|------------------------------------------------------|\n") result = [ heuristic, numberOfMoves - 1, fringe.nodesPutOnQueue, len(visitedNodes) ] return result
def __init__(self, maze): #super already sets the start as the current cell super(Astar, self).__init__(maze, maze.start()) self.strategy = "Euclidean" #make it possible to choose an option which heuristic can be used #current position not necessary, stored in walker #open list containing all cells to explore self.open = PriorityQueue() self.closed = dict()# node:parent self.g = 10 #total costs the agent took so far self.last = None self.closed[self._cell] = None
def test_priority_and_sort_order(): p = PriorityQueue() p.add(1, 1) p.add(2, 1) p.add(3, 2) p.add(4, 1) assert p.pop() == 3 assert p.pop() == 1 assert p.pop() == 2 assert p.pop() == 4 assert p.peek() is None
def run(layout, heuristic): """ It initialize the configuration parameters and run the a star algorithm on the maze data and gets the output. :param layout: Two dimensional array of maze configuration :param heuristic: Type of heuristic :return: return a list which contains heuristic name, number of moves it took, number of node generated and visited """ layoutText = loadMaze(layout) currentMaze = Maze(layoutText) aMaze = Maze(layoutText) aProblem = Problem(aMaze) numberOfMoves = 0 fringe = PriorityQueue() visitedNodes = set() goal = aStarSearch(aProblem, heuristic, fringe, visitedNodes) path = list() while goal is not None: path.insert(0, goal) numberOfMoves += 1 goal = goal.getParent() move = 0 print("For Heuristics: ", heuristic) if len(path) > 0: print("|------------- STARTING MAZE--------------|\n") currentMaze.updateMaze(path[0].getxCoordinate(), path[0].getyCoordinate(), "S") currentMaze.printMaze() print("\n|------------- STARTING DICE ORIENTATION--------------|\n") path[0].dice.display() for currentNode in path: print("\n|-------------------- MOVE: " + str(move) + "--------------------|\n") print("|------------- MAZE--------------|\n") currentMaze.updateMaze(currentNode.getxCoordinate(), currentNode.getyCoordinate(), '#') currentMaze.printMaze() print("\n|------------- DICE--------------|\n") currentNode.dice.display() move += 1 print("\n|---------------- PERFORMANCE METRICS -----------------|\n") print("No. of moves in the solution : ", numberOfMoves - 1) print("No. of nodes put on the queue : ", fringe.nodesPutOnQueue) print("No. of nodes visited / removed from the queue : ", len(visitedNodes)) print("\n|------------------------------------------------------|\n") result = [heuristic, numberOfMoves - 1, fringe.nodesPutOnQueue, len(visitedNodes)] return result
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue cur = self for i in range(0, self.n): # Iterate through all vertex ID if (i == srcID): # If ID is srcID pq.set(i, 0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices minKey, minDist = pq.extractMin() d[minKey] = minDist #set orignal source distance to 0 pi[minKey] = minKey #set sources to orginal source while (pq.isEmpty() == False): # COMPLETE the Dijkstra code here lst = self.adjList[ minKey] #grap array of lists of format (vertices,weight) for node minKey for n in lst: #loop through said list ##grap the next node attached to this node somehow dist = n[1] + minDist #grab distance from list node = n[0] #grab node from list if (pq.hasKey(node) ): #check if that nodes min dist has been found if ( pq.get(node) > dist ): #check if path to the node from minKey is less then current path pq.set(node, dist) #set the nodes distance in the queue d[node] = dist #set the nodes distance in the return array pi[node] = minKey #sets the nodes parents minKey, minDist = pq.extractMin( ) #extract next node dont need to extract last node as all the paths will be filled would probably work better in a do while loop return (d, pi)
def __init__(self): ''' Method for initializing an empty Network. ''' self._nodes = set() self._topLevelNodes = set() self._bottomLevelNodes = set() self._allLinks = set() self._topLevelLinks = set() self._cutLinks = set() self._sortedLinks = PriorityQueue() self._idDict = {} self._idCounter = 0
def Dijkstras(graph,start): pq=PriorityQueue() start.setDistance(0) pq.buildHeap([(v.getDistance(),v) for v in graph]) # distance is the key in the priority queue while not pq.isEmpty(): currentvertex=pq.delMin() for newvertex in currentvertex.getConnections(): newDist=currentvertex.getDistance()+currentvertex.getWeight(newvertex) if newDist<newvertex.getDistance(): # at the start the distance of all the vertices is set to maximum. That's why the if statement will be executed newvertex.setDistance(newDist) newvertex.setPredecessor(currentvertex) pq.decreaseKey(newvertex,newDist)
def test_dequeue(self): priority_queue = PriorityQueue() priority_queue.enqueue(10, 6) priority_queue.enqueue(20, 5) priority_queue.enqueue(30, 4) priority_queue.enqueue(40, 3) priority_queue.enqueue(50, 2) priority_queue.enqueue(60, 1) priority_queue.enqueue(70, 0) returned_node = priority_queue.dequeue() self.assertEqual(70, returned_node.get_value()) self.assertEqual([{1: 60}, {3: 40}, {2: 50}, {6: 10}, {4: 30}, {5: 20}], priority_queue.returnQueue())
def dijkstra(aGraph, start): pq = PriorityQueue() start.setDistance(0) pq.buildHeap([(v.getDistance(), v) for v in aGraph]) while not pq.isEmpty(): currentVert = pq.delMin() for nextVert in currentVert.getConnections(): newDist = currentVert.getDistance() \ + currentVert.getWeight(nextVert) if newDist < nextVert.getDistance(): nextVert.setDistance(newDist) nextVert.setPred(currentVert) pq.decreaseKey(nextVert, newDist)
def buildTree(self, text): queue = PriorityQueue(cmp=lambda a,b: a.frequency > b.frequency) for v,f in dict(Counter(list(text))).items(): queue.enqueue(BinaryNode(v, f)) while queue.size() > 1: nodeL = queue.dequeue() nodeR = queue.dequeue() parent = BinaryNode(None, nodeL.frequency+nodeR.frequency) parent.left = nodeL parent.right = nodeR queue.enqueue(parent) self.root = queue.dequeue()
def test_pop(self): main_list = [] pqueue = PriorityQueue() for i in range(0, 1000): main_list.insert(i, i) random.shuffle(main_list) for i in range(0, 1000): pqueue.push(main_list[i], main_list[i]) for i in range(999, -1, -1): self.assertEqual(pqueue.pop(), 999 - i) self.assertEqual(pqueue.size(), i)
def aStarSearch(problem, evaluator, verbose=None, limit=None): startTime = time.process_time() fringe = PriorityQueue() max_fringe_size = 0 visited = {} initialWorldState = problem.initial() initialValue = evaluator.value(initialWorldState, []) initialSearchState = SearchState(initialWorldState, []) fringe.update(initialSearchState, initialValue) numVisited = numSkipped = 0 while (True): if len(fringe.heap) > max_fringe_size: max_fringe_size = len(fringe.heap) if fringe.isEmpty(): return (None, (time.process_time() - startTime, numVisited, numSkipped, max_fringe_size)) nextNode = fringe.pop() # A search state (state, actions) numVisited += 1 if (limit and numVisited > limit): return (None, (time.process_time() - startTime, numVisited, numSkipped, max_fringe_size)) if (verbose and numVisited % verbose == 0): print("Visited " + str(numVisited) + " world is " + str(nextNode._worldState)) print("Skipped " + str(numSkipped) + " Fringe is size " + str(len(fringe.heap))) print("Evaluation is " + str(evaluator.value(nextNode._worldState, nextNode._actions)) + \ " with actions " + str(len(nextNode._actions))) if (problem.isGoal(nextNode.worldState())): return (nextNode._actions, (time.process_time() - startTime, numVisited, numSkipped, max_fringe_size)) if (nextNode._worldState in visited): numSkipped += 1 else: visited[nextNode.worldState()] = True successors = nextNode.worldState().successors() for successor in successors: state, action = successor actions = list(nextNode.actions()) actions.append(action) newSS = SearchState(state, actions) newValue = evaluator.value(state, actions) fringe.update(newSS, newValue) raise "Impossible search execution path."
def prim(graph,start): # it belongs to the family of greedy algorithms pq=PriorityQueue() for v in graph: v.setDistance(sys.maxsize) v.setPredecessor(None) start.setDistance(0) pq.buildHeap([(v.getDistance(),v) for v in graph]) while not pq.isEmpty() currentvertex=pq.delMin() for newvertex in currentvertex.getConnections(): newDist=currentvertex.getWeight(newvertex) if newDist<newvertex.getDistance() and newvertex in pq: newvertex.setDistance(newDist) newvertex.setPredecessor(currentvertex) pq.decreaseKey(newvertex,newDist)
def test_push(self): main_list = [] for i in range(0, 1000): main_list.insert(i, i) random.shuffle(main_list) pqueue = PriorityQueue() for i in range(0, 1000): pqueue.push(main_list[i], main_list[i]) self.assertEqual(pqueue.size(), i + 1) self.assertFalse(pqueue.isEmpty()) self.assertEqual(pqueue.pop(), 0) self.assertEqual(pqueue.pop(), 1)