コード例 #1
0
def a_star_search(problem, fringe):
    # If there is no node on fringe, make one
    if len(fringe.queue) <= 0:
        initial_node = Node(problem)
        fringe.insert(initial_node)

    # If nodes don't have path cost for A* Search, give them one
    for node in fringe.queue:
        if node.a_star_cost == None:
            node.a_star_cost = a_star_evaluator(node)

    # Form a temporary priority queue
    a_star_fringe = Queue()
    a_star_fringe.insert_all(fringe.queue)

    # Sort them according to lowest path cost
    bubble_sort(a_star_fringe, False)

    # Iterate over the sorted nodes, to check visually
    for nodes in a_star_fringe.queue:
        print('Node: ' + str(nodes.a_star_cost) + ' Depth: ' + str(nodes.depth) + ' Action: ' + str(nodes.action))

    # Now do the good stuff
    # Get the first node in A* fringe and then pop it on the main fringe
    greed_node = a_star_fringe.pop()
    node = fringe.pop_specific(greed_node)

    # If the node is the goal, return it as goal; otherwise expand it
    if goal_test(node.state) == True:
        return True, solution(node), node
    else:
        if node.state.connor.death == False:
            fringe.insert_all(expand(node))
        return False, fringe, node
コード例 #2
0
def best_fs(problem, fringe):
    # If there is no node on fringe, make one
    if len(fringe.queue) <= 0:
        initial_node = Node(problem)
        fringe.insert(initial_node)

    # If nodes don't have path cost for Greedy BFS, give them one
    for node in fringe.queue:
        if node.greed_cost == None:
            node.greed_cost = best_fs_evaluator(node)

    # Form a temporary priority queue
    best_fs_fringe = Queue()
    best_fs_fringe.insert_all(fringe.queue)

    # Sort them according to lowest path cost
    bubble_sort(best_fs_fringe)

    # Now do the good stuff
    # Get the first node in Greedy BFS fringe and then pop it on the main fringe
    greed_node = best_fs_fringe.pop()
    node = fringe.pop_specific(greed_node)

    # If the node is the goal, return it as goal; otherwise expand it
    if goal_test(node.state) == True:
        return True, solution(node), node
    else:
        if node.state.connor.death == False:
            fringe.insert_all(expand(node))
        return False, fringe, node
コード例 #3
0
class EventsHub:
    """Implements an event aggregator to gather events from both interfaces as well as the application itself.
    Similar to an Observer pattern.

    Warning:
        Events need to be processed regularly by calling `.handle_events()`
        to avoid overflowing the event queue.

    Events types:
     - pygame events (mouse / key press / quit)
     - tkinter events (mouse / key press / quit)
        - all buttons
     - application events, like "AnimationFinished" event
    """
    def __init__(self):
        self._events = Queue()
        self._callbacks = {}

    def raise_event(self, event):
        self._events.put(event)

    def add_callback(self, event_name, callback):
        self._callbacks.setdefault(event_name, []).append(callback)

    def handle_events(self):
        while not self._events.empty():
            event = self._events.pop()
            if event.type in [Event.QUIT, Event.NEWFRAME]:
                # print("Handling", event, self._callbacks.get(event.type, []))
                pass
            for callback in self._callbacks.get(event.type, []):
                callback(event)
コード例 #4
0
    def __bfs(graph, beg_id, end_id, shortest_path=True):

        first = graph.vtx_map[beg_id]
        queue = Queue([first])
        visited = set([first.id])

        nearest_prevs_hmap = {}

        found = False
        while len(queue) != 0:
            # explore: (prev node not always unique.)
            # Goes through all nodes
            prev_node = queue.dequeue()

            neighbors_ids_wts = prev_node.adj_list
            for cur_id, _ in neighbors_ids_wts:

                if cur_id not in visited:
                    # visit: (cur_node always unique)
                    # update `queue` and `visited`
                    queue.enqueue(graph.vtx_map[cur_id])
                    visited.add(cur_id)

                    # action - populate hmap
                    # can break if end_id is found cz
                    # we add all nearest prevs until `cur_id` in lookup table
                    nearest_prevs_hmap[cur_id] = prev_node.id
                    if cur_id == end_id:
                        found = True
                        break

            if found is True: break

        # at end of bfs traversal/search
        return nearest_prevs_hmap
