class TestArrayQueue(unittest.TestCase): def setUp(self): self.q = ArrayQueue() self.q.enqueue(1) self.q.enqueue(2) self.q.enqueue(3) def test_instantiation(self): print('Can create an instance') self.assertIsInstance(self.q, ArrayQueue) def test_length_checking(self): print('Can check the length of the queue') self.assertEqual(len(self.q), 3) def test_first_method(self): print('Can return the first element of the queue') self.assertEqual(self.q.first(), 1) def test_enqueue_method(self): print('Can add elements to the queue') self.q.enqueue(4) self.q.enqueue(5) self.assertEqual(len(self.q), 5) self.assertEqual(self.q.first(), 1) def test_dequeue_method(self): print('Can remove elements from the front of the queue') self.q.enqueue(4) self.q.enqueue(5) self.q.dequeue() self.assertEqual(self.q.dequeue(), 2) self.assertEqual(len(self.q), 3) self.assertEqual(self.q.first(), 3) def test_is_empty_method(self): print('Can check if the queue is empty') self.q.dequeue() self.q.dequeue() self.q.dequeue() self.assertEqual(self.q.is_empty(), True) def test_exception_raising(self): print( 'Can raise exception while performing action(s) on an empty queue') self.q.dequeue() self.q.dequeue() self.q.dequeue() with self.assertRaises(Empty): self.q.first() self.q.dequeue()
def breadth_first_print(self): Q = ArrayQueue() Q.enqueue(self.root()) while not Q.is_empty(): p = Q.dequeue() print(p) for c in self.children(p): Q.enqueue(c)
def breath_first(self): from ArrayQueue import ArrayQueue fringe = ArrayQueue() fringe.enqueue(self.root()) while not fringe.is_empty(): p = fringe.dequeue() yield p for c in p.children(): fringe.enqueue(c)
def breadth_first(self): if (self.is_empty()): return line = ArrayQueue() line.enqueue(self.root) while (line.is_empty() == False): curr_node = line.dequeue() yield curr_node if (curr_node.left is not None): line.enqueue(curr_node.left) if (curr_node.right is not None): line.enqueue(curr_node.right)
def invert_binary_tree2(root): if (root is None): return line = ArrayQueue() line.enqueue(root) while (line.is_empty() == False): curr_node = line.dequeue() curr_node.left, curr_node.right \ = curr_node.right, curr_node.left if (curr_node.left is not None): line.enqueue(curr_node.left) if (curr_node.right is not None): line.enqueue(curr_node.right)
def __str__(self): str_return = '' q_uttt = ArrayQueue() q_uttt.enqueue(self._root) last_depth = 0 while not q_uttt.is_empty(): child = q_uttt.dequeue() if last_depth != child.get_depth(): str_return += "\n" str_return += child.get_meta().get_meta_int() + ' ' last_depth = child.get_depth() for grand_child in child.get_children(): q_uttt.enqueue(grand_child) return str_return
def is_complete(root): if (root is None): return True line = ArrayQueue() line.enqueue(root) level = 0 while (line.is_empty() == False): if (len(line) != 2**level): return False for i in range(2**level): curr_node = line.dequeue() if (curr_node.left is not None): line.enqueue(curr_node.left) if (curr_node.right is not None): line.enqueue(curr_node.right) level += 1 return True
def print_tree_level(bin_Tree, level): output = [] if (bin_Tree.is_empty()): return line = ArrayQueue() line.enqueue((bin_Tree.root, 0)) while (line.is_empty() == False): curr = line.dequeue() output.append(curr) depth = curr[1] if (curr[0].left is not None): line.enqueue((curr[0].left, depth + 1)) if (curr[0].right is not None): line.enqueue((curr[0].right, depth + 1)) i = 0 outputlst = [] for i in output: if i[1] == level: outputlst.append(i[0].data) print(outputlst)
class Tower: def __init__(self): self._priority_queue = LinkedQueue() self._queue = ArrayQueue() self._current_plane = None self._total_plane_wait_time = 0 self._planes_served = 0 self._planes_crashed = 0 self._metrics = { "longest_wait_takeoff": 0, "longest_wait_landing": 0, "served_takeoff": 0, "served_landing": 0 } def add_to_Q(self, c): self._queue.add(c) def add_to_PriorityQ(self, c): self._priority_queue.add(c) def set_metrics(self, plane, cur_time): """ set class' metrics :param plane: :param cur_time: """ if plane is not None: #check takeoff metrics if plane.status == "Takeoff": wait_time = cur_time - self._current_plane.arrival_time self._metrics["longest_wait_takeoff"] += wait_time if wait_time > self._metrics["longest_wait_takeoff"]: self._metrics["longest_wait_takeoff"] = wait_time #check landing metrics if plane.status == "Landing": wait_time = cur_time - self._current_plane.arrival_time self._metrics["longest_wait_landing"] += wait_time if wait_time > self._metrics["longest_wait_landing"]: self._metrics["longest_wait_landing"] = wait_time def check_if_complete(self, plane): if plane is not None: #if plane is complete if plane.transaction_time == 0: if plane.status == "Takeoff": self._metrics["served_takeoff"] += 1 else: self._metrics["served_landing"] += 1 self._current_plane = None self._planes_served += 1 def serve_plane(self, cur_time): """ :param curr_time: int clock_tick """ if self._current_plane is None: # No plane is being helped and queue is empty, do nothing if self._queue.is_empty() and self._priority_queue.is_empty(): return else: # set the planes try: if len(self._priority_queue) > 0: self._current_plane = self._priority_queue.pop() self._current_plane.minus_fuel() # crashed plane if self._current_plane.fuel == 0: self._current_plane = None self._planes_crashed += 1 else: if self._queue.peek() is not None: self._current_plane = self._queue.pop() except: pass self.set_metrics(self._current_plane, cur_time) if self._current_plane is not None: self._current_plane.serve() self.check_if_complete(self._current_plane) @property def queue(self): return self._queue @property def priority_queue(self): return self._priority_queue def __str__(self): return_string = "\naverage time spent waiting for take off: " + str( self._metrics["longest_wait_takeoff"] / (round(self._metrics["served_takeoff"] + 1, 3))) return_string += "\naverage time spent waiting for to land: " + str( self._metrics["longest_wait_landing"] / round(self._metrics["served_landing"] + 1, 3)) return_string += "\nlongest time spent waiting for take off: " + str( self._metrics["longest_wait_takeoff"]) return_string += "\nlongest time spent waiting for to land: " + str( self._metrics["longest_wait_landing"]) return_string += "\nPlanes Crashed: " + str(self._planes_crashed) return_string += "\nPlanes served: " + str(self._planes_served) return_string += f"\nPlanes in queues {len(self._priority_queue) + len(self._queue)}" return return_string # What is the average time spent waiting for take off? # What is the average time spent waiting to land? # What is the longest time spent waiting for take off? # What is the longest time spent waiting to land? # How many planes crashed? # print(f"{len(tower.priority_queue)} {len(tower.queue)}") # How many planes total took off and landed during the simulation?
run_lst = [] block_lst = [] job_is_running_time = 0 # to calc cpu utilization job_is_blocking_time = 0 # to calc i/o utilization if detailed_mode: print( "\nThis detailed printout gives the state and remaining burst for each process.\n" ) while job_incomplete > 0: # one time unit is one cycle if detailed_mode: cycle_report(time, jobs_lst) # scan status for change scan_job(Q, jobs_lst, time) if not Q.is_empty() and cpu_can_run: cur_job = Q.dequeue() cur_job.start_run() job_running_in_cur_cycle = False job_is_blocking_in_cur_cycle = False for j in jobs_lst: if j.get_state() == 'running': j.run_controller() job_running_in_cur_cycle = True elif j.get_state() == 'blocked': j.block_controller() job_is_blocking_in_cur_cycle = True elif j.get_state() == 'ready': j.increment_waiting_time()