def test_FCFS(self):
"""Prototype for Master.py"""
stat = Statistics()
simulator = SimulatorLCFS(0.4)
simulator.transient_phase()
res = simulator.simulate_LCFS(1_000_000)
mean_w = stat.calculate_mean(res[0])
var_w = stat.calculate_variance(res[0], mean_w)
mean_nq = stat.calculate_mean(res[1])
mean_nq2 = sum(res[1]) / res[2]
var_nq = stat.calculate_variance(res[1], mean_nq)
var_nq2 = stat.calculate_variance(res[1], mean_nq2)
center_ew, lower_ew, upper_ew, precision_ew = stat.confidence_interval_for_mean(
mean_w, var_w, len(res[0]), 0.95)
center_vw, lower_vw, upper_vw, precision_vw = stat.confidence_interval_for_variance(
var_w, len(res[0]), 0.95)
center_enq, lower_enq, upper_enq, precision_enq = stat.confidence_interval_for_mean(
mean_nq, var_nq, len(res[1]), 0.95)
center_enq2, lower_enq2, upper_enq2, precision_enq2 = stat.confidence_interval_for_mean(
mean_nq2, var_nq2, res[2], 0.95)
center_vnq, lower_vnq, upper_vnq, precision_vnq = stat.confidence_interval_for_variance(
var_nq, len(res[1]), 0.95)
center_vnq2, lower_vnq2, upper_vnq2, precision_vnq2 = stat.confidence_interval_for_variance(
var_nq2, res[2], 0.95)
print(f"E[W] = {mean_w}")
print(f"V(W) = {var_w}")
print(f"E[Nq] = {mean_nq}")
print(f"E[Nq]2 = {mean_nq2}")
print(f"V(Nq) = {var_nq}")
print(f"V(Nq)2 = {var_nq2}")
print(
f"E[W] CI: Center = {center_ew} lower = {lower_ew} upper = {upper_ew} precision = {precision_ew}"
)
print(
f"V[W] CI: Center = {center_vw} lower = {lower_vw} upper = {upper_vw} precision = {precision_vw}"
)
print(
f"E[Nq] CI: Center = {center_enq} lower = {lower_enq} upper = {upper_enq} precision = {precision_enq}"
)
print(
f"E[Nq]2 CI: Center = {center_enq2} lower = {lower_enq2} upper = {upper_enq2} precision = {precision_enq2}"
)
print(
f"V[Nq] CI: Center = {center_vnq} lower = {lower_vnq} upper = {upper_vnq} precision = {precision_vnq}"
)
print(
f"V[Nq]2 CI: Center = {center_vnq2} lower = {lower_vnq2} upper = {upper_vnq2} precision = {precision_vnq2}"
)
def transient_phase(self):
"""Runs the simulator until the transient phase is finished, which occurs
when 'chunk_size' variance values under 'threshold' precision are found"""
stats = Statistics()
means_w = []
var = []
count = 0
# threshold adjustment
if self.__rho == 0.2 or self.__rho == 0.4:
threshold = 0.001
elif self.__rho == 0.6:
threshold = 0.01
elif self.__rho == 0.8:
threshold = 0.5
else:
threshold = 1.0
chunk_size = 10
while True:
# calculate next variance for the variance list
for i in range(0, 10):
res = self.simulate_LCFS(100)
means_w.append(stats.calculate_mean(res[0]))
var_w = stats.calculate_incremental_variance(means_w)
means_w.clear()
if not var: # if variance list is empty
var.append(var_w)
continue
for i in range(0, len(var)):
if abs(var_w - var[i]) < threshold:
count += 1
if count == len(
var): # if we found a number in the list threshold, append
var.append(var_w)
if len(
var
) == chunk_size: # if the list has all members in the threshold, end of transient phase
return
else: # if the member is not in the list threshold, discart list
var.clear()
count = 0 # reset count
class TestStatistics(TestCase):
def setUp(self):
self.stat = Statistics()
def test_calculate_mean(self):
sample = []
for i in range(0, 100):
sample.append(random())
mean = self.stat.calculate_mean(sample)
control = tmean(sample)
self.assertAlmostEqual(mean, control)
def test_calculate_incremental_mean(self):
control_sample = []
sample = []
mean = 0
for i in range(0, 20):
for _ in range(0, 100):
elem = random()
sample.append(elem)
control_sample.append(elem)
mean = self.stat.calculate_incremental_mean(sample)
sample.clear()
control = tmean(control_sample)
self.assertAlmostEqual(mean, control)
def test_calculate_incremental_time_mean(self):
control_sample = []
sample = []
mean = 0
for i in range(0, 20):
for _ in range(0, 100):
elem = random()
sample.append(elem)
control_sample.append(elem)
mean = self.stat.calculate_incremental_time_mean(
sample, len(sample))
sample.clear()
control = tmean(control_sample)
self.assertAlmostEqual(mean, control)
def test_calculate_variance(self):
sample = []
for i in range(0, 100):
sample.append(random())
var = self.stat.calculate_variance(sample,
self.stat.calculate_mean(sample))
control = tvar(sample)
self.assertAlmostEqual(var, control)
def test_calculate_incremental_variance(self):
control_sample = []
sample = []
var = 0
for i in range(0, 20):
for _ in range(0, 100):
elem = random()
sample.append(elem)
control_sample.append(elem)
var = self.stat.calculate_incremental_variance(sample)
sample.clear()
control = tvar(control_sample)
self.assertAlmostEqual(var, control)
def test_confidence_interval_for_mean(self):
n = 100
sample = []
for i in range(0, n):
sample.append(random())
mean = self.stat.calculate_mean(sample)
var = self.stat.calculate_variance(sample, mean)
center, lower, upper, precision = self.stat.confidence_interval_for_mean(
mean, var, n, 0.95)
res = bayes_mvs(sample, 0.95)
self.assertAlmostEqual(center, res[0][0])
self.assertAlmostEqual(lower, res[0][1][0])
self.assertAlmostEqual(upper, res[0][1][1])
def test_confidence_interval_for_variance(self):
n = 100
sample = []
for i in range(0, n):
sample.append(random())
mean = self.stat.calculate_mean(sample)
var = self.stat.calculate_variance(sample, mean)
center, lower, upper, precision = self.stat.confidence_interval_for_variance(
var, n, 0.95)
res = bayes_mvs(sample, 0.95)
self.assertAlmostEqual(lower, res[1][1][0])
self.assertAlmostEqual(upper, res[1][1][1])