コード例 #5
0
ファイル: depth_first_order.py プロジェクト: whille/pyAlgr
 def __init__(self, G):
     self.marked = [False for _ in range(G.V)]
     self.pre = Queue()  # push v to queue before recursion
     self.post = Queue()  # ... after recursion
     self.reverse_post = Stack()  # push v to stack after recursion
     for w in range(G.V):
         if not self.marked[w]:
             self.dfs(G, w)
コード例 #6
0
 def __init__(self, name):
     self.name = name
     self.centerList = Queue.Queue(queue_size, (0, 0))
     self.size = 0
     self._foundQueue = Queue.Queue(queue_size, 0)
     self.found = False
     self.lastFoundFrame = 0
     self.logging = True
     self.idCentroid = 0
     #persona che è stata vista più di 4 volte e che quindi può entrare
     self.possibleEntering = False
コード例 #7
0
def test_queue():
    q = Queue()
    q.enqueue(3)
    assert_equal(1, q.size())
    assert_equal(3, q.dequeue())
    q.enqueue(2)
    q.enqueue(1)
    assert_equal([2, 1], list(q))
    assert_equal(2, q.dequeue())
コード例 #8
0
ファイル: main.py プロジェクト: per-lind/irrigation-system
def main_loop():
    hardware = None
    try:
        print('Setting up hardware...')
        hardware = Hardware()

        # Set up job queue
        queue = Queue(hardware)

        print('Connecting to IotHub...')
        IotHub(hardware=hardware, queue=queue)

        print('Setting up background jobs...')

        def sensor_reading():
            return queue.append(
                "periodic_reading",
                {"methods": ['read_humidity', 'read_light', 'read_pressure']})

        def soil_moisture_reading():
            return queue.append("periodic_reading", {
                "methods": ['read_mcp3008_soil_moisture', 'read_water_level']
            })

        # Read humidity, light, pressure and temperature frequently
        schedule.every(PERIODIC_READING_INTERVAL).seconds.do(sensor_reading)
        # Read soil moisture and water level twice a day
        schedule.every().day.at("06:00").do(
            soil_moisture_reading)  # 08:00 Swedish summer time
        schedule.every().day.at("18:00").do(
            soil_moisture_reading)  # 20:00 Swedish summer time

        print('App ready!')

        while True:
            # Add scheduled jobs to queue
            schedule.run_pending()
            # Pop queue
            queue.work()
            time.sleep(1)

    except KeyboardInterrupt:
        print('Process ended by user.')

    except Exception as inst:
        print('Unexpected error!')
        print(type(inst))
        print(inst.args)
        print(inst)

    finally:
        shutdown_gracefully(hardware)
コード例 #9
0
 def bfs(self, starting_vertex, destination_vertex):
     """
     Return a list containing the shortest path from
     starting_vertex to destination_vertex in
     breath-first order.
     """
     # make a queye
     q = Queue()
     # make a set to track the nodes
     visited = set()
     path = [starting_vertex]
     # enqueue the starting node
     q.enqueue(path)
     # while the queue isn't empty
     while q.size() > 0:
         ## dequee the node at the front of the line
         current_path = q.dequeue()
         current_node = current_path[-1]
         ### if this node is out targte node
         if current_node == destination_vertex:
             #### return it!! return True
             return current_path
     ### if not visted
         if current_node not in visited:
             #### mark as visited
             visited.add(current_node)
             #### get neigghbots
             neighbors = self.vertices[current_node].keys()
             # for each neibor
             for neighbor in neighbors:
                 path = list(current_node)
                 # add to queue
                 path.append(neighbor)
                 q.enqueue(path)
コード例 #10
0
def bfs(graph, starting_vertex, destination_vertex):
    """
    Return a list containing the shortest path from
    starting_vertex to destination_vertex in
    breath-first order.
    """
    # Create a q and enqueue starting vertex
    qq = Queue()
    qq.enqueue([starting_vertex])
    # Create a set of traversed vertices
    visited = set()
    # visited = []
    # While queue is not empty:
    while qq.size() > 0:
        # dequeue/pop the first vertex
        path = qq.dequeue()
        # if not visited
        if path[-1] not in visited:
            # DO THE THING!!!!!!!
            print(path[-1])
            # mark as visited
            visited.add(path[-1])
            print(path)
            # visited.append(path[-1])
            # enqueue all neightbors
            if path[-1] == destination_vertex:
                return path
            for next_vert in graph[path[-1]].keys():
                new_path = list(path)
                # print(new_path)
                new_path.append(next_vert)
                qq.enqueue(new_path)
            # print(visited)

    pass  # TODO
