def prueba_poisson(random):
gen = Generador(x=12, c=40, k=27, g=14, decimals=4, random=random)
datos = gen.poisson(lam=1, n=1000)
tabla = Poisson(datos=datos, decimals=4)
tabla.prueba_de_bondad()
print(tabla)
tabla.histogram()
def prueba_normal(random, box=True):
gen = Generador(x=12, c=40, k=27, g=14, decimals=4, random=random)
datos = gen.normal(media=0, desviacion=1, n=1000, box=box)
tabla = Normal(num_intervalos=10, datos=datos, decimals=4)
tabla.prueba_de_bondad()
print(tabla)
tabla.histogram()
def prueba_exponencial(random):
gen = Generador(x=12, c=40, k=27, g=14, decimals=4, random=random)
datos = gen.exponencial(lam=10, n=1000)
tabla = Exponencial(num_intervalos=10, datos=datos, decimals=4)
tabla.prueba_de_bondad()
print(tabla)
tabla.histogram()
def test_rnd(self):
gen = Generador(x=6, c=7, k=3, g=3)
self.assertEqual(13, gen.a)
self.assertEqual(8, gen.m)
self.assertEqual(0.625, estadistica.truncate(gen.rnd(), 4))
self.assertEqual(5, gen.x)
self.assertNotEqual(gen.rnd(), gen.rnd())
def prueba_uniforme(random):
gen = Generador(x=12, c=40, k=27, g=14, decimals=4, random=random)
datos = gen.uniforme(a=0, b=10, n=25)
tabla = Uniforme(num_intervalos=5, datos=datos, decimals=4)
# tabla.chi_uniforme()
tabla.prueba_de_bondad()
print(tabla)
tabla.histogram()
def __init__(self):
self.nombre = "Grupo"
self.generador_ocupacion = Generador(decimals=4, random=True)
self.generador_llegada = Generador(decimals=4, random=True)
self.cola = False
self.acondicionando = False
self.fin_ocupacion = 0
self.cancha = None
self.tipo = ""
self.finalizado = False
def __init__(self,
capcacidades,
desde=0,
hasta=30,
ultimas_filas=10,
decimales=4):
self.tabla = []
self.tabla_final = []
self.pos_ultimo_elemento = 0
self.generador = Generador(decimals=decimales, random=True)
self.decimales = decimales
self.cantidad_iteraciones = 1
# Inicializacion
self.numero = 0
self.evento = 'Inicializacion'
self.reloj = 0
self.set_proxima_llegada()
self.lote_actual = None
# Resultados
self.cantidad_visitas = 0
self.maximo_cola = 0
# Parametros de visualizacion
self.desde = desde
self.hasta = hasta
self.ultimas_filas = ultimas_filas
# Salas
self.sala_a = SalaNormal("A",
capacidad=capcacidades[0],
media=30,
desviacion=5)
self.sala_b = SalaNormal("B",
capacidad=capcacidades[1],
media=25,
desviacion=4)
self.sala_c = SalaUniforme("C",
capacidad=capcacidades[2],
minimo=12,
maximo=18)
self.sala_d = SalaUniforme("D",
capacidad=capcacidades[3],
minimo=14,
maximo=18)
# TP6
self.estado_servidor = 'libre'
self.porc_inestable = 0
self.tiempo_inestable = 0
self.fin_purga = 0
self.inicio_purga = 0
self.k = 20
def __init__(self):
self.generador = Generador(decimals=4, random=True)
self.grupo_actual = None
self.en_cancha = []
self.en_cola_FutbolHandball = []
self.en_colaBasquet = []
self.acondicionando = False
self.tiempo_acondicionado = 0
def __init__(self, desde=0, hasta=30, ultimas_filas=10, medias_llegada=[10, 12, 8], medias_ocupacion=[1.30, 1.33, 1.67], desviaciones_llegada=[0, 2, 2], desviaciones_ocupacion=[0.167, 0.33, 0.5]):
self.tabla = []
self.tabla_final = []
self.cantidad_iteraciones = 1
self.decimales = 4
#Paso arrays para poder config los tiempos de llegada ocup
self.medias_llegada = medias_llegada
self.medias_ocupacion = medias_ocupacion
self.desviaciones_llegada = desviaciones_llegada
self.desviaciones_ocupacion = desviaciones_ocupacion
self.generadorFutbol = Generador(decimals=4, random=True)
self.generadorHandball = Generador(decimals=4, random=True)
self.generadorBasquet = Generador(decimals=4, random=True)
self.numero = 0
self.evento = "Inicializacion"
self.reloj = 0
self.desde = desde
self.hasta = hasta
self.ultimas_filas = ultimas_filas
self.cancha = Cancha()
self.acondicionando = False
#En_todo momento van a haber 3 grupos concurrentes cada uno con su tiempo de ocupacion
self.grupo_actual = None
self.grupo_actual_futbol = GrupoFutbol(media=self.medias_ocupacion[0], desviacion=self.desviaciones_ocupacion[0])
self.grupo_actual_handball = GrupoHandball(media=self.medias_ocupacion[1], desviacion=self.desviaciones_ocupacion[1])
self.grupo_actual_basquet = GrupoBasquet(media=self.medias_ocupacion[2], desviacion=self.desviaciones_ocupacion[2])
self.grupos_futbol = []
self.grupos_handball = []
self.grupos_basquet = []
#Determino las primeras llegadas de cada grupo
self.proxima_llegada_futbol = self.generadorFutbol.exponencial_next(media=self.medias_llegada[0])
self.proxima_llegada_handball = self.generadorHandball.box_muller_next(media=self.medias_llegada[1], desviacion=self.desviaciones_llegada[1])
self.proxima_llegada_basquet = self.generadorHandball.box_muller_next(media=self.medias_llegada[2], desviacion=self.desviaciones_llegada[2])
""""#Las meto en un array y lo ordeno cada vez que se modifica un valor
self.proximas_llegadas = []
self.proximas_llegadas.append(self.proxima_llegada_futbol)
self.proximas_llegadas.append(self.proxima_llegada_handball)
self.proximas_llegadas.append(self.proxima_llegada_basquet)
self.ordenar_llegadas()"""
#Determino cual es la prox llegada
self.set_proxima_llegada()
def test_truncate(self):
gen = Generador(decimals=5)
self.assertEqual(gen.truncate(0.1234567), 0.12345)
gen.decimals = 2
self.assertEqual(gen.truncate(0.1234567), 0.12)
class Iteracion:
def __init__(self, desde=0, hasta=30, ultimas_filas=10, medias_llegada=[10, 12, 8], medias_ocupacion=[1.30, 1.33, 1.67], desviaciones_llegada=[0, 2, 2], desviaciones_ocupacion=[0.167, 0.33, 0.5]):
self.tabla = []
self.tabla_final = []
self.cantidad_iteraciones = 1
self.decimales = 4
#Paso arrays para poder config los tiempos de llegada ocup
self.medias_llegada = medias_llegada
self.medias_ocupacion = medias_ocupacion
self.desviaciones_llegada = desviaciones_llegada
self.desviaciones_ocupacion = desviaciones_ocupacion
self.generadorFutbol = Generador(decimals=4, random=True)
self.generadorHandball = Generador(decimals=4, random=True)
self.generadorBasquet = Generador(decimals=4, random=True)
self.numero = 0
self.evento = "Inicializacion"
self.reloj = 0
self.desde = desde
self.hasta = hasta
self.ultimas_filas = ultimas_filas
self.cancha = Cancha()
self.acondicionando = False
#En_todo momento van a haber 3 grupos concurrentes cada uno con su tiempo de ocupacion
self.grupo_actual = None
self.grupo_actual_futbol = GrupoFutbol(media=self.medias_ocupacion[0], desviacion=self.desviaciones_ocupacion[0])
self.grupo_actual_handball = GrupoHandball(media=self.medias_ocupacion[1], desviacion=self.desviaciones_ocupacion[1])
self.grupo_actual_basquet = GrupoBasquet(media=self.medias_ocupacion[2], desviacion=self.desviaciones_ocupacion[2])
self.grupos_futbol = []
self.grupos_handball = []
self.grupos_basquet = []
#Determino las primeras llegadas de cada grupo
self.proxima_llegada_futbol = self.generadorFutbol.exponencial_next(media=self.medias_llegada[0])
self.proxima_llegada_handball = self.generadorHandball.box_muller_next(media=self.medias_llegada[1], desviacion=self.desviaciones_llegada[1])
self.proxima_llegada_basquet = self.generadorHandball.box_muller_next(media=self.medias_llegada[2], desviacion=self.desviaciones_llegada[2])
""""#Las meto en un array y lo ordeno cada vez que se modifica un valor
self.proximas_llegadas = []
self.proximas_llegadas.append(self.proxima_llegada_futbol)
self.proximas_llegadas.append(self.proxima_llegada_handball)
self.proximas_llegadas.append(self.proxima_llegada_basquet)
self.ordenar_llegadas()"""
#Determino cual es la prox llegada
self.set_proxima_llegada()
#No entiendo como funciona este diccionario
def __str__(self):
dic = self.as_dict
dic.pop('cancha')
dic.pop('grupos')
cancha = self.as_dict['cancha']
grupos = self.as_dict['grupos']
grupos = '\t' + '\n\t'.join([str(grupo) for grupo in grupos])
return f"{dic}\n{cancha}\n{grupos}\n"
#Este tampoco
def print_tabla(self, tabla):
print("Tabla")
for linea in tabla:
dic = linea.copy()
cancha = dic.pop('cancha')
grupos = dic.pop('grupos')
grupos = '\t' + '\n\t'.join([str(grupo) for grupo in grupos.items()])
print(f"{dic}\n{cancha}\n{grupos}")
print("-" * 20)
def show_evento(self):
if self.evento == "fin_ocupacion" or self.evento == "llegada":
if self.grupo_actual:
return self.evento + '_' + str(self.grupo_actual.nombre)
return self.evento
# Devuelve un diccionario con los valores actuales del objeto
@property
def as_dict(self):
# Creo un diccionario con todos los atributos del objeto
dic = {
'numero': self.numero,
'evento': self.show_evento(),
'reloj': round(self.reloj, self.decimales),
'proxima_llegada': self.proxima_llegada,
'prox llegada futbol': self.proxima_llegada_futbol,
'prox llegada handball': self.proxima_llegada_handball,
'prox llegada basquet': self.proxima_llegada_basquet,
#Cancha
'cancha': self.cancha.as_dict(),
'grupos': {grupo.numero : grupo.as_dict() for grupo in self.get_grupos()}
}
return dic
#Igual que en otros TPs
def guardar_iteracion(self):
"Guarda el estado de una iteracion"
if self.desde <= self.numero <= self.hasta:
self.tabla.append(self.as_dict)
else:
self.tabla_final.append(self.as_dict)
if len(self.tabla_final) > self.ultimas_filas:
self.tabla_final.pop(0)
# Actualizo el proximo elemnto a reemplazar cuidando de que se mantenga en el rango de las ultimas filas
# self.pos_ultimo_elemento = (self.pos_ultimo_elemento + 1) % self.ultimas_filas
def get_grupos_full(self):
return self.get_grupos_futbol() + self.get_grupos_handball() + self.get_grupos_basquet()
def get_grupos(self):
return self.get_grupos_en_sala() + self.get_grupos_en_cola_futbolhandball() + self.get_grupos_en_cola_basquet()
def get_grupos_en_sala(self):
return self.cancha.en_cancha
def get_grupos_en_cola_futbolhandball(self):
return self.cancha.en_cola_FutbolHandball
def get_grupos_en_cola_basquet(self):
return self.cancha.en_colaBasquet
def get_grupos_futbol(self):
return self.grupos_futbol
def get_grupos_handball(self):
return self.grupos_handball
def get_grupos_basquet(self):
return self.grupos_basquet
def ordenar_tabla_final(self):
"Ordena la tabla final"
self.tabla_final = self.tabla_final[self.pos_ultimo_elemento:] + self.tabla_final[:self.pos_ultimo_elemento]
def set_proxima_llegada(self):
self.proxima_llegada = min(self.proxima_llegada_futbol, self.proxima_llegada_handball, self.proxima_llegada_basquet)
def add_proxima_llegada(self, grupo_proximo):
if grupo_proximo.tipo == "Futbol":
self.grupo_actual_futbol = GrupoFutbol(media=self.medias_ocupacion[0],desviacion=self.desviaciones_ocupacion[0])
self.grupos_futbol.append(self.grupo_actual_futbol)
self.proxima_llegada_futbol = round(self.reloj + self.generadorFutbol.box_muller_next(media=self.medias_llegada[0]), 4)
elif grupo_proximo.tipo == "Handball":
self.grupo_actual_handball = GrupoHandball(media=self.medias_ocupacion[1],desviacion=self.desviaciones_ocupacion[1])
self.grupos_handball.append(self.grupo_actual_handball)
self.proxima_llegada_handball = round(self.reloj + self.generadorHandball.box_muller_next(media=self.medias_llegada[1],desviacion=self.desviaciones_llegada[1]), 4)
else:
self.grupo_actual_basquet = GrupoBasquet(media=self.medias_ocupacion[2],desviacion=self.desviaciones_ocupacion[2])
self.grupos_basquet.append(self.grupo_actual_basquet)
self.proxima_llegada_basquet = round(self.reloj + self.generadorBasquet.box_muller_next(media=self.medias_llegada[2],desviacion=self.desviaciones_llegada[2]), 4)
self.set_proxima_llegada()
""""#Ordenar array de llegadas para ver cual es la siguiente
def ordenar_llegadas(self):
proxima_llegada = self.proximas_llegadas[0]
for llegada in self.proximas_llegadas[1:3]:
if llegada < proxima_llegada:
proxima_llegada = llegada
return proxima_llegada
"""
#Determina cual es el siguiente evento (falta acondicionamiento)
def proximo_evento(self):
grupo_proximo = self.grupo_actual
if grupo_proximo:
if self.cancha.acondicionando and self.cancha.tiempo_acondicionado < self.proxima_llegada:
self.acondicionando = False
self.evento = "fin_acondicionamiento"
self.reloj = round( self.reloj + self.cancha.tiempo_acondicionado, 4)
elif self.proxima_llegada < grupo_proximo.fin_ocupacion or self.grupo_actual.finalizado:
self.evento = "llegada"
self.reloj = self.proxima_llegada
else:
self.evento = "fin_ocupacion"
#self.evento = self.show_evento()
self.reloj = grupo_proximo.fin_ocupacion
else:
self.evento = "llegada"
self.reloj = self.proxima_llegada
#Diferenciar entre llegada de 3 grupos
def llegada(self):
if self.proxima_llegada_futbol == self.proxima_llegada:
grupo_proximo = self.grupo_actual_futbol
elif self.proxima_llegada_handball == self.proxima_llegada:
grupo_proximo = self.grupo_actual_handball
else:
grupo_proximo = self.grupo_actual_basquet
if not self.grupo_actual:
self.grupo_actual = grupo_proximo
self.cancha.agregar_grupo(grupo_proximo, self.reloj)
#self.reloj = round(self.reloj + self.cancha.tiempo_acondicionado, 4)
self.acondicionando = self.cancha.acondicionando
self.add_proxima_llegada(grupo_proximo)
self.guardar_iteracion()
def fin_acondicionamiento(self):
self.cancha.agregar_grupo(self.grupo_actual, self.reloj)
#self.reloj = self.grupo_actual.fin_ocupacion
self.guardar_iteracion()
def fin_ocupacion(self):
self.cancha.agregar_grupo(self.grupo_actual, self.reloj)
self.grupo_actual = None
self.guardar_iteracion()
if len(self.cancha.en_cancha) > 0 :
self.reloj = self.cancha.en_cancha[0].fin_ocupacion
else:
self.reloj = self.proxima_llegada
def calcular_iteracion(self, tiempo):
while True:
self.numero += 1
self.proximo_evento()
if self.reloj > tiempo:
break
if self.evento == "llegada":
self.llegada()
elif self.evento == "fin_ocupacion":
#elif self.fin_ocupacion:
self.fin_ocupacion()
elif self.evento == "fin_acondicionamiento":
self.fin_acondicionamiento()
else:
raise Exception("Evento inexistente")
class Iteracion:
def __init__(self,
capcacidades,
desde=0,
hasta=30,
ultimas_filas=10,
decimales=4):
self.tabla = []
self.tabla_final = []
self.pos_ultimo_elemento = 0
self.generador = Generador(decimals=decimales, random=True)
self.decimales = decimales
self.cantidad_iteraciones = 1
# Inicializacion
self.numero = 0
self.evento = 'Inicializacion'
self.reloj = 0
self.set_proxima_llegada()
self.lote_actual = None
# Resultados
self.cantidad_visitas = 0
self.maximo_cola = 0
# Parametros de visualizacion
self.desde = desde
self.hasta = hasta
self.ultimas_filas = ultimas_filas
# Salas
self.sala_a = SalaNormal("A",
capacidad=capcacidades[0],
media=30,
desviacion=5)
self.sala_b = SalaNormal("B",
capacidad=capcacidades[1],
media=25,
desviacion=4)
self.sala_c = SalaUniforme("C",
capacidad=capcacidades[2],
minimo=12,
maximo=18)
self.sala_d = SalaUniforme("D",
capacidad=capcacidades[3],
minimo=14,
maximo=18)
# TP6
self.estado_servidor = 'libre'
self.porc_inestable = 0
self.tiempo_inestable = 0
self.fin_purga = 0
self.inicio_purga = 0
self.k = 20
def __str__(self):
dic = self.as_dict
dic.pop('salas')
dic.pop('lotes')
salas = self.as_dict['salas']
lotes = self.as_dict['lotes']
lotes = '\t' + '\n\t'.join([lote for lote in lotes])
return f"{dic}\n{salas}\n{lotes}\n"
def print_tabla(self, tabla):
print("Tabla")
for linea in tabla:
dic = linea.copy()
salas = dic.pop('salas')
lotes = dic.pop('lotes')
lotes = '\t' + '\n\t'.join([str(lote) for lote in lotes.items()])
print(f"{dic}\n{salas}\n{lotes}")
print("-" * 20)
def show_evento(self):
if self.evento == "fin_recorrido" or self.evento == "llegada":
return self.evento + '(' + str(self.lote_actual.numero) + ')'
return self.evento
# Devuelve un diccionario con los valores actuales del objeto
@property
def as_dict(self):
# Creo un diccionario con todos los atributos del objeto
dic = {
'numero': self.numero,
'evento': self.show_evento(),
'reloj': round(self.reloj, self.decimales),
'proxima_llegada': self.proxima_llegada,
# 'lote_actual': self.lote_actual,
'cantidad_visitas': self.cantidad_visitas,
'maximo_cola': self.maximo_cola,
# Bloqueo
'estado_servidor': self.estado_servidor,
'porcentaje_inestable': self.porc_inestable,
'inestable': self.tiempo_inestable,
'inicio_purga': self.inicio_purga,
'fin_purga': self.fin_purga,
# Salas
'salas': {
'sala_a': self.sala_a.as_dict(),
'sala_b': self.sala_b.as_dict(),
'sala_c': self.sala_c.as_dict(),
'sala_d': self.sala_d.as_dict(),
},
'lotes':
{lote.numero: lote.as_dict()
for lote in self.get_lotes()}
}
return dic
def guardar_iteracion(self):
"Guarda el estado de una iteracion"
if self.desde <= self.numero <= self.hasta:
self.tabla.append(self.as_dict)
else:
self.tabla_final.append(self.as_dict)
if len(self.tabla_final) > self.ultimas_filas:
self.tabla_final.pop(0)
# Actualizo el proximo elemnto a reemplazar cuidando de que se mantenga en el rango de las ultimas filas
# self.pos_ultimo_elemento = (self.pos_ultimo_elemento + 1) % self.ultimas_filas
def ordenar_tabla_final(self):
"Ordena la tabla final"
self.tabla_final = self.tabla_final[
self.pos_ultimo_elemento:] + self.tabla_final[:self.
pos_ultimo_elemento]
def set_proxima_llegada(self):
self.rnd_proxima_llegada = self.generador.exponencial_next(lam=1 / 5)
self.proxima_llegada = round(self.reloj + self.rnd_proxima_llegada,
self.decimales)
return self.proxima_llegada
def get_lotes(self):
"""Obtiene todos los lotes activos en un sistema"""
return self.get_lotes_en_sala() + self.get_lotes_en_cola()
def get_lotes_en_sala(self):
"""Devuelve una lista con los lotes en sala de todas las salas"""
return self.sala_a.en_sala + self.sala_b.en_sala + self.sala_c.en_sala + self.sala_d.en_sala
def get_lotes_en_cola(self):
"""Devuelve una lista con los lotes en sala de todas las colas"""
return self.sala_a.en_cola + self.sala_b.en_cola + self.sala_c.en_cola + self.sala_d.en_cola
#ESTADISTICAS
def get_numero_lotes_encolados(self):
colaA = self.sala_a.contador_cola
colaB = self.sala_b.contador_cola
colaC = self.sala_c.contador_cola
colaD = self.sala_d.contador_cola
return colaA, colaB, colaC, colaD
def get_numero_lotes(self):
lotesA = self.sala_a.contador_lotes
lotesB = self.sala_b.contador_lotes
lotesC = self.sala_c.contador_lotes
lotesD = self.sala_d.contador_lotes
return lotesA, lotesB, lotesC, lotesD
def get_numero_lotes_sala(self):
lotesA_sala = self.sala_a.contador_sala
lotesB_sala = self.sala_b.contador_sala
lotesC_sala = self.sala_c.contador_sala
lotesD_sala = self.sala_d.contador_sala
return lotesA_sala, lotesB_sala, lotesC_sala, lotesD_sala
def calcular_porcentaje_lotes_cola(self):
lotesA, lotesB, lotesC, lotesD = self.get_numero_lotes()
colasA, colasB, colasC, colasD = self.get_numero_lotes_encolados()
if lotesA == 0:
porcentajeA = 0
else:
porcentajeA = self.generador.truncate((colasA * 100) / lotesA, 2)
if lotesB == 0:
porcentajeB = 0
else:
porcentajeB = self.generador.truncate((colasB * 100) / lotesB, 2)
if lotesC == 0:
porcentajeC = 0
else:
porcentajeC = self.generador.truncate((colasC * 100) / lotesC, 2)
if lotesD == 0:
porcentajeD = 0
else:
porcentajeD = self.generador.truncate((colasD * 100) / lotesD, 2)
return porcentajeA, porcentajeB, porcentajeC, porcentajeD
def get_tiempo_medio_recorrido(self):
tiempoA = self.sala_a.tiempo_recorrido_medio
tiempoB = self.sala_b.tiempo_recorrido_medio
tiempoC = self.sala_c.tiempo_recorrido_medio
tiempoD = self.sala_d.tiempo_recorrido_medio
if self.sala_a.contador_lotes == 0:
mediaA = 0
else:
mediaA = tiempoA / self.sala_a.contador_sala
if self.sala_b.contador_lotes == 0:
mediaB = 0
else:
mediaB = tiempoB / self.sala_b.contador_sala
if self.sala_c.contador_lotes == 0:
mediaC = 0
else:
mediaC = tiempoC / self.sala_c.contador_sala
if self.sala_d.contador_lotes == 0:
mediaD = 0
else:
mediaD = tiempoD / self.sala_d.contador_sala
return mediaA, mediaB, mediaC, mediaD
def get_tiempo_espera_cola(self):
tiempoA = self.sala_a.tiempo_espera_medio
tiempoB = self.sala_b.tiempo_espera_medio
tiempoC = self.sala_c.tiempo_espera_medio
tiempoD = self.sala_d.tiempo_espera_medio
if self.sala_a.contador_cola_a_sala == 0:
mediaA = 0
else:
mediaA = self.generador.truncate(
tiempoA / self.sala_a.contador_cola_a_sala, 2)
if self.sala_b.contador_cola_a_sala == 0:
mediaB = 0
else:
mediaB = self.generador.truncate(
tiempoB / self.sala_b.contador_cola_a_sala, 2)
if self.sala_c.contador_cola_a_sala == 0:
mediaC = 0
else:
mediaC = self.generador.truncate(
tiempoC / self.sala_c.contador_cola_a_sala, 2)
if self.sala_d.contador_cola_a_sala == 0:
mediaD = 0
else:
mediaD = self.generador.truncate(
tiempoD / self.sala_d.contador_cola_a_sala, 2)
return mediaA, mediaB, mediaC, mediaD
def get_visitantes_por_sala(self):
visitantesA = self.sala_a.contador_visitantes
visitantesB = self.sala_b.contador_visitantes
visitantesC = self.sala_c.contador_visitantes
visitantesD = self.sala_d.contador_visitantes
return visitantesA, visitantesB, visitantesC, visitantesD
# Proximos eventos
def proximo_lote(self):
"""Devuelve el proximo lote que finalizara el recorrido"""
# Elimino los lotes bloqueados
lotes = [
lote for lote in self.get_lotes_en_sala() if not lote.bloqueado
]
if len(lotes) > 0:
lote_proximo = lotes[0]
for lote in lotes[1:]:
if lote.fin_recorrido < lote_proximo.fin_recorrido:
lote_proximo = lote
return lote_proximo
else:
return None
def proximo_evento(self):
lote_proximo = self.proximo_lote()
if lote_proximo:
# Bloquear servidor
if 0 < self.inicio_purga < self.proxima_llegada and self.inicio_purga < lote_proximo.fin_recorrido \
and self.estado_servidor != 'bloqueado':
self.estado_servidor = 'bloqueado'
self.evento = "bloqueo"
self.reloj = self.inicio_purga
# Desbloquear servidor
elif 0 < self.fin_purga <= self.proxima_llegada and self.fin_purga <= lote_proximo.fin_recorrido \
and self.estado_servidor != 'libre':
self.estado_servidor = 'libre'
self.evento = "desbloqueo"
self.reloj = self.fin_purga
# Llegada
elif self.proxima_llegada < lote_proximo.fin_recorrido and self.estado_servidor != 'bloqueado':
self.evento = "llegada"
self.reloj = self.proxima_llegada
# Fin de recorrido
else:
self.evento = "fin_recorrido"
self.lote_actual = lote_proximo
self.reloj = lote_proximo.fin_recorrido
else:
self.evento = "llegada"
self.reloj = self.proxima_llegada
# todo no se tendria que registrar el tiempo de proxima llegada
# Eventos
def llegada(self):
"""Setea los campos para el caso de una llegada nueva"""
# Se agrega el lote a la sala C, se calculan todos los atributos
# necesarios incluyendo el fin de recorrido si correspondiera
self.lote_actual = Lote(self.sala_a, self.sala_b, self.sala_c,
self.sala_d)
self.sala_c.add_lote(self.lote_actual, self.reloj)
# Se actualiza la cantidad total de visitas
self.cantidad_visitas += self.lote_actual.visitantes
# Se calcula la proxima llegada
self.set_proxima_llegada()
acu = 0
for i in range(len(self.sala_c.en_cola)):
acu += self.sala_c.en_cola[i].visitantes
if acu > self.maximo_cola:
self.maximo_cola = acu
self.guardar_iteracion()
def fin_recorrido_sala(self):
lote = self.lote_actual
sala = lote.sala_actual
lote_en_cola = None
# Verifica si el lote se encuente en la ultima sala del recorrido
if lote.ultima_sala():
# Acciones si un lote llega al final del recorrido
lote.fin_recorrido = '-'
# Actualizo la cantidad total de visitas
#self.cantidad_visitas += lote.visitantes
# Se verifica si la sala tenia algun lote en cola y este puede entrar en la sala
for i in range(len(sala.en_cola)):
if sala.puede_entrar_a_sala_desde_cola():
lote_en_cola = sala.en_cola[0]
self.entrar_a_sala_desde_cola(sala, lote_en_cola)
sala.en_cola.pop(0)
# Guardo la iteracion despues de haber cambiado al lote a su nueva sala
# Guarda la iteracion con todos los cambios realizados
self.guardar_iteracion()
# Elimino el lote anterior
lote.sala_actual.salir_de_sala(lote)
# El lote no se encuentra en la ultima sala
else:
# Me salgo de la sala actual
lote.sala_actual.salir_de_sala(lote)
# Paso a la proxima sala
lote.proxima_sala()
# Asigno el lote a la proxima sala
lote.sala_actual.add_lote(lote, self.reloj)
# Se verifica si la sala tenia algun lote en cola y este puede entrar en la sala
for i in range(len(sala.en_cola)):
if sala.puede_entrar_a_sala_desde_cola():
lote_en_cola = sala.en_cola[0]
self.entrar_a_sala_desde_cola(sala, lote_en_cola)
sala.en_cola.pop(0)
# Guardo la iteracion despues de haber cambiado al lote a su nueva sala
# Guarda la iteracion con todos los cambios realizados
self.guardar_iteracion()
def entrar_a_sala_desde_cola(self, sala, lote):
"""Se ingresa un objeto desde la cola hasta sus sala calculando su fin de recorrido"""
# Esta funcion cuenta como una iteracion adicional en caso de que pueda ingresar un lote a la sala
# No se si corresponde sumar una iteracion
sala.en_sala.append(lote)
# Hago la diferencia del momento en el que entro en la cola y el momento que lo agrregamos a la sala
lote.tiempo_espera_cola = self.reloj - lote.tiempo_espera_cola
sala.tiempo_espera_medio += lote.tiempo_espera_cola
#sala.contador_cola += 1
sala.contador_cola_a_sala += 1
lote.cola = False
sala.contador_visitantes += lote.visitantes
lote.set_fin_recorrido(self.reloj)
def bloquear_servidor(self):
"""Se marca el servidor como bloqueado. se guardan las llegadas en una nueva cola para procesarlas cuando
se libere el servidor"""
self.estado_servidor = 'bloqueado'
# Obtengo los lotes de la sala c
lotes = self.sala_c.en_sala + self.sala_c.en_cola
for lote in lotes:
lote.bloquear_recorrido(self.reloj)
# Se ajusta la proxima llegada
self.proxima_llegada = round(
self.fin_purga + (self.proxima_llegada - self.reloj), 4)
self.guardar_iteracion()
def desbloquear_servidor(self):
"""Se marca el servidor como desbloqueado y se procesan todas las salidas anteriores a este tiempo"""
self.estado_servidor = 'libre'
lotes = self.sala_c.en_sala + self.sala_c.en_cola
for lote in lotes:
lote.desbloquear_recorrido(self.reloj)
self.set_inestable()
self.guardar_iteracion()
def set_inestable(self):
rnd = self.generador.rnd()
if rnd < .5:
self.porc_inestable = 100
self.tiempo_inestable = 250
elif rnd < .8:
self.porc_inestable = 70
self.tiempo_inestable = 220.2347
else:
self.porc_inestable = 50
self.tiempo_inestable = 192.1554
self.inicio_purga = round(self.tiempo_inestable + self.reloj, 4)
self.fin_purga = round(self.inicio_purga + self.k, 4)
def calcular_iteracion(self, tiempo):
"""Metodo que realiza el calculo completo tomando los datos de la iteracion anterior"""
# Setear bloqueo del servidor
self.set_inestable()
while True:
self.numero += 1
self.proximo_evento()
if self.reloj >= tiempo:
break
if self.evento == "llegada":
self.llegada()
elif self.evento == "fin_recorrido":
self.fin_recorrido_sala()
elif self.evento == 'bloqueo':
self.bloquear_servidor()
elif self.evento == 'desbloqueo':
self.desbloquear_servidor()
else:
raise Exception("Evento inexistente")
# Mostrar los lotes de un intervalo en una matriz
def get_matrix(self, tabla):
lotes = set()
# Obtengo los numeros de todos los lotes en todas las iteraciones y elimino los duplicados
for linea in tabla:
lotes.update(list(linea["lotes"].keys()))
lotes = list(lotes)
# Creo una matriz llena de diccionarios vacios
# matriz = [[None] * numero_columnas] * numero_filas
# {'numero': '', 'estado': '', 'visitantes': '', 'recorrido': '' , 'fin_recorrido': ''}
matriz = [[{
'numero': '',
'estado': '',
'visitantes': '',
'recorrido': '',
'fin_recorrido': ''
}] * len(lotes) for i in range(len(tabla))]
for i in range(len(tabla)):
linea = tabla[i]
# print(i, list)
for j in range(len(lotes)):
numero = lotes[j]
# print("Lineas:", list(linea['lotes'].keys()))
# print("Numeros:", numero)
# print("en: ", numero in list(linea['lotes'].keys()))
# Si el lote existe en esta linea
if numero in list(linea['lotes'].keys()):
matriz[i][j] = linea['lotes'][numero]
# print(linea['lotes'][numero])
# Agrego los lotes a la tabla
for i in range(len(tabla)):
tabla[i]['lotes_arreglados'] = matriz[i]
return tabla, lotes
# Ver tabla
# for i in range(len(tabla)):
# for j in range(len(lotes)):
# print(matriz[i][j], end="\n\t")
# print()
# print("-" * 20)
#
# Ver que matrices se registraron en cada fila
# for i in range(len(tabla)):
# for j in range(len(lotes)):
# print(matriz[i][j]["numero"], end=" | ")
# print()
# print("-" * 20)
def limpiar_salas(self):
"""Limpia todas las salas para una nueva simulacion"""
self.sala_a.limpiar_sala()
self.sala_b.limpiar_sala()
self.sala_c.limpiar_sala()
self.sala_d.limpiar_sala()
Lote.resetear_lote()
from generador_pseudoaliatorio.generador import Generador
generador = Generador(decimals=4, random=True)
class Lote:
nro = 0
instances = set()
@classmethod
def get_nro(cls):
"""Devuelve para cada nuevo objeto un valor unico"""
cls.nro += 1
return cls.nro
# @classmethod
# def fin_recorrido_proximo(cls):
# lotes = cls.
#
# @classmethod
# def get_instances(cls):
# dead = set()
# for ref in cls.instances:
# obj = ref()
# if obj is not None:
# yield obj
# else:
# dead.add(ref)
# cls.instances -= dead
def __init__(self, sala_a, sala_b, sala_c, sala_d):