Ejemplo n.º 1
0
 def test_length(self):
     q = PriorityQueue()
     assert q.length() == 0
     q.enqueue('A', 5)
     assert q.length() == 1
     q.enqueue('B', 1)
     assert q.length() == 2
     q.dequeue()
     assert q.length() == 1
     q.dequeue()
     assert q.length() == 0
Ejemplo n.º 2
0
 def test_front(self):
     q = PriorityQueue()
     assert q.front() is None
     q.enqueue('A', 6)
     assert q.front() == 'A'
     q.enqueue('B', 10)
     assert q.front() == 'A'
     q.dequeue()
     assert q.front() == 'B'
     q.dequeue()
     assert q.front() is None
Ejemplo n.º 3
0
 def test_front(self):
     pq = PriorityQueue()
     assert pq.front() is None
     pq.enqueue('A', 1)
     assert pq.front() == (1, 'A')
     pq.enqueue('B', 2)
     assert pq.front() == (1, 'A')
     pq.dequeue()
     assert pq.front() == (2, 'B')
     pq.dequeue()
     assert pq.front() is None
Ejemplo n.º 4
0
 def test_dequeue(self):
     pq = PriorityQueue([(1, 'A'), (2, 'B'), (3, 'C')])
     assert pq.dequeue() == (1, 'A')
     assert pq.length() == 2
     assert pq.dequeue() == (2, 'B')
     assert pq.length() == 1
     assert pq.dequeue() == (3, 'C')
     assert pq.length() == 0
     assert pq.is_empty() is True
     with self.assertRaises(ValueError):
         pq.dequeue()
Ejemplo n.º 5
0
 def test_is_empty(self):
     p = PriorityQueue()
     assert p.is_empty() is True
     p.enqueue('A', 1)
     assert p.is_empty() is False
     p.enqueue('B', 1)
     assert p.is_empty() is False
     p.dequeue()
     assert p.is_empty() is False
     p.dequeue()
     assert p.is_empty() is True
Ejemplo n.º 6
0
 def test_length(self):
     pq = PriorityQueue()
     assert pq.length() == 0
     pq.enqueue('A', 1)
     assert pq.length() == 1
     pq.enqueue('B', 2)
     assert pq.length() == 2
     assert pq.dequeue() == (1, 'A')
     assert pq.length() == 1
     assert pq.dequeue() == (2, 'B')
     assert pq.length() == 0
Ejemplo n.º 7
0
 def test_front(self):
     p = PriorityQueue()
     assert p.front() is None
     p.enqueue('A', 2)
     assert p.front() == 'A'
     p.enqueue('B', 2)
     assert p.front() == 'A'
     p.enqueue('C', 1)
     assert p.front() == 'C'
     p.dequeue()
     assert p.front() == 'A'
     p.dequeue()
     assert p.front() == 'B'
Ejemplo n.º 8
0
 def test_dequeue(self):
     q = PriorityQueue()
     q.enqueue('A', 1)
     q.enqueue('B', 2)
     q.enqueue('C', 3)
     assert q.dequeue() == 'A'
     assert q.length() == 2
     assert q.dequeue() == 'B'
     assert q.length() == 1
     assert q.dequeue() == 'C'
     assert q.length() == 0
     assert q.is_empty() is True
     with self.assertRaises(ValueError):
         q.dequeue()
Ejemplo n.º 9
0
 def test_dequeue(self):
     p = PriorityQueue()
     assert p.heap.items == []
     p.enqueue('A', 2)
     assert p.heap.items == [(2, 'A')]
     p.enqueue('B', 2)
     assert p.heap.items == [(2, 'A'), (2, 'B')]
     p.enqueue('C', 1)
     assert p.heap.items == [(1, 'C'), (2, 'B'), (2, 'A')]
     p.enqueue('D', 1)
     assert p.heap.items == [(1, 'C'), (1, 'D'), (2, 'A'), (2, 'B')]
     p.enqueue('E', 3)
     assert p.heap.items == [(1, 'C'), (1, 'D'), (2, 'A'), (2, 'B'),
                             (3, 'E')]
     p.enqueue('F', 2)
     assert p.heap.items == [(1, 'C'), (1, 'D'), (2, 'A'), (2, 'B'),
                             (3, 'E'), (2, 'F')]
     assert p.dequeue() == 'C'
     assert p.heap.items == [(1, 'D'), (2, 'B'), (2, 'A'), (2, 'F'),
                             (3, 'E')]
     assert p.dequeue() == 'D'
     assert p.heap.items == [(2, 'A'), (2, 'B'), (3, 'E'), (2, 'F')]
     assert p.dequeue() == 'A'
     assert p.heap.items == [(2, 'B'), (2, 'F'), (3, 'E')]
     assert p.dequeue() == 'B'
     assert p.heap.items == [(2, 'F'), (3, 'E')]
     assert p.dequeue() == 'F'
     assert p.heap.items == [(3, 'E')]
     assert p.dequeue() == 'E'
     assert p.heap.items == []
     with self.assertRaises(ValueError):
         p.dequeue()