コード例 #11
0
ファイル: adv.py プロジェクト: bschatzj/Graphs
def bfs(visited_rooms):
    visited = set()
    my_queue = Queue()
    room = player.current_room

    # add room id
    my_queue.enqueue([room.id])

    while my_queue.size() > 0:
        path = my_queue.dequeue()
        # the last node
        end = path[-1]
        if end not in visited:
            visited.add(end)
            # checks if last room has been visited
            for exit_direction in visited_rooms[end]:
                # if no exit exists
                if (visited_rooms[end][exit_direction] == '?'):
                    return path
                # if not visited
                elif (visited_rooms[end][exit_direction] not in visited):
                    # create/ add a new path
                    new_path = path + [visited_rooms[end][exit_direction]]
                    # add the new path
                    my_queue.enqueue(new_path)
    return path
コード例 #12
0
    def find_room(self):
        # implement bfs to find path to nearest unseen room
        
        # def bfs(self, starting_vertex, destination_vertex):
        # """
        # Return a list containing the shortest path from
        # starting_vertex to destination_vertex in
        # breath-first order.
        # """

        # initialize queue with starting vertex
        queue = Queue()
        queue.enqueue((self.current_room, []))
        
        # set to keep track of vertexes already seen
        visited = set()

        # while queue is not empty
        while queue.size() > 0:
            # get path and vertex
            room, path = queue.dequeue()
            # if room has not been seen, return path
            if room.id not in self.seen:
                return path
            # else, add vertex to visited
            elif room.id not in visited:
                visited.add(room.id)      
                # and add paths to the queue for each edge
                for exit in room.get_exits():
                    path_copy = path.copy()
                    path_copy.append(exit)
                    queue.enqueue((room.get_room_in_direction(exit), path_copy))
        
        print('Room not found')
コード例 #13
0
def find_shortest_path(graph, starting_room):
    qq = Queue()
    visited = set()
    qq.enqueue([starting_room])
    while qq.size() > 0:
        path = qq.dequeue()
        move = path[-1]
        room = path[-1].origin
        if move.dir:
            room = graph[room][move.dir]
        if room not in visited:
            visited.add(room)
            for exit in graph[room]:
                #  Target(?) found!
                if graph[room][exit] == '?':
                    new_move = Move(room, exit)
                    return path[1:], new_move
                # If target not found make a new move and append to queue
                elif exit != '?' and graph[room][exit] not in visited:
                    new_path = list(path)
                    new_move = Move(room, exit)
                    new_path.append(new_move)
                    qq.enqueue(new_path)

    return None, None
コード例 #14
0
    def linearize_level_ordered(self, level=1):
        graph_str = ''
        bfs_queue = Queue()
        cur_level_count = 0
        visited = {key: False for key in self.graph}

        for root in self.roots:
            bfs_queue.enqueue(root)
            cur_level_count += 1

        while not bfs_queue.isEmpty() and level > 0:
            next_level_count = 0
            while cur_level_count > 0:
                cur_item = bfs_queue.dequeue()
                if not visited[cur_item]:
                    visited[cur_item] = True
                    if global_info.node_labels[cur_item].find(
                            'name_'
                    ) != -1 or global_info.node_labels[cur_item].find(
                            'date-entity'
                    ) != -1:  # skip name and date entity as global concepts
                        cur_level_count -= 1
                        continue
                    graph_str += global_info.node_labels[cur_item] + _SPACE
                    for neighbour in self.graph[cur_item].adjacency_list:
                        next_level_count += 1
                        bfs_queue.enqueue(neighbour[0])

                cur_level_count -= 1
            cur_level_count = next_level_count
            level -= 1

        return graph_str
