def queue_to_stack(queue):
"""
Converts the queue to a stack.
"""
stk_ar = ArrayStack()
q = ArrayQueue(queue)
el = []
while not q.isEmpty():
el.append(q.pop())
q1 = ArrayQueue(el[::-1])
while not q1.isEmpty():
stk_ar.push(q1.pop())
return stk_ar
class Cashier(object):
"""Represents a cashier."""
def __init__(self, number):
"""Maintains a cashier number, a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self._number = number
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = ArrayQueue()
def addCustomer(self, c):
"""Adds an arriving customer to my line."""
self._queue.add(c)
def serveCustomers(self, currentTime):
"""Serves my cuatomers during a given unit of time."""
if self._currentCustomer is None:
# No customers yet
if self._queue.isEmpty():
return
else:
# Pop first waiting customer and tally results
self._currentCustomer = self._queue.pop()
self._totalCustomerWaitTime += \
currentTime - \
self._currentCustomer.arrivalTime()
self._customersServed += 1
# Give a unit of service
self._currentCustomer.serve()
# If current customer is finished, send it away
if self._currentCustomer.amountOfServiceNeeded() == 0:
self._currentCustomer = None
def __str__(self):
"""Returns my results: my number, my total customers served,
my average wait time per customer, and customers left on my queue."""
if self._customersServed != 0:
aveWaitTime = float(self._totalCustomerWaitTime) /\
self._customersServed
else:
aveWaitTime = 0.0
result = "%4d %8d %13.2f %8d" % (self._number,
self._customersServed,
aveWaitTime,
len(self._queue))
return result
def queue_to_stack(queue):
"""
Converts queue to stack.
"""
temp_queue = ArrayQueue()
temp_stack = ArrayStack() #elements are in reversed order
result_stack = ArrayStack()
while not queue.isEmpty():
elem = queue.pop()
temp_queue.add(elem)
temp_stack.push(elem)
while not temp_queue.isEmpty():
queue.add(temp_queue.pop())
while not temp_stack.isEmpty():
result_stack.push(temp_stack.pop()) #we reverse elements
return result_stack
class TicketCounterSimulation():
# Create a simulation object.
def __init__(self, numAgents, numMinutes, betweenTime, serviceTime):
# Parameters supplied by the user.
self._arriveProb = 1.0 / betweenTime
self._serviceTime = serviceTime
self._numMinutes = numMinutes
# Simulation components.
self._passengerQ = ArrayQueue()
self._theAgents = Array(numAgents)
for i in range(numAgents):
self._theAgents[i] = TicketAgent(i + 1)
# Computed during the simulation.
self._totalWaitTime = 0
self._numPassengers = 0
# Run the simulation using the parameters supplied earlier.
def run(self):
for curTime in range(self._numMinutes + 1):
self._handleArrive(curTime)
self._handleBeginService(curTime)
self._handleEndService(curTime)
# Print the simulation results.
def printResults(self):
numServed = self._numPassengers - len(self._passengerQ)
avgWait = float(self._totalWaitTime) / numServed
print("")
print("Number of passengers served = ", numServed)
print("Number of passengers remaining in line = %d" %
len(self._passengerQ))
print("The average wait time was %4.2f minutes." % avgWait)
# Handles simulation rule #1.
def _handleArrive(self, curTime):
"""
Rule 1: If a customer arrives, he is added to the queue.
At most, one customer can arrive during each time step.
"""
if random.random() <= self._arriveProb:
self._numPassengers += 1
thePassenger = Passenger(self._numPassengers, curTime)
print("Time {}: Passenger {} arrived.".format(
curTime, self._numPassengers))
self._passengerQ.add(thePassenger)
# Handles simulation rule #2.
def _handleBeginService(self, curTime):
"""
Rule 2: If there are customers waiting, for each free server,
the next customer in line begins her transaction.
"""
for agent in self._theAgents:
if agent.isFree():
if not self._passengerQ.isEmpty():
thePassenger = self._passengerQ.pop()
agent.startService(thePassenger,
curTime + self._serviceTime)
print("Time {}: Agent {} started serving passenger {}.".
format(curTime, agent._idNum, thePassenger._idNum))
# Handles simulation rule #3.
def _handleEndService(self, curTime):
"""
Rule 3: For each server handling a transaction, if the transaction is complete, the
customer departs and the server becomes free.
"""
for agent in self._theAgents:
if agent.isFinished(curTime):
thePassenger = agent.stopService()
self._totalWaitTime += curTime - thePassenger._arrivalTime - self._serviceTime
print("Time {}: Agent {} stopped serving passenger {}.".format(
curTime, agent._idNum, thePassenger._idNum))
