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 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])