コード例 #15
0
def bfs(start_room, map):      
        # Create an empty Queue and enqueue path to starting_vertex
        q = Queue()
        q.enqueue([start_room])
        # Create empty set to store visted nodes
        visited = set()
        # While queue is not empty:
        while q.size() > 0:
            # Dequeue the first path
            path = q.dequeue()
            # get vertex from end of path
            node = path[-1]
            # if the vertex has not been visited
            if node not in visited:
                # mark it visted
                visited.add(node)
                # Check if it contains a "?"
                if "?" in map[node].values():
                    return path
                # then add a path to all adjacent vertices to back of queue
                for neighbor in map[node].values():
                    # copy path
                    copy_path = path.copy()
                    # append next vert to back of copy
                    copy_path.append(neighbor)
                    # enqueue copy
                    q.enqueue(copy_path)
        
        return None
コード例 #16
0
    def bft(self, starting_vertex: T) -> None:
        """
        Print each vertex in breadth-first order
        beginning from starting_vertex.
        """
        # keep track of visited vertices
        visited = set()
        # create a queue class
        queue = Queue()
        # enqueue the starting vertex
        queue.enqueue(starting_vertex)

        # while queue is not empty
        while queue.size():
            # dequeue the queue
            current_vertex = queue.dequeue()

            # if current vertex has not been visited
            if current_vertex not in visited:
                # add ti to visited
                visited.add(current_vertex)
                # print the current vertex
                print(current_vertex)

                # for every neighbors of current_vertex
                for vertex in self.vertices[current_vertex]:
                    # add it to the queue
                    queue.enqueue(vertex)
コード例 #17
0
def search(grid,init,goal,cost):
    # ----------------------------------------
    # insert code here
    # ----------------------------------------
    Nr=len(grid)
    Nc=len(grid[0])

    def childNode(grid, loc, delta, delta_name):
        child=[]
        for i in range(len(delta)):
            move=delta[i]
            newloc=[loc[0]+move[0], loc[1]+move[1]]
            if loc[0]+move[0]>=0 and loc[0]+move[0]<Nr \
            and loc[1]+move[1]>=0 and loc[1]+move[1]<Nc \
            and grid[newloc[0]][newloc[1]] ==0:
                child.append([newloc,delta_name[i]])
        return child

    visited=[]
    frontier=Queue()
    frontier.push([init,0])

    while not frontier.isEmpty():
        loc, rlen=frontier.pop()
        if not loc in visited:
            visited.append(loc)
            if loc==goal:
                return [rlen, loc[0], loc[1]]

            for nextloc, move_name in childNode(grid, loc, delta, delta_name):
                if not nextloc in visited:
                    frontier.push([nextloc, rlen+cost])
    return 'fail'
コード例 #18
0
ファイル: loop_treasure.py プロジェクト: Team-JAM/algorithms
def get_directions(starting_room, destination_room, all_rooms):
    # Create an empty queue
    queue = Queue()
    # Add a path for starting_room_id to the queue
    # Add a second option that recalls to room zero first
    # paths will contain tuple of (direction, room_id)
    queue.enqueue([(None, starting_room)])
    # queue.enqueue([(None, starting_room), (None, 0)])
    # Create an empty set to store visited rooms
    visited = set()
    while queue.size() > 0:
        # Dequeue the first path
        path = queue.dequeue()
        # Grab the last room from the path
        room = path[-1][1]
        # If room is the desination, return the path
        if room == destination_room:
            return path[1:]
        # If it has not been visited...
        if room not in visited:
            # Mark it as visited
            visited.add(room)
            # Then add a path all neighbors to the back of the queue
            current_room = all_rooms[str(room)]
            adjacent_rooms = []
            for e in current_room['exits']:
                adjacent_rooms.append((e, current_room['exits'][e]))
            for next_room in adjacent_rooms:
                queue.enqueue(path + [next_room])
コード例 #19
0
ファイル: graphs.py プロジェクト: atonymartin20/TreasureHunt
 def bfs(self, starting_vertex, destination_vertex):
     """
     Return a list containing the shortest path from
     starting_vertex to destination_vertex in
     breath-first order.
     """
     # make a queue
     queue = Queue()
     # make a visited set
     visited = set()
     # enqueue the PATH to that node
     queue.enqueue([starting_vertex])
     # While queue isn't empty
     while queue.size():
         # dequeue the PATH
         path = queue.dequeue()
         # the last thing in the path is our current item
         node = path[-1]
         # if node is not visited:
         if node not in visited:
             # CHECK if it's the target
             if node == destination_vertex:
                 # if so, return the path
                 return path
             visited.add(node)
             # for each of the node's neighbor's
             for neighbor in self.vertices[node]:
                 #copy the path
                 PATH_COPY = path.copy()
                 # add neighbor to the path
                 PATH_COPY.append(neighbor)
                 # enqueue the PATH_COPY
                 queue.enqueue(PATH_COPY)
     return None
