Esempio n. 1
0
def test_sort():
    '''
    Test sorting (heap sort) of priority queues.
    
    '''
    q = PriorityQueue([5, 1, 2, 4, 6, 3])
    assert q == [1, 4, 2, 5, 6, 3]
    assert q.sort() == [1, 2, 3, 4, 5, 6]
Esempio n. 2
0
def test_sort():
    '''
    Test sorting (heap sort) of priority queues.
    
    '''
    q = PriorityQueue([5, 1, 2, 4, 6, 3])
    assert q == [1, 4, 2, 5, 6, 3]
    assert q.sort() == [1, 2, 3, 4, 5, 6]
Esempio n. 3
0
def dijkstra(graph, start, end=None):
    nodes = graph.get_nodes()
    # initialize distance dictionary

    dist = {node: float('Inf') for node in nodes}
    dist[start] = 0
    # initialize predecessor dictionary
    pred = {node: None for node in nodes}

    # initialize prio queue for "unvisited nodes
    nodes_nonfinal = PriorityQueue()
    for node in nodes:
        nodes_nonfinal.add_task(task=node, priority=dist[node])

    # main computation loop
    while nodes_nonfinal.not_empty():
        u = nodes_nonfinal.pop_task()
        for adj in graph.get_node_neighbours(u):
            if nodes_nonfinal.contains_task(adj):
                temp = dist[u] + float(graph.get_default_weights((u, adj))[0])
                if temp < dist[adj]:

                    pred[adj] = u
                    nodes_nonfinal.add_task(task=adj, priority=temp)

    # if an end node was specified, the corresponding shortest path shall be
    # computed and displayed
    if end is not None:
        path, path_sum = shortest_path(graph, pred, end)
        #print '#' * 50
        #print 'Path: ', path
        #print 'Weight: ', path_sum
        return path
    else:
        get_shortest_path_tree(graph, pred, start)
Esempio n. 4
0
 def __init__(self):
     self._lock = threading.Lock()
     self._modified = threading.Condition(self._lock)
     self._queue = PriorityQueue()
     self._next_id = 1
     self._should_stop = False
     self._loop_thread = ProfiledThread(target=self._the_loop, name_prefix='DelayedExecutor')
     self._loop_thread.start()
Esempio n. 5
0
    def __init__(self, input_maze=None):
        is_text = type(input_maze) == str
        if is_text:
            converter = TextToMatrixMazeConverter(input_maze)
            converter = MazeToGraphConverter(converter.maze,
                                             converter.start_cell)
        else:
            converter = MazeToGraphConverter(input_maze)

        self.vertices = converter.graph_vertices
        self.edge_weights = converter.graph_edge_weights
        self.adjacency_list = converter.graph_adjacency_list
        self.edge_weights = converter.graph_edge_weights
        self.start_v = converter.start_cell
        self.exit_v = converter.exit_cell
        self.dist = dict()
        self.prev = dict()
        self.queue = PriorityQueue()
        self.shortest_path = self.shortest_exit_path()
    def main(self, s):
        self.dists[s] = 0

        pq = PriorityQueue()
        for u in range(self.n):
            pq.insert(float('inf'), u)

        pq.decrease_key(s, 0)
        while pq:
            _, u = pq.extract()
            for v in self.G[u]:
                if self.relax(u, v, self.G[u][v]):
                    pq.decrease_key(v, self.dists[v])
Esempio n. 7
0
def huffman(C):
    n = len(C)
    Q = PriorityQueue(C, MinHeap)
    for i in range(n - 1):
        x = Q.extract_min()
        y = Q.extract_min()
        z = Node(x.key() + y.key())
        z.left = x
        z.right = y
        Q.insert(z)
    return Q.extract_min()
