def do_test(self, lim_inf, lim_sup, _type, intervals):
interval_size = truncate((lim_sup - lim_inf) / intervals, self.accuracy)
ac = 0.0
if _type != 3:
for i in range(intervals):
self.freq_observ[i] = 0
k = truncate(lim_inf + interval_size * i, self.accuracy)
k_prox = truncate(k + interval_size, self.accuracy)
if _type != 3:
self.labels.append((k, k_prox))
else:
self.labels.append((i, i))
for i in self.data:
k = int((i - lim_inf) // interval_size)
if k == intervals:
self.freq_observ[k-1] += 1
else:
self.freq_observ[k] += 1
else:
self.freq_observ = Counter(self.data)
self.freq_observ.most_common()
self.freq_observ = sorted(self.freq_observ.items())
for i in self.freq_observ:
self.labels.append((i, i))
self.freq_esperadas = self.get_frecuencia_esperada(_type, self.labels)
# self.agrupar_freq_esperadas()
for i in self.freq_observ:
if _type != 3:
freq_esp = self.freq_esperadas[i]
freq_obs = self.freq_observ[i]
else:
freq_esp = self.freq_esperadas[int(i[0])]
freq_obs = self.freq_observ[int(i[0])][1]
if freq_esp == 0:
freq_esp = 1
chi_2 = truncate(
(pow(freq_obs - freq_esp, 2)) / freq_esp,
self.accuracy
)
self.chi_2.append(chi_2)
ac += chi_2
self.chi_2_ac.append(ac)
def do_test(self):
percentil = 1 / self.subintervals
freq_esperada = self.n / self.subintervals
# creo archivo si no existe, borro lo que ya estaba
csv_filename = 'exports/data.csv'
f = open(csv_filename, 'w+')
f.close()
for i in range(self.subintervals):
key_interval = truncate(percentil * i, self.accuracy)
label_interval = str(key_interval) + ' - ' + str(
truncate(key_interval + percentil, self.accuracy))
self.labels.append((key_interval, label_interval))
self.freq_esperadas[key_interval] = freq_esperada
self.freq_observ[key_interval] = 0
write_csv = []
for i in self.data:
key = truncate(percentil * int(i[1] / percentil), self.accuracy)
if int(key) == 1:
self.freq_observ[truncate(1 - percentil, self.accuracy)] += 1
else:
self.freq_observ[key] += 1
# guardo la serie en un csv cada 1000 registros
write_csv.append(i[1])
if len(write_csv) == 1000:
with open(csv_filename, 'a') as csvfile:
writer = csv.writer(csvfile)
writer.writerows(map(lambda x: [x], write_csv))
write_csv.clear()
# agrego los que faltaron, si no llego a 1000 registros
if len(write_csv) > 0:
with open(csv_filename, 'a') as csvfile:
writer = csv.writer(csvfile)
writer.writerows(map(lambda x: [x], write_csv))
write_csv.clear()
ac = 0.0
for i in self.freq_observ:
chi_2 = truncate(
(pow(self.freq_observ[i] - self.freq_esperadas[i], 2)) /
self.freq_esperadas[i], self.accuracy)
self.chi_2.append(chi_2)
ac += chi_2
self.chi_2_ac.append(ac)
def get_frecuencia_esperada(self, serie, intervalos):
listaFrecuenciaEsperada = []
lambdaa = truncate((1 / self.calcularMedia(serie)), 9)
for i in range(0, len(intervalos)):
marcaClase = truncate(((intervalos[i][0] + intervalos[i][1]) / 2),
1)
# probEsperadaConMarcaClase = truncate(lambdaa * math.exp(-lambdaa*marcaClase) * (intervalos[i][1] - intervalos[i][0]),4)
probEsperadaConMarcaClaseAcum = truncate(
(1 - math.exp(-lambdaa * intervalos[i][1])) -
(1 - math.exp(-lambdaa * intervalos[i][0])), 4)
frecuenciaEsperada = truncate(
(len(serie) * probEsperadaConMarcaClaseAcum), 4)
listaFrecuenciaEsperada.append(frecuenciaEsperada)
return listaFrecuenciaEsperada
def get_frecuencia_esperada(self, serieEntera, intervalo):
# eliminamos las repeticiones de la serie, pero sigue desordenada e incompleta
serieSinRepeticiones = set(serieEntera)
# la serie final es la que ya esta ordenada, completa y sin repeticiones
serieFinal = self.ordenarYcompletarSerie(serieSinRepeticiones)
lambdaa = self.calcularLambda(serieEntera)
listaFrecuenciaEsperadaPoisson = []
for i in range(0, len(serieFinal)):
probabilidad = truncate(
(((lambdaa**(serieFinal[i])) * math.exp(-lambdaa)) /
math.factorial(serieFinal[i])), 4)
frecuenciaEsperadaPoission = round(len(serieEntera) * probabilidad)
listaFrecuenciaEsperadaPoisson.append(frecuenciaEsperadaPoission)
return listaFrecuenciaEsperadaPoisson
def get_frecuencia_esperada(self, serie, intervalos):
listaFrecuenciaEsperadaNormal = []
media = self.calcularMedia(serie)
desviacionEstandar = self.calcularDevEstandar(serie)
for i in range(0, len(intervalos)):
marcaClase = truncate(((intervalos[i][0] + intervalos[i][1]) / 2),
1)
probabilidad = ((math.exp(-0.5 * (
(marcaClase - media) / desviacionEstandar)**2)) /
(desviacionEstandar * math.sqrt(2 * math.pi))) * (
intervalos[i][1] - intervalos[i][0])
frecuenciaEsperadaNormal = len(serie) * probabilidad
listaFrecuenciaEsperadaNormal.append(frecuenciaEsperadaNormal)
return listaFrecuenciaEsperadaNormal
# print(frecuenciaEsperadaNormal(serie,intervalos))
def get_random(self):
# formula metodo congruencial mixto
x1 = ((self.a * self.xo) + self.c) % self.m
self.set_xo(x1)
return truncate((x1 / (self.m - 1)), self.ACCURACY)
def get_random(self):
# formula metodo congruencial multiplicativo
x1 = (self.a * self.xo) % self.m
self.set_xo(x1)
return truncate((x1 / (self.m - 1)), self.ACCURACY)
def get_random_numbers_python(n):
# random.random() es la funcion random de python
for i in range(n):
yield i + 1, truncate(random.random(), ACCURACY)