コード例 #20
0
    def __init__(self, user_accounts):
        """Initialization

        Args:
            user_accounts (list): user account details from bank
        """
        self.user_accounts = user_accounts

        self.options = None
        self.option_states = []

        self.q = Queue()
        self.q.enqueue(self.init)

        self.curr_acc = None
コード例 #21
0
    def __init__(self, parent=None):
        tk.Frame.__init__(self, parent)
        self.grid(column=0, row=0)
        self.columnconfigure(0, weight=1)
        self.rowconfigure(0, weight=1)
        self.parent = parent

        self.test_problem = State()
        self.test_fringe = Queue()
        self.problem = State()
        self.solution = tree_search(self.test_problem, self.test_fringe)
        self.solution_stage = 0

        self.connor_hp = tk.IntVar()
        self.arnold_hp = tk.IntVar()

        self.connor_defense = tk.StringVar()
        self.arnold_defense = tk.StringVar()

        self.update()

        name_column = 1
        data_column = 2

        self.ui_label(1, name_column, 'Connor')
        self.ui_label(4, name_column, 'Arnold')
        self.ui_label(2, name_column, 'Defense')
        self.ui_label(5, name_column, 'Defense')
        self.ui_label(1, data_column, self.connor_hp, True)
        self.ui_label(4, data_column, self.arnold_hp, True)
        self.ui_label(2, data_column, self.connor_defense, True)
        self.ui_label(5, data_column, self.arnold_defense, True)

        self.ui_btn(6, data_column, 'Next', self.resolve)
コード例 #22
0
    def __init__(self, event_hub: EventsHub):
        self.state = RubiksCube()
        self._generate_cubes(self.state.cubes)
        self._animation: Queue = Queue()  # Stores animations to move faces
        self.event_hub = event_hub

        self._add_listeners()
コード例 #23
0
class Account(object):

    account = dict()
    fax = 0

    kline = Queue.Queue()
    MIN_DATA_COUNT = 26 * 3 + 1
    MAX_DATE = None

    def __init__(self):
        print()

    #获取K线数据
    def getKlines(self):
        raise NotImplementedError()

    #获取账户余额
    def getAccountBalance(self):
        raise NotImplementedError()

    #买币
    def buy(self, ratio, kline):
        raise NotImplementedError()

    def sell(self, ratio, kline):
        raise NotImplementedError()

    def initWithKeySecret(self, key, secret):
        raise NotImplementedError()
コード例 #24
0
def solve(board, robots, dest, dest_color, num_sols=3, max_depth=20):
    """
	Robots denotes the position and orientation (above or below a diag) of the robots.
	The robot of color DEST_COLOR must get to the square given by DEST (an (x, y) tuple).
	A list of Solution objects are returned, NUM_SOLS many of them (the best, second best, etc.)
	If we haven't found a solution less than MAX_DEPTH, give up
	"""

    assert len(robots) == 4, "there must be 4 robots"
    assert dest_color in ["yellow", "red", "green", "blue"]
    assert num_sols >= 0 and max_depth >= 0, "Cannot have a negative number of solutions or max depth"

    print "Trying to move", dest_color, "robot to", dest

    solutions = []
    if num_sols == 0:
        return solutions

    # initialize the BFS fringe
    initial_sol = Solution(robots)
    bfs_fringe = Queue()
    bfs_fringe.enqueue(initial_sol)

    # in loop: dequeue, check if solution, add all next positions to queue
    curr_depth = 0
    num_sols_at_depth = 0
    while True:
        assert not bfs_fringe.empty(), "BFS fringe is empty"

        # dequeue the Solution at the front of the stack
        curr_sol = bfs_fringe.dequeue()

        # if it is a valid solution for the board, add it to the list of solutions to return
        if board.isSolution(curr_sol, dest, dest_color):
            solutions.append(curr_sol)
            if len(solutions) == num_sols:
                return solutions

        if curr_sol.depth > curr_depth:
            print "Examined", num_sols_at_depth, "solutions at depth", curr_depth
            curr_depth = curr_sol.depth
            num_sols_at_depth = 0

        # check that the depth of this solution does not exceed max depth
        num_sols_at_depth += 1
        if num_sols_at_depth % 100 == 0:
            print "Examined", num_sols_at_depth, "solutions at depth", curr_depth

        if curr_sol.depth > max_depth:
            break

        # for each of the possible robot moves, make the move, grab the new Solution and enqueue it
        next_moves = board.allNextMoves(curr_sol)
        for next_move in next_moves:
            bfs_fringe.enqueue(next_move)

    return solutions
