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 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 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 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 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 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()