Ejemplo n.º 10
0
def dijkstra_search(root, goal, init, domprob, nb_robots, width, height):
    """Dijkstra search of a solution in a graph.
    Returns a path if there is any.

    The priority of each node represent the cost
    (if each action costs 1) to go from the root
    to the node.

    Parameters:
        root: Node object, the root of the state graph we're
              searching and building at the same time.
        goal: bitvector, the state we're searching.
        init: bitvector, the initial state of the maze.
        domprob: Domain-Problem object from the pddlpy lib.
        nb_robots: integer, the number of robots in the maze.
        width, height: integers, the dimensions of the maze.
    """
    # Priority queue
    pqueue = PriorityQueue()
    # an empty set to maintain visited nodes
    closed_set = set()
    # a dictionary for path formation
    meta = dict()  # key -> (parent state, action to reach child)
    # Operator list
    op_list = list(domprob.operators())

    # initialize
    pqueue.insert(root)

    meta[root] = (None, None)
    ground_op_bv = get_ground_operator(
        op_list, domprob, init, nb_robots, width, height)
    print("Taille de ground_op : {}".format(len(ground_op_bv[0])))

    while not pqueue.empty():
        subtree_root = pqueue.dequeue()
        current_priority = subtree_root.priority

        if is_goal(subtree_root, goal):
            return construct_path(subtree_root, meta)

        # Create current node's children
        for op in ground_op_bv:
            subtree_root.build_children(op)

        for (child, action) in subtree_root.children:
            # The node has already been processed, so skip over it
            if child in closed_set:
                continue

            # The child is not enqueued to be processed,
            # so enqueue this level of children to be expanded
            if child not in pqueue.queue:
                child.priority = current_priority + 1
                # Update the path
                meta[child] = (subtree_root, action)
                # Enqueue this node
                pqueue.insert(child)

            closed_set.add(subtree_root)
Ejemplo n.º 11
0
class PQueueTestCase(unittest.TestCase):
    '''Test creation and use of a priority queue.'''
    
    def setUp(self):
        self.pq = PriorityQueue()
        self.r1 = Rectangle(0, 150, 200, 50, media.forestgreen, 1)
        self.o1= Oval(120, 160, 60, 60, media.white, 4)
        self.o2 = Oval(120, 115, 45, 45, media.yellow, 3)
        self.o3 = Oval(120, 80, 30, 30, media.orange, 2)

    def tearDown(self):
        self.pq = None
        self.r1 = None
        self.o1 = None
        self.o2 = None
        self.o3 = None
            
    def testSize(self):
        assert self.pq.size() == 0, 'mismatch in predicted pqueue size'
        
    def testEnqueueSize(self):
        self.pq.enqueue(self.r1)
        assert self.pq.size() == 1, \
               'mismatch in pqueue size after enqueue'

    def testDequeue(self):
        self.pq.enqueue(self.r1)
        result = self.pq.dequeue()
        assert result is self.r1, \
               'mismatch in dequeued value'

    def testMultipleEnqueueSize(self):
        self.pq.enqueue(self.o1)
        self.pq.enqueue(self.o2)
        self.pq.enqueue(self.o3)
        assert self.pq.size() == 3, \
               'mismatch in pqueue size after enqueues'

    def testMultipleDequeue(self):
        self.pq.enqueue(self.o1)
        self.pq.enqueue(self.o2)
        self.pq.enqueue(self.o3)
        result = self.pq.dequeue()
        assert result is self.o3, 'mismatch in dequeuing correct value'