コード例 #25
0
    def BFS(self, s):
        '''
        Breadth first search algorithm (BFS)
        Input:  s - start vertex
        Output: visited (set) - the set of accessible vertices from s
                prev (dictionary) - each key has as value the vertex
                    that is previous to the key in the BFS path
                dist (dictionary) - each key represent a vertex and has
                    as value the length of the shortest path from s to it
        '''
        visited = set()  # set
        q = Queue()  # queue
        prev = {}  # dictionary
        dist = {}  # dictionary

        prev[s] = None
        dist[s] = 0

        q.enqueue(s)
        while len(q) > 0:
            x = q.dequeue()  # get the next element from the queue
            for y in self.__dg.iterateOut(x):
                if y not in visited:
                    visited.add(y)
                    q.enqueue(y)
                    prev[y] = x
                    dist[y] = dist[x] + 1

        return visited, prev, dist
コード例 #26
0
def search(grid, init, goal, cost):
    # ----------------------------------------
    # insert code here
    # ----------------------------------------
    Nr = len(grid)
    Nc = len(grid[0])
    expand = [[-1 for j in range(Nc)] for i in range(Nr)]
    policy = [[' ' for j in range(Nc)] for i in range(Nr)]
    path = [[' ' for j in range(Nc)] for i in range(Nr)]
    count = 0

    def childNode(grid, loc, delta, delta_name):
        child = []
        for i in range(len(delta)):
            move = delta[i]
            newloc = [loc[0] + move[0], loc[1] + move[1]]
            if loc[0]+move[0]>=0 and loc[0]+move[0]<Nr \
            and loc[1]+move[1]>=0 and loc[1]+move[1]<Nc \
            and grid[newloc[0]][newloc[1]] ==0:
                child.append([newloc, delta_name[i]])
        return child

    visited = []
    frontier = Queue()
    frontier.push([init, ' ', 0])

    while not frontier.isEmpty():
        loc, mov, rlen = frontier.pop()
        if not loc in visited:
            visited.append(loc)
            policy[loc[0]][loc[1]] = mov

            if loc == goal:
                path[goal[0]][goal[1]] = '*'
                while loc != init:
                    x, y = loc
                    if policy[x][y] == 'v':
                        loc = [x - 1, y]
                        path[loc[0]][loc[1]] = 'v'
                    elif policy[x][y] == '^':
                        loc = [x + 1, y]
                        path[loc[0]][loc[1]] = '^'
                    elif policy[x][y] == '>':
                        loc = [x, y - 1]
                        path[loc[0]][loc[1]] = '>'
                    elif policy[x][y] == '<':
                        loc = [x, y + 1]
                        path[loc[0]][loc[1]] = '<'

                return path

            for nextloc, move_name in childNode(grid, loc, delta, delta_name):
                if not nextloc in visited:
                    frontier.push([nextloc, move_name, rlen + cost])
    return 'fail'
コード例 #27
0
ファイル: depth_first_order.py プロジェクト: whille/pyAlgr
class DepthFirstOrder:
    def __init__(self, G):
        self.marked = [False for _ in range(G.V)]
        self.pre = Queue()  # push v to queue before recursion
        self.post = Queue()  # ... after recursion
        self.reverse_post = Stack()  # push v to stack after recursion
        for w in range(G.V):
            if not self.marked[w]:
                self.dfs(G, w)

    def dfs(self, G, v):
        self.pre.enqueue(v)
        self.marked[v] = True
        for w in G.adj[v]:
            if not self.marked[w]:
                self.dfs(G, w)
        self.post.enqueue(v)
        self.reverse_post.push(v)
