def run_FCFS(rho, k, seed=None):
"""Runs the simulation for FCFS discipline with given parameters,
returning its statistics"""
results_w = []
results_nq = []
stat_w = Statistics()
stat_nq = Statistics()
simulator = SimulatorFCFS(rho, seed)
simulator.transient_phase()
for i in range(0, 3200):
res = simulator.simulate_FCFS(k)
mean_w = stat_w.calculate_incremental_mean(res[0])
var_w = stat_w.calculate_incremental_variance(res[0])
mean_nq = stat_nq.calculate_incremental_time_mean(res[1], res[2])
var_nq = stat_nq.calculate_incremental_variance(res[1])
center_ew, lower_ew, upper_ew, precision_ew = stat_w.confidence_interval_for_mean(
mean_w, var_w, len(res[0]), 0.95)
center_vw, lower_vw, upper_vw, precision_vw = stat_w.confidence_interval_for_variance(
var_w, len(res[0]), 0.95)
center_enq, lower_enq, upper_enq, precision_enq = stat_nq.confidence_interval_for_mean(
mean_nq, var_nq, res[2], 0.95)
center_vnq, lower_vnq, upper_vnq, precision_vnq = stat_nq.confidence_interval_for_variance(
var_nq, res[2], 0.95)
results_w.append(
((mean_w, center_ew, lower_ew, upper_ew, precision_ew),
(var_w, center_vw, lower_vw, upper_vw, precision_vw)))
results_nq.append(
((mean_nq, center_enq, lower_enq, upper_enq, precision_enq),
(var_nq, center_vnq, lower_vnq, upper_vnq, precision_vnq)))
return results_w, results_nq
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}"
)
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])
