def collect_list_measures(self, ruleset, results, election):
const_seats_alloc = add_totals(election.m_const_seats_alloc)
total_seats_alloc = add_totals(results)
for c in range(1 + self.num_constituencies):
for p in range(1 + self.num_parties):
cs = const_seats_alloc[c][p]
ts = total_seats_alloc[c][p]
adj = ts - const_seats_alloc[c][p]
sh = float(ts) / total_seats_alloc[c][-1]
self.aggregate_list(ruleset, "const_seats", c, p, cs)
self.aggregate_list(ruleset, "total_seats", c, p, ts)
self.aggregate_list(ruleset, "adj_seats", c, p, adj)
self.aggregate_list(ruleset, "seat_shares", c, p, sh)
def run_initial_elections(self):
self.base_allocations = []
for r in range(self.num_rulesets):
election = voting.Election(self.e_rules[r], self.base_votes)
xtd_total_seats = add_totals(election.run())
xtd_const_seats = add_totals(election.m_const_seats_alloc)
xtd_adj_seats = matrix_subtraction(xtd_total_seats, xtd_const_seats)
xtd_seat_shares = find_xtd_shares(xtd_total_seats)
self.base_allocations.append({
"xtd_const_seats": xtd_const_seats,
"xtd_adj_seats": xtd_adj_seats,
"xtd_total_seats": xtd_total_seats,
"xtd_seat_shares": xtd_seat_shares,
"step_info": election.adj_seats_info,
})
def beta_distribution(
base_votes, #2d - votes for each list,
std_param #distribution parameter in range (0,1)
):
"""
Generate a set of votes with beta distribution,
using 'base_votes' as reference.
"""
assert (0 < std_param and std_param < 1)
xtd_votes = add_totals(base_votes)
xtd_shares = find_xtd_shares(xtd_votes)
generated_votes = []
for c in range(len(base_votes)):
s = 0
generated_votes.append([])
for p in range(len(base_votes[c])):
mean_beta_distr = xtd_shares[c][p]
assert (0 <= mean_beta_distr and mean_beta_distr <= 1)
if 0 < mean_beta_distr and mean_beta_distr < 1:
var_beta = std_param * mean_beta_distr * (1 - mean_beta_distr)
alpha, beta = beta_params(mean_beta_distr, std_param)
share = betavariate(alpha, beta)
else:
share = mean_beta_distr #either 0 or 1
generated_votes[c].append(int(share * xtd_votes[c][-1]))
return generated_votes
def test_all_adj(self):
#Arrange
election = voting.Election(self.e_rules, self.votes)
comparison_rules = simulate.generate_all_adj_ruleset(self.e_rules)
comparison_election = voting.Election(comparison_rules, self.votes)
sim = simulate.Simulation(self.s_rules, [self.e_rules], self.votes)
#Act
base_results = election.run()
comparison_results = comparison_election.run()
sim.simulate()
sim_result = sim.get_results_dict()
#Assert
list_measures = sim_result['data'][0]['list_measures']
self.assertEqual(list_measures["total_seats"]['avg'],
util.add_totals(base_results))
self.assertEqual(base_results, [[0, 1], [0, 1], [0, 1]])
self.assertEqual(comparison_results, [[1, 0], [0, 1], [0, 1]])
deviation = simulate.dev(base_results, comparison_results)
self.assertEqual(deviation, 2)
measures = sim_result['data'][0]['measures']
self.assertEqual(measures['dev_all_adj']['avg'], deviation)
def collect_votes(self, votes):
xtd_votes = add_totals(votes)
xtd_shares = find_xtd_shares(xtd_votes)
for c in range(self.num_constituencies+1):
for p in range(self.num_parties+1):
self.aggregate_list(-1, "sim_votes", c, p, xtd_votes[c][p])
self.aggregate_list(-1, "sim_shares", c, p, xtd_shares[c][p])
def __init__(self, sim_rules, e_rules, m_votes, std_param=0.1):
self.num_total_simulations = sim_rules["simulation_count"]
self.num_rulesets = len(e_rules)
self.num_constituencies = len(m_votes)
self.num_parties = len(m_votes[0])
assert (all([len(c) == self.num_parties for c in m_votes]))
assert (all([
self.num_constituencies == len(ruleset["constituency_names"])
and self.num_constituencies == len(ruleset["constituency_seats"])
and self.num_constituencies == len(
ruleset["constituency_adjustment_seats"])
and self.num_parties == len(ruleset["parties"])
for ruleset in e_rules
]))
self.sim_rules = sim_rules
self.e_rules = e_rules
self.base_votes = m_votes
self.xtd_votes = add_totals(self.base_votes)
self.xtd_vote_shares = find_xtd_shares(self.xtd_votes)
self.variate = self.sim_rules["gen_method"]
self.std_param = std_param
self.iteration = 0
self.terminate = False
self.iteration_time = timedelta(0)
self.data = []
self.list_data = []
for ruleset in range(self.num_rulesets):
self.data.append({})
for measure in MEASURES.keys():
self.data[ruleset][measure] = {
aggr: 0
for aggr in AGGREGATES.keys()
}
self.list_data.append({})
for measure in LIST_MEASURES.keys():
self.list_data[ruleset][measure] = {}
for aggr in AGGREGATES.keys():
self.list_data[ruleset][measure][aggr] = []
for c in range(self.num_constituencies + 1):
self.list_data[ruleset][measure][aggr].append(
[0] * (self.num_parties + 1))
self.data.append({})
self.list_data.append({})
for measure in VOTE_MEASURES.keys():
self.list_data[-1][measure] = {}
for aggr in AGGREGATES.keys():
self.list_data[-1][measure][aggr] = []
for c in range(self.num_constituencies + 1):
self.list_data[-1][measure][aggr].append(
[0] * (self.num_parties + 1))
self.run_initial_elections()
def test_get_results(self):
rules = ElectionRules()
rules["parties"] = ["A", "B"]
rules["adjustment_method"] = "alternating-scaling"
rules["constituency_names"] = ["I", "II"]
rules["constituency_seats"] = [2, 3]
rules["constituency_adjustment_seats"] = [1, 2]
votes = [[500, 400], [300, 200]]
election = Election(rules, votes)
election.run()
res = election.get_results_dict()
print(res)
self.assertEqual(res["rules"], rules)
self.assertEqual(res["seat_allocations"], add_totals([[2, 1], [3, 2]]))
def gen_votes(self):
"""
Generate votes similar to given votes using the given
generating method.
"""
gen = GENERATING_METHODS[self.variate]
while True:
votes = gen(self.base_votes, self.std_param)
xtd_votes = add_totals(votes)
xtd_shares = find_xtd_shares(xtd_votes)
for c in range(self.num_constituencies + 1):
for p in range(self.num_parties + 1):
self.aggregate_list(-1, "sim_votes", c, p, xtd_votes[c][p])
self.aggregate_list(-1, "sim_shares", c, p,
xtd_shares[c][p])
yield votes
def get_results_dict(self):
return {
"rules": self.rules,
"seat_allocations": add_totals(self.results),
}