コード例 #28
0
 def build_path(self, G, s):
     self.marked[s] = True
     queue = Queue()
     queue.enqueue(s)
     while not queue.is_empty():
         v = queue.dequeue()
         for w in G.adj[v]:
             if not self.marked[w]:
                 self.edge_to[w] = v
                 self.marked[w] = True
                 queue.enqueue(w)
コード例 #29
0
ファイル: expr.py プロジェクト: marcinkrolik/MathExpressions
 def evaluate(self, vars):
     stack = Stack()
     queue = Queue()
     for elem in self._rpn:
         factory = OperatorFactory()
         operator = factory.newOperator(elem, stack, vars)
         if self.verbose == True:
             print elem, operator.evaluate()
         stack.push(operator.evaluate())
         if self.verbose == True:
             print stack.s()
     return stack.popAll()
コード例 #30
0
 def test_pop_2(self):
     q = Queue()
     q.put(2)
     q.put(1)
     self.assertEqual(q.pop(), 2)
     self.assertEqual(q.pop(), 1)
     self.assertTrue(q.empty())
コード例 #31
0
ファイル: expr.py プロジェクト: marcinkrolik/MathExpressions
    def convert(self, verbose):
        self.verbose = verbose
        operators = "^*+-\/"
        # operands = string.ascii_lowercase + string.digits
        output = Queue()
        stack = Stack()

        for token in self.infix:
            operands = re.match("^[a-z]$|^\d+\.\d+$|^\d+$", token)
            operators = re.match("^[+-\/*^]$", token)
            # if token is a number or variable add it to putput
            if operands:
                output.push(token)
                if self.verbose == True:
                    print "1 token = %s, output = %s" % (token, output.list[::-1])
                # if the token is variable add it mapVariable dictionary
                if token in string.ascii_lowercase:
                    self.mapVariables[token] = ""
            # if token is an operator
            elif operators:
                # while there is another operator on the stack
                while not stack.isEmpty():
                    # if operator is lef-associative and its precedence is less than or equal to that on stack, or operator has precedence less than that on stack (is not left-associative)
                    if stack.lastOnStack() != "(" and (
                        (
                            self.precedence[token][0] <= self.precedence[stack.lastOnStack()][0]
                            and self.precedence[token][1] == "L"
                        )
                        or self.precedence[token][0] < self.precedence[stack.lastOnStack()][0]
                    ):
                        # push operator to output from stack
                        output.push(stack.pop())
                        if self.verbose == True:
                            print "2 token = %s, output = %s" % (token, output.list[::-1])
                    else:
                        break
                # push operator to stack
                stack.push(token)
                if self.verbose == True:
                    print "3 token = %s, stack = %s" % (token, stack.list[::-1])
            # if token is left parenthesis push it to stack
            elif token == "(":
                stack.push(token)
                if self.verbose == True:
                    print "4 token = %s, stack = %s" % (token, stack.list[::-1])
            # if token is right parenthesis
            elif token == ")":
                # until token at the top of stack is not left parethesis
                while stack.lastOnStack() != "(":
                    # push from stack to output
                    output.push(stack.pop())
                    if self.verbose == True:
                        print "5 token = %s, output = %s" % (token, output.list[::-1])
                # and pop left parethesis from stack but not to output
                stack.pop()
        if self.verbose == True:
            print "Left on stack " + str(stack.list[::-1])
            print "Output " + str(output.list)
        self._rpn = output.list[::-1]
        while len(stack.list) > 0:
            self._rpn.append(stack.pop())
        if self.verbose == True:
            print "RPN value = " + str(self._rpn)
        return self._rpn
コード例 #32
0
ファイル: test.py プロジェクト: marcinkrolik/MathExpressions
import re
from utils import Stack
from utils import Queue

def recu(s, out, stk):
    print s
    for token in s:
        print token
        dig = re.match('\d+', token)
        oper = re.match('[\+\-\/\*]', token)
        if token == '(':
            a = s[s.index(token)+1:s.index(')')]
            print "obciachane ", a
            del s[s.index(')')]
            recu(a, out, stk)
        elif dig:
            out.push(token)
        elif oper:
            stk.push(token) 

output = Queue()
stack = Stack()
s1 = '(2+3)*5'
s2 = re.split('\s*([+\-*/()]|\d+\.\d+|\d+)\s*', s1)
recu(s2, output, stack)
print output.popAll(), stack.popAll()