def FrecuenciasEsperadas(tamaño_muestra, intervalos, tipoDistribucion, media,
desviacion_estandar, a, b):
'''La función calcula la frecuencia esperada para cada intervalo según el tipo de distribución elegida
Parámetros: tamaño_muestra: entero que representa la cantidad de elementos de la serie
intervalos: intervalos Dict<str, extremos> Diccionario que utiliza como clave la representacion del intervalo
tipoDistribucion: entero que representa el tipo de distribución elegida como hipótesis nula (0=uniforme, 1=exponencial, 2=normal)
media: media calculada para la serie
desviacion_estandar: desviacion estandar calculada para la serie
a: valor minimo de la serie
b: valor maximo de la serie
Return: lista con frecuencias esperadas'''
frec_esp_arr = []
if tipoDistribucion == 1:
valor_lambda = Truncate(1 / media, 7)
for i in intervalos:
intervalo = intervalos[i]
desde, hasta = intervalo[0], intervalo[1]
if tipoDistribucion == 0:
prob = ProbabilidadAcumuladaUniforme(desde, hasta, a, b)
frec_esp = round(prob * tamaño_muestra)
elif tipoDistribucion == 1:
prob = ProbabilidadAcumuladaExponencial(desde, hasta, valor_lambda)
frec_esp = Truncate(prob * tamaño_muestra, 4)
elif tipoDistribucion == 2:
marca_clase = (desde + hasta) / 2
prob = FuncionDensidadNormal(marca_clase, media,
desviacion_estandar) * (hasta - desde)
frec_esp = Truncate(prob * tamaño_muestra, 4)
frec_esp_arr.append(frec_esp)
return frec_esp_arr
def SimulacionBowling(vector_primera_bola,
vector_segunda_bola_7,
vector_segunda_bola_8,
vector_segunda_bola_9,
it,ron,
puntaje_objetivo, punt_10_prim,punt_10_seg,
mostrar_ronda_desde,mostrar_ronda_cantidad,
mostrar_iteracion_desde, mostrar_iteracion_cantidad
):
int_pr = tablas.CrearProbabilidadesAcumuladas(vector_primera_bola)
int_seg_7 = tablas.CrearProbabilidadesAcumuladas(vector_segunda_bola_7)
int_seg_8 = tablas.CrearProbabilidadesAcumuladas(vector_segunda_bola_8)
int_seg_9 = tablas.CrearProbabilidadesAcumuladas(vector_segunda_bola_9)
cant_exitos = 0
iteraciones = []
for i in range(it):
puntajeTotal = 0
ronda_datos = [str(i + 1), "Falló",None]
for j in range(ron):
puntajeRonda = 0
rand_tirada_1 = Truncate(random.uniform(0, 1.00001), 4)
cant_pinos = tablas.CalcularPinosTirada(int_pr, rand_tirada_1)
rand_tirada_2 = Truncate(random.uniform(0, 1.00001), 4)
cant_pinos_seg = 0
if(cant_pinos == 7):
cant_pinos_seg = tablas.CalcularPinosTirada(int_seg_7, rand_tirada_2, primera_tirada=False)
elif(cant_pinos == 8):
cant_pinos_seg = tablas.CalcularPinosTirada(int_seg_8, rand_tirada_2, primera_tirada=False)
elif(cant_pinos == 9):
cant_pinos_seg = tablas.CalcularPinosTirada(int_seg_9, rand_tirada_2, primera_tirada=False)
if(cant_pinos == 10):
puntajeRonda = punt_10_prim
elif((cant_pinos + cant_pinos_seg) == 10):
puntajeRonda = punt_10_seg
else:
puntajeRonda = cant_pinos + cant_pinos_seg
puntajeTotal += puntajeRonda
if j + 1 >= mostrar_ronda_desde and (j + 1) - mostrar_ronda_desde < mostrar_ronda_cantidad or (j + 1) == ron:
ronda_datos.extend([rand_tirada_1, cant_pinos, rand_tirada_2, cant_pinos_seg, puntajeRonda, puntajeTotal])
if puntajeTotal >= puntaje_objetivo:
cant_exitos += 1
if (i + 1) >= mostrar_iteracion_desde and (i + 1) - mostrar_iteracion_desde < mostrar_iteracion_cantidad or (i + 1) == it:
if puntajeTotal >= puntaje_objetivo:
ronda_datos[1] = "Éxito"
ronda_datos[2] = cant_exitos
iteraciones.append(ronda_datos)
probabilidad_exito = cant_exitos / it
return CrearDataFrame(mostrar_ronda_cantidad + 1 if ron - mostrar_ronda_desde - mostrar_ronda_cantidad == 0 else mostrar_ronda_cantidad, mostrar_ronda_desde, iteraciones, ron),probabilidad_exito
def ListaAleatoriaCongruencialMultiplicativo(n, x, k, g):
numeros_generados = []
a = 3 + 8 * k
m = 2**g
for i in range(n):
x = ((a * x) % m)
y = x / (m - 1)
numeros_generados.append(Truncate(y, 4))
return numeros_generados
def ListaAleatoriaNativa(n, inferior, superior, s=None):
if superior == 1:
superior = 1.0001
if s != 0:
random.seed(s)
#La funcion aleatoria se parametriza con el rango [0, 1.00001] para generar numeros aleatorios menores o iguales a uno
#por algunos decimales, que luego son truncados mediante la funcion
numbers_array = list(
[Truncate(random.uniform(inferior, superior), 4) for i in range(n)])
return numbers_array
def ListaAleatoriaCongruencialLineal(n, x, k, g, c):
numeros_generados = []
a = 1 + 4 * k
m = 2**g
for i in range(n):
x = (a * x + c) % m
y = x / (m - 1)
numeros_generados.append(Truncate(y, 4))
return numeros_generados
def distribucionNormal(n, mu, sigma):
return list([Truncate(random.gauss(mu, sigma), 4) for i in range(n)])
def distribucionExponencial(n, media):
valor_lambda = 1 / media
return list(
[Truncate(random.expovariate(valor_lambda), 4) for i in range(n)])
def simular(self, paso_integracion=None, probabilidades_archivos=None):
if self.tipo == TS.TP6:
if paso_integracion is None or probabilidades_archivos is None:
raise Exception(
"Los parametros no pueden ser None para el tipo de simulacion elegido..."
)
self.realizarIntegracionNumerica(paso_integracion)
self.probabilidades = CrearProbabilidadesAcumuladas(
probabilidades_archivos)
else:
self.dict_integracion_numerica = None
df_datos_fijos = pd.DataFrame(
columns=self.crearColumnasParcialesDataFrame())
df_alumnos = pd.DataFrame()
df_manten = pd.DataFrame()
inicializacion = Inicializacion()
fin_simulacion = FinSimulacion(self.x)
self.eventos.append(inicializacion)
self.eventos.append(fin_simulacion)
cantidad_iteraciones_mostradas = 0
i = 0
while self.reloj <= self.x:
i += 1
if len(self.buscarMaquinasNoMantenidas()) == 0:
self.maquina1.estado_mantenimiento = EM.NO_MANTENIDA
self.maquina2.estado_mantenimiento = EM.NO_MANTENIDA
self.maquina3.estado_mantenimiento = EM.NO_MANTENIDA
self.maquina4.estado_mantenimiento = EM.NO_MANTENIDA
self.maquina5.estado_mantenimiento = EM.NO_MANTENIDA
evento_actual = min(self.eventos, key=lambda x: x.hora)
self.eventos.remove(
evento_actual) # Elimina el evento de la fila actual
if isinstance(evento_actual, FinSimulacion):
break
if isinstance(evento_actual, Inicializacion):
self.manejarInicializacion()
if isinstance(evento_actual, LlegadaAlumno
): # Si el tipo de evento es una llegada de alumno
self.manejarLlegadaAlumno(evento_actual)
elif isinstance(
evento_actual, LlegadaMantenimiento
): # Si el tipo de evento es una llegada de mantenimiento
self.manejarLlegadaMantenimiento(evento_actual)
elif isinstance(evento_actual, FinInscripcion
): # Si el tipo de evento es un fin de inscripción
self.manejarFinInscripcion(evento_actual.maquina.cliente)
elif isinstance(
evento_actual, FinMantenimiento
): # Si el tipo de evento es un fin de mantenimiento
self.manejarFinMantenimiento(evento_actual.maquina.cliente)
vector_estado = self.crearVectorEstado(
evento_actual) # Vector de estado
print(vector_estado)
if self.reloj >= self.mostrar_desde_minuto and cantidad_iteraciones_mostradas < self.mostrar_cantidad_iteraciones and cantidad_iteraciones_mostradas <= i:
df_datos_fijos, df_alumnos, df_manten = self.agregarDatos(
df_datos_fijos, df_alumnos, df_manten, evento_actual)
cantidad_iteraciones_mostradas += 1
self.reloj = min(self.eventos).hora # Incrementar reloj
self.reloj = Truncate(self.reloj, 2)
df_datos_fijos, df_alumnos, df_manten = self.agregarDatos(
df_datos_fijos, df_alumnos, df_manten, fin_simulacion)
if self.tipo == TS.TP5:
return df_datos_fijos.join(df_alumnos).join(df_manten), \
self.maquina1.acum_cant_inscripciones, \
self.maquina2.acum_cant_inscripciones, \
self.maquina3.acum_cant_inscripciones, \
self.maquina4.acum_cant_inscripciones, \
self.maquina5.acum_cant_inscripciones, \
self.contador_alumnos_llegaron, \
self.contador_alumnos_retiran
elif self.tipo == TS.TP6 and self.dict_integracion_numerica is not None:
dataframes = {
"Simulacion": df_datos_fijos.join(df_alumnos).join(df_manten)
}
for k, v in self.dict_integracion_numerica.items():
dataframes["Euler_" + str(k) + "_archivos"] = v
return dataframes, \
self.maquina1.acum_cant_inscripciones, \
self.maquina2.acum_cant_inscripciones, \
self.maquina3.acum_cant_inscripciones, \
self.maquina4.acum_cant_inscripciones, \
self.maquina5.acum_cant_inscripciones, \
self.contador_alumnos_llegaron, \
self.contador_alumnos_retiran