def test_simulate_once(self):
#Arrange
self.s_rules["simulation_count"] = 1
sim = simulate.Simulation(self.s_rules, [self.e_rules], self.votes,
100)
#Act
sim.simulate()
#Assert
result = sim.get_results_dict()
vote_data = result['vote_data']['sim_votes']
list_measures = result['data'][0]['list_measures']
for const in range(sim.num_constituencies):
for party in range(sim.num_parties):
self.assertGreater(vote_data['sum'][const][party], 0)
self.assertGreater(vote_data['avg'][const][party], 0)
self.assertEqual(vote_data['cnt'][const][party], 1)
self.assertEqual(vote_data['var'][const][party], 0)
self.assertEqual(vote_data['std'][const][party], 0)
for m in simulate.LIST_MEASURES.keys():
self.assertEqual(list_measures[m]['cnt'][const][party], 1)
self.assertEqual(list_measures[m]['var'][const][party], 0)
self.assertEqual(list_measures[m]['std'][const][party], 0)
measures = result['data'][0]['measures']
for m in simulate.MEASURES.keys():
self.assertEqual(measures[m]['cnt'], 1)
self.assertEqual(measures[m]['var'], 0)
self.assertEqual(measures[m]['std'], 0)
def test_robot_works_in_rectangle_world():
from simulate import Simulation
import simulate as sim
import helpers
reload(localizer)
reload(sim)
reload(helpers)
R = 'r'
G = 'g'
# grid = [
# [R,G,G,G,R,R,R],
# [G,G,R,G,R,G,R],
# [G,R,G,G,G,G,R],
# [R,R,G,R,G,G,G],
# ]
grid = [
[R, G, G, G],
[G, G, R, G],
[G, R, G, G],
[R, R, G, R],
[R, R, G, R],
]
blur = 0.001
p_hit = 100.0
for i in range(1000):
simulation = sim.Simulation(grid, blur, p_hit)
simulation.run(1)
def test_generate_votes_average(self):
n = 1000
self.s_rules["simulation_count"] = n
sim = simulate.Simulation(self.s_rules, [self.e_rules], self.votes,
100)
gen = sim.gen_votes()
r = []
r_avg = []
r_var = []
for k in range(n):
r.append([])
generated_votes = next(gen)
for i in range(len(self.votes)):
r[k].append([])
for j in range(len(self.votes[i])):
r[k][i].append(uniform(0.0, 1.0))
for i in range(len(self.votes)):
r_avg.append([])
r_var.append([])
for j in range(len(self.votes[i])):
r_ij = [r[k][i][j] for k in range(n)]
# average = simulate.avg(r_ij)
# r_avg[i].append(average)
# r_var[i].append(simulate.var(r_ij, average))
sim.test_generated()
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 simulate(votes, constituencies, **kwargs):
"""Simulate elections."""
e_rules = voting.ElectionRules()
e_rules["constituencies"] = constituencies
parties, votes = util.load_votes(votes, e_rules["constituencies"])
e_rules["parties"] = parties
s_rules = sim.SimulationRules()
try:
for arg, val in kwargs.iteritems():
s_rules[arg] = val
except AttributeError:
for arg, val in kwargs.items():
s_rules[arg] = val
e_rules = util.sim_election_rules(e_rules, s_rules["test_method"])
simulation = sim.Simulation(s_rules, [e_rules], votes)
simulation.simulate()
if s_rules["show_details"]:
util.print_simulation(simulation)
if s_rules["to_xlsx"]:
util.simulation_to_xlsx(simulation, s_rules["to_xlsx"])
def set_up_simulation():
data = request.get_json(force=True)
rulesets = []
for rs in data["election_rules"]:
election_rules = voting.ElectionRules()
print(data["election_rules"])
print(rs)
for k, v in rs.items():
print("Setting election_rules[%s] = %s" % (k, v))
election_rules[k] = v
for x in [
"constituency_names", "constituency_seats", "parties",
"constituency_adjustment_seats"
]:
if x in data and data[x]:
election_rules[x] = data[x]
else:
return False, "Missing data ('%s')" % x
rulesets.append(election_rules)
if not "ref_votes" in data:
return False, "Votes missing."
for const in data["ref_votes"]:
for party in const:
if type(party) != int:
return False, "Votes must be numbers."
stability_parameter = 100
if "stbl_param" in data:
stability_parameter = data["stbl_param"]
if stability_parameter <= 1:
return False, "Stability parameter must be greater than 1."
simulation_rules = sim.SimulationRules()
for k, v in data["simulation_rules"].items():
simulation_rules[k] = v
try:
simulation = sim.Simulation(simulation_rules, rulesets,
data["ref_votes"], stability_parameter)
except ZeroDivisionError:
return False, "Need to have more votes."
return True, simulation
# This code defines a 5x5 robot world as well as some other parameters
# It then creates a simulation and shows the initial beliefs.
R = 'r'
G = 'g'
grid = [
[R,G,G,G,R],
[G,G,R,G,R],
[G,R,G,G,G],
[R,R,G,R,G],
[R,G,R,G,R],
]
blur = 0.05
p_hit = 200.0
simulation = sim.Simulation(grid, blur, p_hit)
simulation.show_beliefs()
simulation.run(1)
simulation.show_beliefs()
def show_rounded_beliefs(beliefs):
for row in beliefs:
for belief in row:
print("{:0.3f}".format(belief), end=" ")
print()
# The {:0.3f} notation is an example of "string
parser.add_argument("--ntrain",
type=int,
default=5,
help='number of batch GP trainings to run')
args = parser.parse_args()
alpha = .05
thresh = scipy.stats.norm.ppf((1 - alpha / 2))
sim = simulate.Simulation(nobs=args.nobs,
nrep=args.nrep,
nbatch=args.nbatch,
sigma=args.sigma,
batchVariance=args.batchVariance,
repVariance=args.repVariance,
mumax=args.mumax,
A=args.A,
lag=args.lag,
xmax=args.xmax,
config=args.config)
if not str(sim._id) in os.listdir("results/simulations"):
os.mkdir('results/simulations/%d' % sim._id)
if not 'figures' in os.listdir("results/simulations/%d" % sim._id):
os.mkdir('results/simulations/%d/figures' % sim._id)
sim.to_config().write(
open(os.path.join('results/simulations/%d' % sim._id, 'config.cfg'), 'w'))
'''
A program to simulate the damage done by weapons in the videogame
warframe.
'''
# Imports
from mods import mod, loadout
import enemies
import simulate
import plotter
# Main Function
if __name__ == "__main__":
# Play around
loadout1 = loadout('Viral', 'Soma')
loadout1.add_mod(mod('Serration', 10), mod('Infected Clip', 2),
mod('Cryo Rounds', 2))
grineer = enemies.Enemy('Elite Crewman', 25)
simulation = simulate.Simulation(loadout1, grineer)
simulation.Simulate()
plotter.Plotter([simulation])
