def breadth_first_tree_search(self, problem): queue = Queue() node = Node(problem.initial, None, None, 0) queue.enqueue(node) explored = [] #print("problem initial = ", problem.initial) while not queue.is_empty(): node = queue.dequeue() #print(node.state) if (problem.goal_test(node.state)): #print("goal reached: ", node.state) return node explored.append(node.state) problem.visited = len(explored) frontier_nodes = node.expand_frontier(problem) problem.time += len(frontier_nodes) #print("frontier: ", frontier_nodes.state) for fnode in frontier_nodes: #print(fnode) if (fnode != None and fnode.state not in explored): queue.enqueue(fnode) if (queue.size() > problem.frontier): problem.frontier = queue.size() return None
def test_size(self): mock_item1 = MagicMock() mock_item2 = MagicMock() queue = Queue() assert queue.size() == 0 queue.enqueue(mock_item1) assert queue.size() == 1 queue.enqueue(mock_item2) assert queue.size() == 2
def main(): queue = Queue() queue.enqueue("Mon") queue.enqueue("Thu") queue.enqueue("Wed") print(queue.size()) queue.dequeue() print(queue.size())
def bfs(g, start): """Breadth First Search Searching a graph and adjusting the vertex states. Args: g: a gragh start: a starting vertex. Returns: None Raises: None """ start.setDistance(0) start.setPred(None) vertQueue = Queue() vertQueue.enqueue(start) while vertQueue.size() > 0: currentVert = vertQueue.dequeue() for nbr in currentVert.getConnections(): if nbr.getColor() == 'white': nbr.setColor('grey') nbr.setDistance(currentVert.getDistance() + 1) nbr.setPred(currentVert) vertQueue.enqueue(nbr) currentVert.setColor('black')
def simulateManyServer(num_secs, file_per_min, in_file, num_servers): request_list = [Server(file_per_min) for i in range(num_servers)] print_queue = Queue() waiting_times = [] with open(in_file) as lines: for line in lines: data = line.split(',') request = Request(int(data[0].strip()), data[1], int(data[2].strip())) print_queue.enqueue(request) current_server = 0 for current_second in range(num_secs): if (not request_list[current_server].busy()) and ( not print_queue.is_empty()): next_task = print_queue.dequeue() waiting_times.append(next_task.wait_time()) request_list[current_server].start_next(next_task) current_server = (current_server + 1) % len(request_list) for server in request_list: if server.busy: server.tick() average_wait = sum(waiting_times) / len(waiting_times) print("Average Wait %6.2f secs %3d tasks remaining." % (average_wait, print_queue.size()))
class piLearning: def __init__(self): self.event_queue = Queue() def get_mean(self, itemlist): return sum(itemlist) / len(itemlist) def get_stdev(self, smeanlist): grand_mean = self.get_mean(smeanlist) stdev = 0 for x in smeanlist: stdev += (x - grand_mean)**2 return stdev def learn(self): print("Learning initiated") # calculate averages self.moving_average(self, 10) def moving_average(self, window_size): if (self.event_queue.size() >= window_size): samples = self.event_queue.consumeQ( window_size) # assuming samples is not empty avg = self.get_mean(samples) self.movavgs.append(avg) def rolling_std(self, mu, samples): self.movstd.append(np.std( samples, ddof=1)) # standard deviation for samples (instead of population)
def simulation(simulationTime, pagesPerMinute): # create a printer with a specific page rate labprinter = Printer(pagesPerMinute) printQueue = Queue() # waiting times list used for extracting meaningful content from the simulation waitingtimes = [] # run simulationTime seconds for currentSecond in range(simulationTime): if newPrintTask(): # create a new task if newPrintTask has randomly created a task task = printJob(currentSecond) # enqueue task to the print Queue printQueue.enqueue(task) # if printer is free and printQueue has jobs to process if (not labprinter.busy()) and (not printQueue.is_empty()): # process printJob nexttask = printQueue.dequeue() # keep track of how long printJob had to wait in the queue waitingtimes.append( nexttask.waitTime(currentSecond)) # start printing next task labprinter.startNextTask(nexttask) labprinter.tick() averageWait=sum(waitingtimes)/len(waitingtimes) print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size()))
def mp_skeletonize(seg): def worker(img_orig, label, out_q): """thread worker function""" img = np.zeros(img_orig.shape) img[img_orig == label] = 1 skel_img = skeletonize_3d(img) out_q.put(skel_img) # Each process will get 'chunksize' nums and a queue to put his out # dict into out_q = Queue() # chunksize = int(math.ceil(len(nums) / float(nprocs))) procs = [] for label in np.unique(seg): p = Process(target=worker, args=(seg, label, out_q)) procs.append(p) p.start() # Collect all results into a single result dict. We know how many dicts # with results to expect. final = np.zeros(seg.shape) print "1" while out_q.size(): final[out_q.get() == 1] = 1 print "2" # Wait for all worker processes to finish for p in procs: p.join() print "3" return final
def ClinicSim(w): # simulation for doctor clinic Doctor0 = Doctor() patientQ = Queue() # creating The queue TimeWaiting = [] # create the waiting times alist for currentsec in range( w): # w is the time we enter ( 4 hours = 4*60*60 second) if random.randrange( 1, 361 ) == 360: #checks the probability of arrival of a patient at any given second patient = Patient(currentsec) #creating a file for the patient patientQ.enqueue(patient) # adding the patient to the queue if not Doctor0.busy() and not patientQ.isEmpty( ): # check if the doctor is not busy and if there is a patient nextp = patientQ.dequeue() # delete patient from queue TimeWaiting.append( nextp.waittime(currentsec) ) #calculate the waiting time then add it to the list of waiting times Doctor0.Nextp(nextp) #let the patient enter to the doctor Doctor0.tick() #checks for patients still at the doctor averagewait = sum(TimeWaiting) / len( TimeWaiting) # calculate the average wait print("Average Wait ", averagewait, " secs", patientQ.size(), " tasks remaining.")
def simulation(numSeconds, pagesPerMinute): labprinter = Printer(pagesPerMinute) printQueue = Queue() waitingtimes = [] number = 0 # 用循环模拟每一秒钟的情况 for currentSecond in range(numSeconds): # 有新任务时,任务入队 if newPrintTask(): number += 1 task = Task(currentSecond, number) logging.info('第{}秒,任务{}进入打印队列, 共{}页'.format(currentSecond, task.number, task.pages)) printQueue.enqueue(task) # 当打印机不忙,打印队列不为空时,开始下一个任务 if (not labprinter.busy()) and (not printQueue.isEmpty()): nexttask = printQueue.dequeue() waittime = nexttask.waitTime(currentSecond) logging.info('第{}秒,任务{}开始打印,等待了{}秒。'.format(currentSecond, task.number, waittime)) waitingtimes.append(waittime) labprinter.startNext(nexttask) # 执行打印逻辑 当前任务剩余时间 -1, 为0时结束任务 labprinter.tick(currentSecond) averageWait = sum(waitingtimes) / len(waitingtimes) logging.info("共执行了{}项打印任务,平均等待时间为{}秒, 打印队列里还有{}项任务".format\ (number, averageWait, printQueue.size()))
def test_size(): """Test size method.""" from Queue import Queue q = Queue() q.enqueue(data[0]) q.enqueue(data[1]) assert q.size() == 2
def simulation(numSeconds, pagesPerMinute): labprinter = Printer(pagesPerMinute) printQueue = Queue() waitingtimes = [] complete = [] # total time is 1 hour for currentSecond in range(numSeconds): print('currentSecond: ', currentSecond) if newPrintTask(): # if task is created, go into the Queue to wait task = Task(currentSecond) # timestamp for this task printQueue.enqueue(task) print('>>printQueue', printQueue) print('waitingtimes: ', waitingtimes) # add task if (not labprinter.busy()) and (not printQueue.isEmpty()): nexttask = printQueue.dequeue() # waiting time before printing: currentSecond - nexttask.timestamp waitingtimes.append(nexttask.waitTime(currentSecond)) print('>>printQueue', printQueue) print('waitingtimes for all tasks: ', waitingtimes) labprinter.startNext(nexttask) complete.append(nexttask) print('>>complete tasks and next task: ', complete) # start printing # when the timeremaining is 0 then the printer is available labprinter.tick() if waitingtimes != []: averageWait = sum(waitingtimes) / len(waitingtimes) print("Average Wait %6.2f secs %3d tasks remaining" % (averageWait, printQueue.size()))
def _test_queue(self): queue = Queue() assert queue.is_empty() for item in self._test_items: queue.push(item) assert queue.size() == 4, "expected queue to be of size 4" assert ( queue.peek() == "firstItem" ), "expected first item in queue to be firstItem" popped = queue.pop() assert queue.size() == 3 assert queue.peek() == "secondItem" assert popped == "firstItem" while not queue.is_empty(): queue.pop() assert queue.is_empty()
def hot_potato(nameList: List, num: int) -> str: nameQueue = Queue(nameList) print(nameQueue.viewAll()) while nameQueue.size() > 1: for i in range(0, num): nameQueue.enqueue(nameQueue.dequeue()) nameQueue.dequeue() return nameQueue.viewAll()
def testEmptyQueue(self): queue = Queue() self.assertFalse(queue.hasOne()) self.assertTrue(queue.isEmpty()) self.assertFalse(queue.isFull()) self.assertEqual(queue.size(), 0)
def reverse(q_orig): q_new = Queue([]) s = q_orig.size()-1 while (not q_new.size() == q_orig.size()): q_new.enq(q_orig.queue[s]) s -= 1 return q_new
def hotPotato(namelist, num): simqueue = Queue() for name in namelist: simqueue.enqueue(name) while simqueue.size() > 1: for i in range(num): simqueue.enqueue(simqueue.dequeue()) print(simqueue.dequeue()) return simqueue.dequeue()
def hot_potato(name_list, num): sim_queue = Queue() for name in name_list: sim_queue.enqueue(name) while sim_queue.size() > 1: for i in range(num): sim_queue.enqueue(sim_queue.dequeue()) #sim_queue.dequeue() return sim_queue.dequeue()
def hotPotato(name_list, num): queue = Queue() for name in name_list: queue.enqueue(name) while queue.size() > 1: for i in range(num): queue.enqueue(queue.dequeue()) queue.dequeue() return queue.dequeue()
def testAttr_n_dequeue(self): queue = Queue() for i in range(1, 10): queue.enqeue(i) for i in range(8, 0, -1): queue.dequeue() self.assertEqual(queue.size(), i)
def simulation(numSeconds, ppm1, ppm2,minTask,maxTask): p1 = Printer(ppm1) p2 = Printer(ppm2) pQueue = Queue() wTimes = [] avgList = [] for currentSecond in range(numSeconds): if newpTask(): task = Task(currentSecond,minTask,maxTask) pQueue.enqueue(task) if (p1.getPageRate() >= p2.getPageRate() or p2.getPageRate() is 0): p1fastest = True else: p1fastest = False if (not p1.busy() and not p2.busy() and p2.getPageRate() is not 0 and not pQueue.is_empty()): if (p1fastest): nexttask = pQueue.dequeue() wTimes.append(nexttask.waitTime(currentSecond)) p1.startNext(nexttask) elif (not pr1fastest): nexttask = pQueue.dequeue() wTimes.append(nexttask.waitTime(currentSecond)) p2.startNext(nexttask) if (not p1.busy()): if (not pQueue.is_empty()): nexttask = pQueue.dequeue() wTimes.append(nexttask.waitTime(currentSecond)) p1.startNext(nexttask) if (p2.getPageRate() is not 0 and not pr2.busy()): if (not pQueue.is_empty()): nexttask = pQueue.dequeue() wTimes.append(nexttask.waitTime(currentSecond)) p2.startNext(nexttask) p1.tick() p2.tick() avgWait = sum(wTimes)/len(wTimes) print("Average Wait %6.2f secs %3d tasks remaining." \ %(avgWait,pQueue.size())) output = ("Average Wait %6.2f secs %3d tasks remaining." \ %(avgWait,pQueue.size())) return(avgWait)
def hotPotato(namelist, num): sim = Queue() for name in namelist: sim.enqueue(name) while sim.size() > 1: for i in range(num): sim.enqueue(sim.dequeue()) sim.dequeue() return sim
def hotPotato(players, num): simQ = Queue() for p in players: simQ.enqueue(p) while simQ.size() > 1: for i in range(num): simQ.enqueue(simQ.dequeue()) simQ.dequeue() return simQ.dequeue()
def hot_potato(l, num): q = Queue() for i in l: q.enqueue(i) while q.size() > 1: for j in range(num): q.enqueue(q.dequeue()) q.dequeue() return q.dequeue()
def Filter(s,num): # s是成员名字列表,num是传递次数 q = Queue() for i in s: # 将所有成员按顺序入列 q.enqueue(i) while q.size() > 1: # 循环直至只剩一个人 count = 0 # 每次重置传递土豆次数 while count <= num: q.enqueue(q.dequeue()) # 队首出列后到队尾算是将土豆传递给下一个人 count += 1 q.dequeue() # 传递一个次数后 队首的人算为“持有土豆” 则退出 return q.dequeue()
def permutation(namelist, num): q = Queue() for name in namelist: q.enqueue(name) while q.size() > 1: for i in range(num - 1): q.enqueue(q.dequeue()) q.dequeue() return q.dequeue()
def test_queue(): # Setup q = Queue() q.enqueue(1) q.enqueue(2) q.enqueue(3) # Test size assert q.size() == 3, 'Fail' # Test dequeue assert q.dequeue() == 1, 'Fail' # Test enqueue q.enqueue(4) assert q.dequeue() == 2, 'Fail' assert q.dequeue() == 3, 'Fail' assert q.dequeue() == 4, 'Fail' q.enqueue(5) assert (q.size() == 1), "Fail"
def hot_potato(nameList, num): nameQueue = Queue() for name in nameList: nameQueue.enqueue(name) while nameQueue.size() > 1: for i in range(num): nameQueue.enqueue(nameQueue.dequeue()) nameQueue.dequeue() return nameQueue.dequeue()
def testSeq1N(self): #Constructor queue = Queue() #Reporter : Récupérons la longueur de la queue self.assertEqual(str(queue.size()), str(0)) #Transformer : Ajoutons l'élément 0 à la queue queue.enqeue(0) #Reporter : Récupérons la longueur de la queue self.assertEqual(str(queue.size()), str(1)) #Transformer : Retirons l'élément 0 de la queue self.assertEqual(str(queue.dequeue()), str(0)) #Reporter : Récupérons la longueur de la queue self.assertEqual(str(queue.size()), str(0)) #Other : Une queue vide doit lancer une erreur si on essaie de récupérer le dernier élément self.assertRaises(ValueError, queue.check_last)
def testSeq2N(self): #Constructor queue = Queue() #Reporter : Récupérons la longueur de la queue self.assertEqual(str(queue.size()), str(0)) #Transformer : Une queue vide doit lancer une erreur si on essaie de retirer le premier élément self.assertRaises(ValueError, queue.dequeue) #Reporter : Récupérons la longueur de la queue self.assertEqual(str(queue.size()), str(0)) #Transformer : Ajoutons l'élément 0 à la queue queue.enqeue(0) #Reporter : Récupérons la longueur de la queue self.assertEqual(str(queue.size()), str(1)) #Other : La queue contient un élément self.assertTrue(queue.hasOne())
class MovingAverage: """ @param: size: An integer """ def __init__(self, size): # do intialization if necessary self.queue = Queue() self.size = size self.sum = 0.0 """ @param: val: An integer @return: """ def next(self, val): self.sum += val if self.queue.size() == self.size: self.sum -= self.queue.get() self.queue.put(val) return self.sum * 1.0 / self.queue.size()
def josephus(namelist, num): simqueue = Queue() for name in namelist: simqueue.enqueue(name) while simqueue.size() > 1: for i in xrange(num): simqueue.enqueue(simqueue.dequeue()) simqueue.dequeue() return simqueue.dequeue()
def BFS(self,start): start.setDistance(0) vertQueue= Queue() vertQueue.enqueue(start) while(vertQueue.size()>0): currentVert=vertQueue.dequeue() for nbr in currentVert.getConnections(): if(nbr.getColor()=="white"): nbr.setColor("gray") nbr.setDistance(currentVert.getDistance()+1) nbr.setPred(currentVert) vertQueue.enqueue(nbr) currentVert.setColor("black")
class QueueTest(unittest.TestCase): def setUp(self): self.queue = Queue() self.queue.enqueue(1) self.queue.enqueue(2) self.queue.enqueue(3) self.queue.enqueue(4) self.queue.enqueue(5) def test_empty_queue(self): queue = Queue() self.assertEqual(queue.head, None) self.assertEqual(queue.tail, None) self.assertTrue(queue.is_empty()) with self.assertRaises(Queue.Empty): queue.peek() with self.assertRaises(Queue.Empty): queue.dequeue() def test_size(self): self.assertEqual(self.queue.size(), 5) def test_enqueue(self): self.queue.enqueue(6) self.assertEqual(self.queue.size(), 6) self.assertEqual(self.queue.tail.get_data(), 6) def test_dequeue(self): self.assertEqual(self.queue.dequeue(), 1) self.assertEqual(self.queue.dequeue(), 2) def test_peek(self): self.assertEqual(self.queue.peek(), 1) self.assertEqual(self.queue.peek(), 1)
def hotPotato(players): if players is None or len(players) <= 1: return players simQ = Queue() plsize = len(players) for p in players: simQ.enqueue(p) while simQ.size() > 1: r = random.randint(plsize, plsize*2) for i in range(r): simQ.enqueue(simQ.dequeue()) simQ.dequeue() return simQ.dequeue()
def bfs(g,start): start.setDistance(0) start.setPred(None) vertQueue = Queue() vertQueue.enqueue(start) while (vertQueue.size() > 0): currentVert = vertQueue.dequeue() print 'Current ', currentVert.id for nbr in currentVert.getConnections(): if (nbr.getColor() == 'white'): nbr.setColor('gray') nbr.setDistance(currentVert.getDistance() + 1) nbr.setPred(currentVert) vertQueue.enqueue(nbr) currentVert.setColor('black')
def simulation(num_seconds, pages_per_minute): lab_printer = Printer(pages_per_minute) print_queue = Queue() waiting_times = [] for current_second in range(num_seconds): if new_print_task(): task = Task(current_second) print_queue.enqueue(task) if (not lab_printer.busy()) and (not print_queue.is_empty()): next_task = print_queue.dequeue() waiting_times.append(next_task.wait_time(current_second)) lab_printer.startNext(next_task) lab_printer.tick() average_wait = sum(waiting_times) / len(waiting_times) print("Average Wait %6.2f secs %3d tasks remaining." %(average_wait, print_queue.size()) )
def simulation(seconds, ppm): printQueue = Queue() waitingtimes = [] printer = Printer(ppm) for currentSecond in range(seconds): if newPrintTask(): printQueue.enqueue(Task("Task"+str(currentSecond), currentSecond)) if (not printer.busy()) and (not printQueue.isEmpty()): nexttask = printQueue.dequeue() waitingtimes.append(nexttask.getWaitTime(currentSecond)) printer.nextTask(nexttask) printer.tick() lenWaitTime = len(waitingtimes) averageWait=sum(waitingtimes)/lenWaitTime print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size()))
def simulation(numSeconds, pagePerMin): labPrinter = Printer(pagePerMin) printQ = Queue() waitTime = [] for currentSecond in range(numSeconds): if newPrintTask(): task = Task(currentSecond) printQ.enqueue(task) if (not labPrinter.busy()) and (not printQ.is_empty()): nextTask = printQ.dequeue() waitTime.append(nextTask.waitTime(currentSecond)) labPrinter.startNext(nextTask) labPrinter.tick() avgWait = sum(waitTime)/len(waitTime) print ("Avg wait: %6.2f secs, Tasks remaining: %3d" % (avgWait, printQ.size()))
def simulation(numseconds, pageperminute): labprinter = Printer(pageperminute) printerQueue = Queue() waitingtimes = [] for currentseconds in range(numseconds): if newPrintTask(): task = Task(currentseconds) printerQueue.enqueue(task) if (not labprinter.busy()) and (not printerQueue.isEmpty()): nextTask = printerQueue.dequeue() waitingtimes.append(nextTask.waitTime(currentseconds)) labprinter.pickNextTask(nextTask) labprinter.tick() averageWait = sum(waitingtimes)/len(waitingtimes) print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printerQueue.size()))
#!/usr/bin/python from Queue import Queue; queue = Queue() queue.enqueue('Daniel') queue.enqueue('Kevin') queue.enqueue('Joe') print(queue.dequeue()) print(queue.dequeue()) print(queue.size()) print(queue.dequeue()) print(queue.size())
def p_vars2(p): '''Vars2 : ID COR_I Exp COR_D VarSize DOSP Tipo Vars3 ''' pass vars_values.pop() if (ids.vars_exists_in_list((p[1]))): vars_types.pop() vars_values.pop() if len(vars_size) > 1: #Si existe mas de 1 elemento en la lista de tamano de variables obtiene 2 elementos vars_size.pop() vars_size.pop() else: #Si no, solo obtiene 1 elemento vars_size.pop() else: ids.enqueue(p[1]) if ids.size() > 0: #Si encuentra que existe un id, significa que hay que agregarlo a la tabla de variables #valor = p[2] tipo = vars_types.pop() #obtiene el tipo de la lista de de tipos #vars_types.append(tipo) sizes1 = None sizes2 = None if len(vars_size) > 1: #Si existe mas de 1 elemento en la lista de tamano de variables obtiene 2 elementos sizes2 = vars_size.pop() sizes1 = vars_size.pop() else: #Si no, solo obtiene 1 elemento sizes1 = vars_size.pop() identificador =ids.dequeue() x.var = x.add_vars_to_dict(tipo,sizes1, sizes2) #Se manda llamar el proceso de agregar variable al dict y lo guarda en el objeto var_dict.update({identificador: x.var}) #print(p[5])
from Queue import Queue q=Queue() n=input("Enter The Memory Size:\n") Pages=[int(i) for i in raw_input("Give a List Of Pages\n" ).split()] #print Pages pf=0 for i in Pages: #q.printList() if not q.isPresent(i): if q.size()==n: k=q.dequeue() print "Page \'"+str(k)+"\' is poped out" q.enqueue(i) pf+=1 print "No. of Page Faults :"+str(pf)
from Queue import Queue queue = Queue() queue.enqueue(1) queue.enqueue(2) queue.enqueue(3) print queue.dequeue() print queue.dequeue() print queue.size() print queue.dequeue() print queue.size() print queue.dequeue()