def breadthTraverse(self, index):
if index == -1:
return
q = Queue()
print(self.vertexes[index], end='')
traversed.append(index)
q.insert(index)
while q.empty() == False:
p = self.vertexes[q.delete()]
if self.firstAdj(p) == -1:
continue
tmp = self.__locate(self.firstAdj(p))
while tmp not in traversed:
print(self.vertexes[tmp], end='')
traversed.append(tmp)
q.insert(tmp)
if self.nextAdj(self.vertexes[tmp], p) == -1:
break
tmp = self.__locate(self.nextAdj(self.vertexes[tmp], p))
class BFS:
def __init__(self) -> None:
self.alist = None
num = self.initilize()
self.visited = [-1] * num
self.Queue = Queue(10 * num)
def initilize(self):
num = 5
self.alist = AList(num)
self.alist.insert(0, 2)
self.alist.insert(0, 3)
self.alist.insert(1, 3)
self.alist.insert(1, 4)
self.alist.insert(2, 3)
self.alist.insert(3, 4)
self.alist.print_graph()
return num
def BFS_Start(self, node):
print("BFS Sequence is: ==> ", end="")
self.visited[node] = 0
print(node, "==>", end="")
k = self.alist.aL[node]
while k:
self.Queue.insert(k.nodeVal)
k = k.next
self.visited[node] = 1
while not self.Queue.isEmpty:
u = self.Queue.delete()
if self.visited[u] == -1:
self.visited[u] = 0
print(u, end="==>")
k = k = self.alist.aL[u]
while k:
self.Queue.insert(k.nodeVal)
k = k.next
self.visited[u] = 1
def bfs(G, s):
setV = Set(G.V())
for u in setV - Set(s):
u.color = WHITE
u.d = INF
u.pi = None
s.color = GRAY
s.d = 0
s.pi = None
Q = Queue()
Q.insert(s)
while Q:
u = Q.remove()
for v in G.adj(u):
if v.color == WHITE:
v.color = GRAY
v.d = u.d + 1
v.pi = u
Q.insert(v)
u.color = BLACK
class TestQueueClasses(TestCase):
def setUp(self):
self.queue = Queue()
def test_is_empty(self):
self.assertTrue(self.queue.is_empty())
def test_insert(self):
self.queue.insert(1)
self.assertEqual(1, self.queue.head.cargo)
def test_remove(self):
self.queue.insert(1)
self.assertEqual(1, self.queue.remove())
def test_insert_remove_multi(self):
self.queue.insert(1)
self.queue.insert(2)
self.queue.insert(3)
self.assertEqual(1, self.queue.remove())
self.assertEqual(2, self.queue.remove())
self.assertEqual(3, self.queue.remove())
from Queue import Queue
import os, sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)
from helpers import readData
from env import env
if __name__ == "__main__":
airbnbList = readData(env['path_airbnb'])
myQueue = Queue()
for i in range(myQueue.limit):
myQueue.insert(airbnbList[i])
myQueue.show()
#myQueue.remove()
print(
"##############################################################################################################################"
)
myQueue.tam()
myQueue.remove()
print(
"##############################################################################################################################"
)
myQueue.insert(airbnbList[0])
myQueue.show()
from Queue import Queue queue = Queue() queue.insert(5) queue.insert(6) print queue.remove() queue.insert(7) print queue.remove() print queue.remove() print queue.remove()
class Emergency:
def __init__(self, configuration_file):
# global
self.count = 0 # to control priority queue
self.current_time = 0
self.simulation_time = 0
# employee sets
self.nurses = set()
self.doctors = set()
self.secretaries = set()
# priority queues
self.event_queue = Queue(priority=True)
self.medical_care_queue = Queue(priority=True)
# other queues
self.registration_queue = Queue()
self.screening_queue = Queue()
self.exam_medicine_queue = Queue()
# config
self.config = {}
# Log
self.log = Log()
self.build(configuration_file)
self.start()
# =================================================================
# BUILD
# =================================================================
def build(self, configuration_file):
self.config = read_config(configuration_file)
self.simulation_time = float(self.config['T']['TTS'][0])
self.create_employees()
self.initialize_event_queue()
self.log.header(self)
def create_employees(self):
config = self.config['Q']
id = 1
amount = int(config['MED'][0])
for _ in range(amount):
self.doctors.add(Doctor(id))
id += 1
amount = int(config['ENF'][0])
for _ in range(amount):
self.nurses.add(Nurse(id))
id += 1
amount = int(config['ATD'][0])
for _ in range(amount):
self.secretaries.add(Secretary(id))
id += 1
def initialize_event_queue(self):
local_time = 0
id = 0
while local_time < self.simulation_time:
duration = get_dist_num(self.config['T']['CHE'])
exam_medicine = get_exam_medicine(self.config['P']['PRO'])
priority = get_priority(self.config['P']['PRI'])
id += 1
local_time += duration
patient = Patient(id, priority, exam_medicine)
self.add_event(self.EndOfArrival(duration, local_time, patient))
# =================================================================
# EXECUTION
# =================================================================
def start(self):
event = self.next_event()
while event.time < self.simulation_time:
event.run(self)
event = self.next_event()
self.add_event(event)
self.free_resources()
self.log.write()
def add_event(self, event):
self.event_queue.insert(event, self.count)
self.increment_count()
def next_event(self):
return self.event_queue.next()
def add_queue(self, queue, entity):
if not entity.priority:
queue.insert(entity)
queue.save_size()
else:
queue.insert(entity, self.count)
self.count += 1
entity.joined_queue = self.current_time
queue.save_size()
def rmv_queue(self, queue):
patient = queue.next()
queue.time.append(self.current_time - patient.joined_queue)
patient.joined_queue = 0
queue.save_size()
return patient
def free_resources(self):
while not self.event_queue.empty:
finalize = False
event = self.event_queue.next()
if event.time - event.duration > self.simulation_time:
finalize = True
if event.__class__ == Emergency.EndOfRegistration:
if not finalize:
event.secretary.working_time += \
(self.simulation_time - self.current_time)
self.secretaries.add(event.secretary)
elif event.__class__ in (Emergency.EndOfScreening,
Emergency.EndOfExamMedicine):
if not finalize:
event.nurse.working_time += \
(self.simulation_time - self.current_time)
self.nurses.add(event.nurse)
elif event.__class__ == Emergency.EndOfMedicalCare:
if not finalize:
event.doctor.working_time += \
(self.simulation_time - self.current_time)
self.doctors.add(event.doctor)
def increment_count(self):
self.count += 1
# =================================================================
# EVENTS
# =================================================================
class EndOfArrival():
def __init__(self, duration, time, patient):
self.duration = duration
self.time = time
self.patient = patient
def run(self, e):
e.log.insert(("EndOfArrival", self))
e.current_time = self.time
if len(e.secretaries) > 0:
secretary = e.secretaries.pop()
duration = get_dist_num(e.config['T']['CAD'])
execution_time = e.current_time + duration
e.add_event(
Emergency.EndOfRegistration(duration, execution_time,
self.patient, secretary))
else:
e.add_queue(e.registration_queue, self.patient)
class EndOfRegistration():
def __init__(self, duration, time, patient, secretary):
self.duration = duration
self.time = time
self.patient = patient
self.secretary = secretary
def run(self, e):
e.log.insert(("EndOfRegistration", self))
e.current_time = self.time
self.secretary.working_time += self.duration
if not e.registration_queue.empty:
duration = get_dist_num(e.config['T']['CAD'])
patient = e.rmv_queue(e.registration_queue)
execution_time = e.current_time + duration
e.add_event(
Emergency.EndOfRegistration(duration, execution_time,
patient, self.secretary))
else:
e.secretaries.add(self.secretary)
if (self.patient.priority == 5):
if len(e.doctors) > 0:
doctor = e.doctors.pop()
duration = get_dist_num(e.config['T']['ATE'])
execution_time = e.current_time + duration
e.add_event(
Emergency.EndOfMedicalCare(duration, execution_time,
self.patient, doctor))
else:
e.add_queue(e.medical_care_queue, self.patient)
else:
if len(e.nurses) > 0:
nurse = e.nurses.pop()
duration = get_dist_num(e.config['T']['TRI'])
execution_time = e.current_time + duration
e.add_event(
Emergency.EndOfScreening(duration, execution_time,
self.patient, nurse))
else:
e.add_queue(e.screening_queue, self.patient)
class EndOfScreening():
def __init__(self, duration, time, patient, nurse):
self.duration = duration
self.time = time
self.patient = patient
self.nurse = nurse
def run(self, e):
e.log.insert(("EndOfScreening", self))
e.current_time = self.time
self.nurse.working_time += self.duration
if not e.screening_queue.empty:
duration = get_dist_num(e.config['T']['TRI'])
execution_time = e.current_time + duration
patient = e.rmv_queue(e.screening_queue)
e.add_event(
Emergency.EndOfScreening(duration, execution_time, patient,
self.nurse))
else:
if not e.exam_medicine_queue.empty:
duration = get_dist_num(e.config['T']['EXA'])
execution_time = e.current_time + duration
patient = e.rmv_queue(e.exam_medicine_queue)
e.add_event(
Emergency.EndOfExamMedicine(duration, execution_time,
patient, self.nurse))
else:
e.nurses.add(self.nurse)
if len(e.doctors) > 0:
doctor = e.doctors.pop()
duration = get_dist_num(e.config['T']['ATE'])
execution_time = e.current_time + duration
e.add_event(
Emergency.EndOfMedicalCare(duration, execution_time,
self.patient, doctor))
else:
e.add_queue(e.medical_care_queue, self.patient)
class EndOfExamMedicine():
def __init__(self, duration, time, patient, nurse):
self.duration = duration
self.time = time
self.patient = patient
self.nurse = nurse
def run(self, e):
e.log.insert(("EndOfExamMedicine", self))
e.current_time = self.time
self.nurse.working_time += self.duration
if not e.exam_medicine_queue.empty:
duration = get_dist_num(e.config['T']['EXA'])
execution_time = e.current_time + duration
patient = e.rmv_queue(e.exam_medicine_queue)
e.add_event(
Emergency.EndOfExamMedicine(duration, execution_time,
patient, self.nurse))
else:
if not e.screening_queue.empty:
duration = get_dist_num(e.config['T']['TRI'])
execution_time = e.current_time + duration
patient = e.rmv_queue(e.screening_queue)
e.add_event(
Emergency.EndOfScreening(duration, execution_time,
patient, self.nurse))
else:
e.nurses.add(self.nurse)
class EndOfMedicalCare():
def __init__(self, duration, time, patient, doctor):
self.duration = duration
self.time = time
self.patient = patient
self.doctor = doctor
def run(self, e):
e.log.insert(("EndOfMedicalCare", self))
e.current_time = self.time
self.doctor.working_time += self.duration
if not e.medical_care_queue.empty:
patient = e.rmv_queue(e.medical_care_queue)
duration = get_dist_num(e.config['T']['ATE'])
execution_time = e.current_time + duration
e.add_event(
Emergency.EndOfMedicalCare(duration, execution_time,
patient, self.doctor))
else:
e.doctors.add(self.doctor)
if self.patient.exam_medicine:
if len(e.nurses) > 0:
duration = get_dist_num(e.config['T']['EXA'])
execution_time = e.current_time + duration
nurse = e.nurses.pop()
e.add_event(
Emergency.EndOfExamMedicine(duration, execution_time,
self.patient, nurse))
else:
e.add_queue(e.exam_medicine_queue, self.patient)