Esempio n. 8
0
    def __init__(self, input_maze=None):
        is_text = type(input_maze) == str
        if is_text:
            converter = TextToMatrixMazeConverter(input_maze)
            converter = MazeToGraphConverter(converter.maze, converter.start_cell)
        else:
            converter = MazeToGraphConverter(input_maze)

        self.vertices = converter.graph_vertices
        self.edge_weights = converter.graph_edge_weights
        self.adjacency_list = converter.graph_adjacency_list
        self.edge_weights = converter.graph_edge_weights
        self.start_v = converter.start_cell
        self.exit_v = converter.exit_cell
        self.dist = dict()
        self.prev = dict()
        self.queue = PriorityQueue()
        self.shortest_path = self.shortest_exit_path()
Esempio n. 9
0
def prim(G):
    n = G.num_vertices()
    parents = [-1] * n

    pq = PriorityQueue()
    for u in G:
        pq.insert(float('inf'), u)

    pq.decrease_key(u, 0)
    while pq:
        _, u = pq.extract()
        for v in G[u]:
            if v in pq and G[u][v] < pq[v]:
                parents[v] = u
                pq.decrease_key(v, G[u][v])

    mst = set()
    for u, v in enumerate(parents):
        if v >= 0:
            mst.add((u, v))
    return mst
Esempio n. 10
0
 def add(self, obj, tm=None):
     if isinstance(obj, tuple):
         obj, tm = obj
     if obj not in self:
         PriorityQueue.add(self, obj, tm or time.time())
Esempio n. 11
0
 def add(self, obj, value, tm=None):
     if obj not in self:
         PriorityQueue.add(self, obj, (tm or time.time(), value))
Esempio n. 12
0
class DelayedExecutor(object):
    def __init__(self):
        self._lock = threading.Lock()
        self._modified = threading.Condition(self._lock)
        self._queue = PriorityQueue()
        self._next_id = 1
        self._should_stop = False
        self._loop_thread = ProfiledThread(target=self._the_loop, name_prefix='DelayedExecutor')
        self._loop_thread.start()

    def _cancel(self, id):
        with self._lock:
            if id not in self._queue: # because of user-space-race with _the_loop
                return False

            if self._queue.front()[0] == id:
                self._modified.notify()

            self._queue.pop_by_key(id)

            return True

    def add(self, callback, deadline=None, timeout=None):
        if timeout is not None:
            deadline = time.time() + timeout
        elif deadline is None:
            raise ValueError("You must specify deadline or timeout")

        with self._lock:
            id = self._next_id
            self._next_id += 1

            self._queue.add(id, (deadline, callback))

            if self._queue.front()[0] == id:
                self._modified.notify()

            ret = lambda : self._cancel(id) # TODO use weak self
            ret.id = id

            return ret

    schedule = add

    def stop(self):
        with self._lock:
            self._should_stop = True
            self._modified.notify()

        self._loop_thread.join()

    def _the_loop(self):
        while not self._should_stop:
            with self._lock:
                while not(self._should_stop or self._queue):
                    self._modified.wait()

                if self._should_stop:
                    return

                id, (deadline, callback) = self._queue.front()

                now = time.time()

                if now < deadline:
                    self._modified.wait(deadline - now)

                    if self._should_stop:
                        return

                    if not self._queue or self._queue.front()[0] != id:
                        continue

                self._queue.pop_front()

            try:
                if callback.__code__.co_argcount:
                    callback(id)
                else:
                    callback()
            except:
                logging.exception("Failed to execute %s" % callback)

            del callback
Esempio n. 13
0
def prim(graph, start_node):
    queue = PriorityQueue()
    parent = {}
    mst = []
    mst_sum = 0

    for node in graph.get_nodes():
        queue.add_task(task=node, priority=float('Inf'))
        parent[node] = None

    # put first node in the queue
    queue.add_task(task=start_node, priority=0)

    while queue.not_empty():
        cheapest_node = queue.pop_task()
        if parent[cheapest_node] is not None:
            temp_weight = float(graph.get_default_weights((cheapest_node, parent[cheapest_node]))[0])
            mst.append((temp_weight, (cheapest_node, parent[cheapest_node])))
            mst_sum += temp_weight
        for adj_node in graph.get_node_neighbours(cheapest_node):
            edge_weight = float(graph.get_default_weights((cheapest_node, adj_node))[0])
            if queue.contains_task(adj_node) and edge_weight < queue.get_priority(adj_node):
                parent[adj_node] = cheapest_node
                queue.add_task(task=adj_node, priority=edge_weight)

    print "Prim Weight: ", mst_sum
    return mst
