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