def create_toxin(name, i): """ Create a toxin. """ toxin = Agent(name + str(i), action=toxin_action) toxin["max_move"] = get_prop("toxin_move", DEF_TOXIN_MOVE) return toxin
def setUp(self): (self.space, self.newton) = create_space() self.teeny_space = create_teeny_space() self.test_agent = Agent("test agent") self.test_agent2 = Agent("test agent 2") self.test_agent3 = Agent("test agent 3") self.test_agent4 = Agent("test agent 4")
def create_rholder(name, i, props=None): """ Create an agent. """ k_price = DEF_K_PRICE resources = copy.deepcopy(DEF_CAP_WANTED) num_resources = len(resources) price_list = copy.deepcopy(DEF_EACH_CAP_PRICE) if props is not None: k_price = props.get('cap_price', DEF_K_PRICE) for k in price_list.keys(): price_list[k] = float("{0:.2f}".format( float(k_price * random.uniform(0.5, 1.5)))) starting_cash = DEF_RHOLDER_CASH if props is not None: starting_cash = get_prop('rholder_starting_cash', DEF_RHOLDER_CASH) if props is not None: total_resources = get_prop('rholder_starting_resource_total', DEF_TOTAL_RESOURCES_RHOLDER_HAVE) for k in resources.keys(): resources[k] = int( (total_resources * 2) * (random.random() / num_resources)) return Agent(name + str(i), action=rholder_action, attrs={ "cash": starting_cash, "resources": resources, "price": price_list })
def create_agent(i): """ Creates agent for holding sand. """ return Agent(SAND_PREFIX + str(i), action=agent_action, attrs={"grains": 0})
def create_grain(x, y): """ Create an agent with the passed x, y value as its name. """ return Agent(name=("(%d,%d)" % (x, y)), action=spagent_action, attrs={"save_neighbors": True})
def create_trader(name, i, props=None): return Agent(name + str(i), action=seek_a_trade, attrs={ "goods": { "penguin": { AMT_AVAILABLE: 0, UTIL_FUNC: "penguin_util_func", "incr": 0 }, "cat": { AMT_AVAILABLE: 0, UTIL_FUNC: "cat_util_func", "incr": 0 }, "bear": { AMT_AVAILABLE: 0, UTIL_FUNC: "bear_util_func", "incr": 0 }, "pet food": { AMT_AVAILABLE: 0, UTIL_FUNC: GEN_UTIL_FUNC, "incr": 0 } }, "util": 0, "pre_trade_util": 0, "trades_with": "trader" })
def create_bb(name): """ Create a big box store. """ bb_book = {"expense": bb_expense, "capital": get_env_attr("bb_capital")} return Agent(name=name, attrs=bb_book, action=bb_action)
def create_resident(name, i, group=BLUE, **kwargs): """ Creates agent of specified color type """ execution_key = get_exec_key(kwargs=kwargs) if group == BLUE: grp_idx = BLUE_GRP_IDX mean_tol = get_prop('mean_tol', DEF_TOLERANCE, execution_key=execution_key) else: grp_idx = RED_GRP_IDX mean_tol = -get_prop( 'mean_tol', DEF_TOLERANCE, execution_key=execution_key) dev = get_prop('deviation', DEF_SIGMA, execution_key=execution_key) this_tolerance = get_tolerance(mean_tol, dev) return Agent(name + str(i), action=seg_agent_action, attrs={ TOLERANCE: this_tolerance, GRP_INDEX: grp_idx, "hood_changed": True, "just_moved": False, "hood_size": get_prop('hood_size', DEF_HOOD_SIZE, execution_key=execution_key) }, execution_key=execution_key)
def create_tsetter(i, color=RED_SIN): """ Create a trendsetter: all RED_SIN to start. """ return Agent(TSETTER_PRENM + str(i), action=tsetter_action, attrs={COLOR_PREF: color, DISPLAY_COLOR: color})
def create_agent(i, color): """ Creates agent of specified color type """ return Agent(group_names[color] + str(i), action=agent_action, attrs={TOLERANCE: DEF_TOLERANCE, COLOR: color})
def create_grain(x, y, execution_key=None): """ Create an agent with the passed x, y value as its name. """ return Agent(name=("(%d,%d)" % (x, y)), action=None, attrs={"save_neighbors": True}, execution_key=execution_key)
def create_follower(i, color=BLUE_SIN): """ Create a follower: all BLUE_SIN to start. """ return Agent(FOLLOWER_PRENM + str(i), action=follower_action, attrs={COLOR_PREF: color, DISPLAY_COLOR: color})
def create_bb(name): """ Create a big box store. """ global bb_capital bb_book = {"expense": 150, "capital": bb_capital} return Agent(name=name, attrs=bb_book, action=bb_action)
def create_nutrient(name, i): """ Create a nutrient. """ nutrient = Agent(name + str(i), action=nutrient_action) nutrient["max_move"] = get_prop("nutrient_move", DEF_NUTRIENT_MOVE) return nutrient
def plant_tree(i, state=HE): """ Plant a new tree! By default, they start out healthy. """ return Agent(TREE_PREFIX + str(i), action=tree_action, attrs={"state": state})
def create_other_leibniz(): return Agent("Leibniz", attrs={ "place": 1.0, "time": LEIBBYEAR }, action=leib_action, duration=20)
def create_game_cell(x, y, execution_key=CLI_EXEC_KEY): """ Create an agent with the passed x, y value as its name. """ return Agent(name=("(%d,%d)" % (x, y)), action=game_agent_action, attrs={"save_neighbors": True}, execution_key=execution_key)
def create_newton(): return Agent("Newton", attrs={ "place": 0.0, "time": 1658.0, "achieve": 43.9 }, action=newt_action, duration=30)
def create_geneng(name, i, **kwargs): """ Create an agent. """ dur = get_prop("lifespan", DEF_DURATION) return Agent(name + str(i), action=geneng_action, duration=dur, attrs={"height": START_HEIGHT})
def create_central_bank(name, i): """ Create the central bank to distribute the coupons """ central_bank = Agent(name, action=central_bank_action) central_bank["percent_change"] = get_prop("percent_change", DEF_PERCENT) central_bank["extra_coupons"] = get_prop("extra_coupons", DEF_COUPON) central_bank["extra_dev"] = get_prop("extra_deviation", DEF_SIGMA) return central_bank
def create_mp(store_type, i): """ Create a mom and pop store. """ expense = mp_stores[str(store_type)] name = str(store_type) + " " + str(i) store_books = {"expense": expense[EXPENSE_INDX], "capital": expense[CAPITAL_INDX]} return Agent(name=name, attrs=store_books, action=mp_action)
def create_follower(name, i, props=None, color=BLUE_SIN, **kwargs): """ Create a follower: all BLUE to start. """ execution_key = get_exec_key(kwargs=kwargs) return Agent(FOLLOWER_PRENM + str(i), action=follower_action, attrs={COLOR_PREF: color, DISPLAY_COLOR: color}, execution_key=execution_key)
def create_tsetter(name, i, props=None, color=RED_SIN, **kwargs): """ Create a trendsetter: all RED to start. """ execution_key = get_exec_key(kwargs=kwargs) return Agent(TSETTER_PRENM + str(i), action=tsetter_action, attrs={COLOR_PREF: color, DISPLAY_COLOR: color}, execution_key=execution_key)
def create_consumer(name, i, props=None): """ Create consumers """ spending_power = random.randint(50, 70) consumer_books = {"spending power": spending_power, "last util": 0.0, "item needed": get_rand_good()} return Agent(name + str(i), attrs=consumer_books, action=consumer_action)
def addAgents(self, agent_name, num_of_agents): agents_arr = [] for agent_num in range(1, num_of_agents + 1): agents_arr.append( Agent( agent_name + "_agent" + str(agent_num), action=generate_func, attrs={"John": "Knox"}, )) return agents_arr
def create_natural(name, i, **kwargs): """ Create an agent. """ dur = get_prop("lifespan", DEF_DURATION) height = gauss(START_HEIGHT, DEF_SIGMA) return Agent(name + str(i), action=natural_action, duration=dur, attrs={"height": height})
def create_mp(store_grp, i): """ Create a mom and pop store. """ return Agent(name=str(store_grp) + " " + str(i), attrs={ "expense": store_grp.get_attr("per_expense"), "capital": store_grp.get_attr("init_capital") }, action=mp_action)
def create_boyfriend(name, i, props=None): """ Create an agent. """ return Agent(name + str(i), action=boyfriend_action, attrs={ "cycle": get_prop('cycle', DEF_CYCLE), "going": True })
def create_agent(i, mean_tol, dev, color): """ Creates agent of specified color type """ this_tolerance = get_tolerance(mean_tol, dev) return Agent(group_names[color] + str(i), action=agent_action, attrs={ TOLERANCE: this_tolerance, COLOR: color })
def create_trader(name, i): """ A func to create a trader. """ return Agent(name + str(i), action=trader_action, attrs={ "goods": {}, "util": 0, "pre_trade_util": 0 })
def create_bird(name, i, props=None): """ Creates a bird with a numbered name and an action function making it flock. """ return Agent(name + str(i), action=bird_action, attrs={ "max_move": BIRD_MAX_MOVE, "angle": 0 })
class SpaceTestCase(TestCase): def setUp(self): (self.space, self.newton) = create_space() self.teeny_space = create_teeny_space() self.test_agent = Agent("test agent") self.test_agent2 = Agent("test agent 2") self.test_agent3 = Agent("test agent 3") self.test_agent4 = Agent("test agent 4") def tearDown(self): self.space = None self.teeny_space = None self.test_agent = None self.test_agent2 = None self.test_agent3 = None self.test_agent4 = None def test_constrain_x(self): """ Test keeping x in bounds. """ self.assertEqual(self.space.constrain_x(-10), 0) self.assertEqual(self.space.constrain_x(DEF_WIDTH * 2), DEF_WIDTH - 1) def test_constrain_y(self): """ Test keeping y in bounds. """ self.assertEqual(self.space.constrain_y(-10), 0) self.assertEqual(self.space.constrain_x(DEF_HEIGHT * 2), DEF_HEIGHT - 1) def test_grid_size(self): """ Make sure we calc grid size properly. """ self.assertEqual(self.space.grid_size(), DEF_HEIGHT * DEF_WIDTH) def test_is_full(self): """ See if the grid is full. """ self.assertFalse(self.space.is_full()) self.assertTrue(self.teeny_space.is_full()) def test_place_members(self): """ Test place_members() by making sure all agents have a pos when done. """ for agent in self.space: self.assertTrue(self.space[agent].islocated()) def test_place_member_xy(self): """ Test placing an agent at a particular x, y spot. We will run this DEF_HEIGHT times, to test multiple possible placements. """ space = Space("test space") for i in range(DEF_HEIGHT): spot = space.place_member(mbr=self.test_agent, xy=(i, i)) if spot is not None: # the print output will usually be captured by nose, # but that can be turned off with --nocapture. (x, y) = (self.test_agent.get_x(), self.test_agent.get_y()) self.assertEqual((x, y), (i, i)) def test_get_agent_at(self): """ Test getting an agent from some locale. """ space = Space("test space") # before adding agent, all cells are empty: self.assertEqual(space.get_agent_at(1, 1), None) for i in range(DEF_HEIGHT): spot = space.place_member(mbr=self.test_agent, xy=(i, i)) whos_there = space.get_agent_at(i, i) self.assertEqual(whos_there, self.test_agent) def test_rand_x(self): """ Make sure randomly generated X pos is within grid. If constrained, make sure it is within constraints. """ x = self.space.rand_x() self.assertTrue(x >= 0) self.assertTrue(x < self.space.width) x2 = self.space.rand_x(low=4, high=8) self.assertTrue(x2 >= 4) self.assertTrue(x2 <= 8) def test_rand_y(self): """ Make sure randomly generated Y pos is within grid. """ y = self.space.rand_y() self.assertTrue(y >= 0) self.assertTrue(y < self.space.height) y2 = self.space.rand_y(low=4, high=8) self.assertTrue(y2 >= 4) self.assertTrue(y2 <= 8) def test_gen_new_pos(self): """ Making sure new pos is within max_move of old pos. Since this test relies on random numbers, let's repeat it. """ for i in range(REP_RAND_TESTS): # test with different max moves: max_move = (i // 2) + 1 (old_x, old_y) = self.newton.get_pos() (new_x, new_y) = self.space.gen_new_pos(self.newton, max_move) if not abs(old_x - new_x) <= max_move: print("Failed test with ", old_x, " ", new_x) if not abs(old_y - new_y) <= max_move: print("Failed test with ", old_y, " ", new_y) self.assertTrue(abs(old_x - new_x) <= max_move) self.assertTrue(abs(old_y - new_y) <= max_move) def test_location(self): """ Test that an added agent has a location. """ n = create_newton() self.space += n self.assertTrue(self.space.locations[n.pos] == n) def test_add_location(self): """ Can we add an agent to a location? """ x, y = self.space.rand_x(), self.space.rand_y() if (x, y) not in self.space.locations: self.newton.set_pos(self.space, x, y) self.space.add_location(x, y, self.newton) self.assertTrue(self.space.locations[self.newton.pos] == self.newton) def test_move_location(self): """ Can we move agent from one location to another? This test sometimes fails: we need to explore! """ x, y = self.space.rand_x(), self.space.rand_y() self.space.move_location(x, y, self.newton.get_x(), self.newton.get_y()) self.assertTrue(self.space.locations[(x, y)] == self.newton) def test_remove_location(self): """ Test removing location from locations. """ (x, y) = (self.newton.get_x(), self.newton.get_y()) self.space.remove_location(x, y) self.assertTrue((x, y) not in self.space.locations) def test_move(self): """ Test whether moving an agent stays within its max move. """ for i in range(REP_RAND_TESTS): # test with different max moves: max_move = (i // 2) + 1 (old_x, old_y) = (self.newton.get_x(), self.newton.get_y()) self.newton.move(max_move) (new_x, new_y) = (self.newton.get_x(), self.newton.get_y()) self.assertTrue(abs(new_x - old_x) <= max_move) self.assertTrue(abs(new_y - old_y) <= max_move) def test_is_empty(self): """ Is cell empty? """ (x, y) = (self.newton.get_x(), self.newton.get_y()) self.assertFalse(self.space.is_empty(x, y)) def test_get_vonneumann_hood(self): """ Get von Neumann neighborhood. """ space = Space("test space") space += self.test_agent space += self.test_agent2 space.place_member(mbr=self.test_agent, xy=(0, 0)) space.place_member(mbr=self.test_agent2, xy=(0, 1)) hood = space.get_vonneumann_hood(self.test_agent) print(repr(hood)) self.assertTrue(self.test_agent2.name in hood) space += self.test_agent3 space.place_member(mbr=self.test_agent3, xy=(1, 0)) hood = space.get_vonneumann_hood(self.test_agent) self.assertTrue(self.test_agent3.name in hood) space += self.test_agent4 space.place_member(mbr=self.test_agent4, xy=(0, DEF_HEIGHT)) hood = space.get_vonneumann_hood(self.test_agent) self.assertTrue(self.test_agent4.name not in hood)