Ejemplo n.º 12
0
def djkistra(sourceId: int, vertices: list, vertexDict: dict, edgeList: list):
    sourcePair = Pair(sourceId)

    visited = set()
    unvisited = PriorityQueue(contents=[sourcePair])

    # build mapping labels -> vertexId & vertexId -> labels
    labelsDict = {
        int(v.attributes["label"].value): int(v.attributes["vertexId"].value)
        for v in vertices
    }
    labels = [labelsDict[i] for i in range(len(labelsDict))]
    previousLabelsDict = {v: k for k, v in labelsDict.items()}

    vertexDict[sourceId].setCost(0)

    vertexDict[sourceId].setPrevious(sourceId)

    while not unvisited.isEmpty():
        currentPair = unvisited.dequeue()

        visited.add(currentPair.getVertexId())

        currentVertex = vertexDict[currentPair.getVertexId()]
        # grab adjacents.
        adjacents = currentVertex.getAdjacents(edgeList)

        for e in adjacents:
            dist = vertexDict[currentVertex.vertexId].getCost() + e.weight
            for vertex in [e.v1, e.v2]:
                if vertex not in visited:
                    if vertexDict[vertex].getCost() > dist:
                        vertexDict[vertex].setCost(dist)
                        vertexDict[vertex].setPrevious(
                            currentVertex.getVertexId())
                        # heapq.heappush(unvisited, Pair(vertex, dist))
                        unvisited.enqueue(Pair(vertex, dist))

    for i in range(len(visited)):
        print("Vertex:")
        print("  label: {}".format(i))
        print("  cost: {:.2f}".format(vertexDict[labels[i]].getCost()))
        print("  previous: {}\n".format(
            previousLabelsDict[vertexDict[labelsDict[i]].getPrevious()]))

    return labelsDict
Ejemplo n.º 13
0
 def test_length(self):
     p = PriorityQueue()
     p.enqueue('A', 1)
     assert p.length() == 1
     p.enqueue('B', 1)
     assert p.length() == 2
     p.enqueue('C', 2)
     assert p.length() == 3
     p.dequeue()
     assert p.length() == 2
     p.dequeue()
     assert p.length() == 1
     p.dequeue()
     assert p.length() == 0
Ejemplo n.º 14
0
def dijkstra(source, graph):
    pQueue = PriorityQueue()
    graph[source]['dist'] = 0

    for v in graph:
        pQueue.enqueue(v, graph[v]['dist'])

    while not pQueue.isEmpty():
        u = pQueue.dequeue()
        baseDist = graph[u]['dist']
        for w in graph[u]['edgeTo']:
            edgeLen = graph[u]['edgeTo'][w]
            newDist = baseDist + edgeLen
            currentDist = graph[w]['dist']
            if newDist < currentDist:
                graph[w]['dist'] = newDist
                pQueue.changePriority(w, newDist)

    distanceList = []
    for v in graph:
        distanceList.append((v, graph[v]['dist']))

    return distanceList
Ejemplo n.º 15
0
def Astar(puzzle8, came_from):
    frontier = PriorityQueue()
    cost_so_far = {}
    frontier.enqueue(puzzle8, 0)
    cost_so_far[puzzle8.ToString()] = puzzle8.cost
    came_from[puzzle8.ToString()] = None
    while not frontier.is_empty():
        puzzle8 = frontier.dequeue()
        
        if puzzle8.isGoal():
            return puzzle8
        else:
            moves = puzzle8.getAllMoves()
            for move in moves:
                newpuzzle8 = puzzle8.clone()
                newpuzzle8.move(*move)
                new_cost = newpuzzle8.cost
                if cost_so_far.get(newpuzzle8.ToString()) == None or \
                   new_cost < cost_so_far[newpuzzle8.ToString()]:
                    cost_so_far[newpuzzle8.ToString()] = new_cost
                    priority = new_cost + newpuzzle8.heuristics
                    frontier.enqueue(newpuzzle8, priority)
                    came_from[newpuzzle8.ToString()] = puzzle8
    return None