Esempio n. 14
0
 def add(self, pck):
     if pck not in self:
         PriorityQueue.add(self, pck, getattr(pck, priorAttr, 0))
Esempio n. 15
0
 def add(self, pck):
     if pck not in self:
         PriorityQueue.add(self, pck, getattr(pck, priorAttr, 0))
Esempio n. 16
0
from heap import Node, PriorityQueue

q = PriorityQueue([5, 4, 3])


def test_basic():
    assert q.min == 3
    assert q.size == 3
    assert q == [3, 5, 4]


def test_insert():
    '''
    Testing `insert` method, which inserts a new element into the queue
    and reorders the underlying MinHeap if necessary.

    '''
    q.insert(2)
    assert q.min == 2
    assert q.size == 4
    assert q == [2, 3, 4, 5]

    q.insert(1)
    assert q.min == 1
    assert q.size == 5
    assert q == [1, 2, 4, 5, 3]


def test_relations():
    '''
    Testing parent and child relations among elements.
Esempio n. 17
0
 def add(self, obj, tm=None):
     if isinstance(obj, tuple):
         obj, tm = obj
     if obj not in self:
         PriorityQueue.add(self, obj, tm or time.time())
Esempio n. 18
0
        self.g = g  # list of event secuences Ids


class PriorityQueue_tuple(object):
    def __init__(self, l, c_, ci, cj):
        self.l = l
        self.c_ = c_
        self.ci = ci
        self.cj = cj


###############	containers	#####################3
cluster_list = dict()  ### Stores the clusters formed
priorityQueue_dict = dict(
)  ### Maps the priorityQueue elements to Tuple objects
q = PriorityQueue([])  ### Priority Queue
#############//////////////##################


def add_cluster(c):
    global counter_cluster_id
    cluster_list[counter_cluster_id] = c
    counter_cluster_id += 1
    return counter_cluster_id - 1


def remove_cluster(ckey):
    cluster_list.pop(ckey)  ## check


def getNextLabel():
Esempio n. 19
0
class DijkstrasMazeSolver(object):
    """Gets shortest maze exit path with help of Dijkstras algorithm.
    It converts 0/1 matrix maze to edge weighted graph representation
    (due to MazeToGraphConverter) and then finds shortest path.
    Also it uses Heap data structure to quickly get minimums.
    """

    infinity = 10 ** 10

    def __init__(self, input_maze=None):
        is_text = type(input_maze) == str
        if is_text:
            converter = TextToMatrixMazeConverter(input_maze)
            converter = MazeToGraphConverter(converter.maze, converter.start_cell)
        else:
            converter = MazeToGraphConverter(input_maze)

        self.vertices = converter.graph_vertices
        self.edge_weights = converter.graph_edge_weights
        self.adjacency_list = converter.graph_adjacency_list
        self.edge_weights = converter.graph_edge_weights
        self.start_v = converter.start_cell
        self.exit_v = converter.exit_cell
        self.dist = dict()
        self.prev = dict()
        self.queue = PriorityQueue()
        self.shortest_path = self.shortest_exit_path()

    def shortest_exit_path(self):
        self.count_shortest_paths(self.start_v, self.exit_v)
        length = self.dist[self.exit_v]
        path = self.get_path(self.exit_v)
        return path, length

    def get_path(self, v, path=()):
        path = (v,) + path
        if self.prev[v] and v != self.start_v:
            return self.get_path(self.prev[v], path)
        else:
            return path

    def count_shortest_paths(self, source, dest):
        self.dist[source] = 0
        self.prev[source] = None

        for v in self.vertices:
            if v != source:
                self.dist[v] = self.infinity
                self.prev[v] = None
            else:
                self.queue.insert((v, self.dist[v]))

        while self.queue:
            u = self.queue.pop_min()[0]
            if u == dest:
                break
            for v in self.adjacency_list[u]:
                edge = frozenset((u, v))
                alt = self.dist[u] + self.edge_weights[edge]
                if alt < self.dist[v]:
                    self.dist[v] = alt
                    self.prev[v] = u
                    if v not in self.queue:
                        self.queue.insert((v, alt))
Esempio n. 20
0
    def test_sanity(self):
        ilist = [2, 4, 1, 9, 7, 5, 3, 2, 3]
        olist = [1, 2, 2, 3, 3, 4, 5, 7, 9]
        # heap test
        from heap import Heap
        h = Heap(deepcopy(ilist))
        h.sanity()
        self.assertListEqual(h.sort(), olist)
        # min heap
        h = Heap(deepcopy(ilist), htype='min')
        h.sanity()
        self.assertListEqual(h.sort(), olist[::-1])
        # big array test
        array = range(500)
        random.shuffle(array)
        h = Heap(array)
        h.sanity()
        self.check_sorted(h.sort())

        # priority queue
        from heap import PriorityQueue
        q = PriorityQueue(deepcopy(ilist))
        q.sanity()
        # get top test
        top = q.find_top()
        self.assertEqual(top, max(ilist))
        self.assertEqual(top, q.pop_top())
        q.sanity()
        self.assertNotEqual(top, q.find_top())
        # update key test
        q.update_key(3, 10)  # upwards
        q.sanity()
        q.update_key(8, 0)  # downwards
        q.sanity()
        # insert key test
        q.insert_key(15)
        q.sanity()
        q.insert_key(-1)
        q.sanity()
        q.insert_key(4)
        q.sanity()
Esempio n. 21
0
#@ <int>  cj: Id of Cluster j
class PriorityQueue_tuple(object):
    def __init__(self, l, c_, ci, cj):
        self.l = l
        self.c_ = c_
        self.ci = ci
        self.cj = cj


###############	containers	#####################
# Maps Ids to clusters
cluster_list = dict()
# Maps PriorityQueue elements to PriorityQueue_Tuple Objects
priorityQueue_dict = dict()
# Main Priority Queue for MinDL algorithm <heap>
q = PriorityQueue([])


# -- Adds a new cluster (c) to cluster_list --
#@<Cluster> c: new cluster object
#@<int>     returns: new cluster's id
def add_cluster(c):
    global counter_cluster_id
    cluster_list[counter_cluster_id] = c
    counter_cluster_id += 1
    return counter_cluster_id - 1


# -- Removes the cluster identified by Id cKey from cluster_list --
#@<int> ckey: Id or key of cluster c
def remove_cluster(ckey):
Esempio n. 22
0
 def add(self, key, value, t=None):
     if key not in self:
         PriorityQueue.add(self, key, (t or time.time(), value))
Esempio n. 23
0
def test_node_heaping():
    '''
    Test priority queues with nodes as elements.
    
    '''
    a = Node(label='a', msg="boom!", priority=1)
    b = Node(label='b', msg="hi", priority=2)
    c = Node(label='c', msg="ok", priority=3)
    d = Node(label='d', msg="oh", priority=4)

    q = PriorityQueue([b, c, d])
    assert q.min == b
    assert q.min.msg == 'hi'
    assert q.min.label == 'b'
    assert q == [b, c, d]

    q.insert(a)
    assert q.min == a
    assert q.min.msg is 'boom!'
    assert q.min.label == 'a'
    assert q == [a, b, d, c]

    assert q.delete('c') == c
    assert q.sort() == [a, b, d]
    assert q.min == a
    assert q.min.label == 'a'

    min = q.shift()
    assert min == a
    assert min.label == 'a'
    assert q.sort() == [b, d]
    assert q.min == b
    assert q.min.label == 'b'

    q = PriorityQueue([d, c, b, a])
    assert [a, b, c, d] == q.sort()
    assert [a, b, c, d] == [q.shift() for x in range(q.size)]
    assert q.size == 0
    assert q == []

    from itertools import permutations
    nodes = [a, b, c, d]
    for perm in permutations(nodes):
        q = PriorityQueue(perm)
        assert [a, b, c, d] == q.sort()
        assert [a, b, c, d] == [q.shift() for x in range(q.size)]
        assert q.size == 0
        assert q == []
Esempio n. 24
0
class DijkstrasMazeSolver(object):
    """Gets shortest maze exit path with help of Dijkstras algorithm.
    It converts 0/1 matrix maze to edge weighted graph representation
    (due to MazeToGraphConverter) and then finds shortest path.
    Also it uses Heap data structure to quickly get minimums.
    """
    infinity = 10**10

    def __init__(self, input_maze=None):
        is_text = type(input_maze) == str
        if is_text:
            converter = TextToMatrixMazeConverter(input_maze)
            converter = MazeToGraphConverter(converter.maze,
                                             converter.start_cell)
        else:
            converter = MazeToGraphConverter(input_maze)

        self.vertices = converter.graph_vertices
        self.edge_weights = converter.graph_edge_weights
        self.adjacency_list = converter.graph_adjacency_list
        self.edge_weights = converter.graph_edge_weights
        self.start_v = converter.start_cell
        self.exit_v = converter.exit_cell
        self.dist = dict()
        self.prev = dict()
        self.queue = PriorityQueue()
        self.shortest_path = self.shortest_exit_path()

    def shortest_exit_path(self):
        self.count_shortest_paths(self.start_v, self.exit_v)
        length = self.dist[self.exit_v]
        path = self.get_path(self.exit_v)
        return path, length

    def get_path(self, v, path=()):
        path = (v, ) + path
        if self.prev[v] and v != self.start_v:
            return self.get_path(self.prev[v], path)
        else:
            return path

    def count_shortest_paths(self, source, dest):
        self.dist[source] = 0
        self.prev[source] = None

        for v in self.vertices:
            if v != source:
                self.dist[v] = self.infinity
                self.prev[v] = None
            else:
                self.queue.insert((v, self.dist[v]))

        while self.queue:
            u = self.queue.pop_min()[0]
            if u == dest:
                break
            for v in self.adjacency_list[u]:
                edge = frozenset((u, v))
                alt = self.dist[u] + self.edge_weights[edge]
                if alt < self.dist[v]:
                    self.dist[v] = alt
                    self.prev[v] = u
                    if v not in self.queue:
                        self.queue.insert((v, alt))
Esempio n. 25
0
 def add(self, obj, value, tm=None):
     if obj not in self:
         PriorityQueue.add(self, obj, (tm or time.time(), value))
Esempio n. 26
0
def test_node_heaping():
    '''
    Test priority queues with nodes as elements.
    
    '''
    a = Node(label='a', msg="boom!", priority=1)
    b = Node(label='b', msg="hi", priority=2)
    c = Node(label='c', msg="ok", priority=3)
    d = Node(label='d', msg="oh", priority=4)

    q = PriorityQueue([b, c, d])
    assert q.min == b
    assert q.min.msg == 'hi'
    assert q.min.label == 'b'
    assert q == [b, c, d]

    q.insert(a)
    assert q.min == a
    assert q.min.msg is 'boom!'
    assert q.min.label == 'a'
    assert q == [a, b, d, c]

    assert q.delete('c') == c
    assert q.sort() == [a, b, d]
    assert q.min == a
    assert q.min.label == 'a'

    min = q.shift()
    assert min == a
    assert min.label == 'a'
    assert q.sort() == [b, d]
    assert q.min == b
    assert q.min.label == 'b'

    q = PriorityQueue([d, c, b, a])
    assert [a, b, c, d] == q.sort()
    assert [a, b, c, d] == [q.shift() for x in range(q.size)]
    assert q.size == 0
    assert q == []

    from itertools import permutations
    nodes = [a, b, c, d]
    for perm in permutations(nodes):
        q = PriorityQueue(perm)
        assert [a, b, c, d] == q.sort()
        assert [a, b, c, d] == [q.shift() for x in range(q.size)]
        assert q.size == 0
        assert q == []