class TestSingleGrid(unittest.TestCase):
'''
Test the SingleGrid object.
Since it inherits from Grid, all the functionality tested above should
work here too. Instead, this tests the enforcement.
'''
def setUp(self):
'''
Create a test non-toroidal grid and populate it with Mock Agents
'''
width = 3
height = 5
self.grid = SingleGrid(width, height, True)
self.agents = []
counter = 0
for x in range(width):
for y in range(height):
if TEST_GRID[x][y] == 0:
continue
counter += 1
# Create and place the mock agent
a = MockAgent(counter, None)
self.agents.append(a)
self.grid.place_agent(a, (x, y))
def test_enforcement(self):
'''
Test the SingleGrid empty count and enforcement.
'''
assert len(self.grid.empties) == 9
a = MockAgent(100, None)
with self.assertRaises(Exception):
self.grid._place_agent((0, 1), a)
# Place the agent in an empty cell
self.grid.position_agent(a)
# Test whether after placing, the empty cells are reduced by 1
assert a.pos not in self.grid.empties
assert len(self.grid.empties) == 8
for i in range(10):
self.grid.move_to_empty(a)
assert len(self.grid.empties) == 8
# Place agents until the grid is full
empty_cells = len(self.grid.empties)
for i in range(empty_cells):
a = MockAgent(101 + i, None)
self.grid.position_agent(a)
assert len(self.grid.empties) == 0
a = MockAgent(110, None)
with self.assertRaises(Exception):
self.grid.position_agent(a)
with self.assertRaises(Exception):
self.move_to_empty(self.agents[0])
class TestSingleGrid(unittest.TestCase):
'''
Test the SingleGrid object.
Since it inherits from Grid, all the functionality tested above should
work here too. Instead, this tests the enforcement.
'''
def setUp(self):
'''
Create a test non-toroidal grid and populate it with Mock Agents
'''
width = 3
height = 5
self.grid = SingleGrid(width, height, True)
self.agents = []
counter = 0
for x in range(width):
for y in range(height):
if TEST_GRID[x][y] == 0:
continue
counter += 1
# Create and place the mock agent
a = MockAgent(counter, None)
self.agents.append(a)
self.grid.place_agent(a, (x, y))
def test_enforcement(self):
'''
Test the SingleGrid empty count and enforcement.
'''
assert len(self.grid.empties) == 9
a = MockAgent(100, None)
with self.assertRaises(Exception):
self.grid._place_agent((0, 1), a)
# Place the agent in an empty cell
self.grid.position_agent(a)
# Test whether after placing, the empty cells are reduced by 1
assert a.pos not in self.grid.empties
assert len(self.grid.empties) == 8
for i in range(10):
self.grid.move_to_empty(a)
assert len(self.grid.empties) == 8
# Place agents until the grid is full
empty_cells = len(self.grid.empties)
for i in range(empty_cells):
a = MockAgent(101 + i, None)
self.grid.position_agent(a)
assert len(self.grid.empties) == 0
a = MockAgent(110, None)
with self.assertRaises(Exception):
self.grid.position_agent(a)
with self.assertRaises(Exception):
self.move_to_empty(self.agents[0])
class TestSingleGrid(unittest.TestCase):
'''
Test the SingleGrid object.
Since it inherits from Grid, all the functionality tested above should
work here too. Instead, this tests the enforcement.
'''
def setUp(self):
'''
Create a test non-toroidal grid and populate it with Mock Agents
'''
self.grid = SingleGrid(3, 5, True)
self.agents = []
counter = 0
for y in range(3):
for x in range(5):
if TEST_GRID[y][x] == 0:
continue
counter += 1
# Create and place the mock agent
a = MockAgent(counter, None)
self.agents.append(a)
self.grid.place_agent(a, (x, y))
def test_enforcement(self):
'''
Test the SingleGrid empty count and enforcement.
'''
assert len(self.grid.empties) == 10
a = MockAgent(100, None)
with self.assertRaises(Exception):
self.grid._place_agent((1, 0), a)
# Place the agent in an empty cell
self.grid.position_agent(a)
assert a.pos not in self.grid.empties
assert len(self.grid.empties) == 9
for i in range(10):
self.grid.move_to_empty(a)
assert len(self.grid.empties) == 9
# Place agents until the grid is full
for i in range(9):
a = MockAgent(101 + i, None)
self.grid.position_agent(a)
assert len(self.grid.empties) == 0
a = MockAgent(110, None)
with self.assertRaises(Exception):
self.grid.position_agent(a)
with self.assertRaises(Exception):
self.move_to_empty(self.agents[0])
class TestSingleGrid(unittest.TestCase):
'''
Test the SingleGrid object.
Since it inherits from Grid, all the functionality tested above should
work here too. Instead, this tests the enforcement.
'''
def setUp(self):
'''
Create a test non-toroidal grid and populate it with Mock Agents
'''
self.grid = SingleGrid(3, 5, True)
self.agents = []
counter = 0
for y in range(3):
for x in range(5):
if TEST_GRID[y][x] == 0:
continue
counter += 1
# Create and place the mock agent
a = MockAgent(counter, None)
self.agents.append(a)
self.grid.place_agent(a, (x, y))
def test_enforcement(self):
'''
Test the SingleGrid empty count and enforcement.
'''
assert len(self.grid.empties) == 10
a = MockAgent(100, None)
with self.assertRaises(Exception):
self.grid._place_agent((1, 0), a)
# Place the agent in an empty cell
self.grid.position_agent(a)
assert a.pos not in self.grid.empties
assert len(self.grid.empties) == 9
for i in range(10):
self.grid.move_to_empty(a)
assert len(self.grid.empties) == 9
# Place agents until the grid is full
for i in range(9):
a = MockAgent(101 + i, None)
self.grid.position_agent(a)
assert len(self.grid.empties) == 0
a = MockAgent(110, None)
with self.assertRaises(Exception):
self.grid.position_agent(a)
with self.assertRaises(Exception):
self.move_to_empty(self.agents[0])
class TestSingleGrid(unittest.TestCase):
def setUp(self):
self.space = SingleGrid(50, 50, False)
self.agents = []
for i, pos in enumerate(TEST_AGENTS_GRID):
a = MockAgent(i, None)
self.agents.append(a)
self.space.place_agent(a, pos)
def test_agent_positions(self):
"""
Ensure that the agents are all placed properly.
"""
for i, pos in enumerate(TEST_AGENTS_GRID):
a = self.agents[i]
assert a.pos == pos
def test_remove_agent(self):
for i, pos in enumerate(TEST_AGENTS_GRID):
a = self.agents[i]
assert a.pos == pos
assert self.space.grid[pos[0]][pos[1]] == a
self.space.remove_agent(a)
assert a.pos is None
assert self.space.grid[pos[0]][pos[1]] is None
def test_empty_cells(self):
if self.space.exists_empty_cells():
pytest.deprecated_call(self.space.find_empty)
for i, pos in enumerate(list(self.space.empties)):
a = MockAgent(-i, pos)
self.space.position_agent(a, x=pos[0], y=pos[1])
assert self.space.find_empty() is None
with self.assertRaises(Exception):
self.space.move_to_empty(a)
def move_agent(self):
agent_number = 0
initial_pos = TEST_AGENTS_GRID[agent_number]
final_pos = (7, 7)
_agent = self.agents[agent_number]
assert _agent.pos == initial_pos
assert self.space.grid[initial_pos[0]][initial_pos[1]] == _agent
assert self.space.grid[final_pos[0]][final_pos[1]] is None
self.space.move_agent(_agent, final_pos)
assert _agent.pos == final_pos
assert self.space.grid[initial_pos[0]][initial_pos[1]] is None
assert self.space.grid[final_pos[0]][final_pos[1]] == _agent
class MoneyModel(Model):
"""A model with some number of agents."""
def __init__(self,
N,
width,
height,
init_price,
init_ei,
grow_ei,
fixed,
rnd,
p_q,
p_ei,
min_neighbor,
sub,
subsell,
burn,
seed=None):
self.num_agents = (width * height)
self.grid = SingleGrid(width, height, True)
self.schedule = RandomActivation(self)
self.running = True
self.ext_inc = init_ei
self.grow_ei = grow_ei
self.min_neighbor = min_neighbor
self.p_q = p_q
self.p_ei = p_ei
self.last_price = 0
self.price = self.init_price = init_price
self.tick = 0
self.true_supply = 0
self.stock = 0
self.subtrue = False
self.sub = sub
self.subsell = subsell
self.burn = burn
self.burned = 0
self.tax = 0
print(f'{p_q}, {p_ei}, {min_neighbor}')
# Create agents
for i in range(self.num_agents):
a = MoneyAgent(i, self, N, fixed, rnd)
self.schedule.add(a)
self.grid.place_agent(a, (0, 0))
if i < self.num_agents - 1:
self.grid.move_to_empty(a)
self.supply = [k.color for k in self.schedule.agents].count('yellow')
self.datacollector = DataCollector(
model_reporters={
"Supply": compute_supply,
"Price": compute_price,
"Stock": compute_stock,
"Burned": compute_burned
}
#agent_reporters={"Wealth": "wealth"}
)
#print(f'start time: {time.time() - start_time}')
def market(self):
self.tick += 1
print(self.tick)
self.last_price = self.price
self.ext_inc = self.ext_inc * (1 + self.grow_ei)
self.supply = [k.color for k in self.schedule.agents].count('yellow')
self.price = max(0, (self.init_price + (self.p_ei * self.ext_inc) -
(self.p_q * self.supply)))
if self.sub == True:
if self.price < 0.9 * self.last_price:
self.true_supply = (50 *
((self.init_price) + (0.2 * self.ext_inc) -
(0.9 * self.last_price)))
self.stock = (self.stock + (self.supply - self.true_supply))
self.price = (0.9 * self.last_price)
self.subtrue = True
if self.tick < 10:
self.stock = 0
if self.subsell == True:
if self.stock > 0:
if self.price > self.last_price:
if self.subtrue == True:
self.supprice = self.init_price + (
0.2 * self.ext_inc) - (0.01 *
(self.supply + self.stock))
if self.supprice >= self.last_price:
self.price = self.supprice
self.stock = 0
else:
self.price = self.last_price
self.true_supply = (50 * ((self.init_price) +
(0.2 * self.ext_inc) -
(0.9 * self.last_price)))
self.stock = self.stock - (self.true_supply -
self.supply)
if self.burn == True:
if self.stock >= 0:
self.tax = 0.5 * (self.stock / (self.supply + 0.1))
self.burned = (self.burned + self.stock)
self.stock = 0
def step(self):
start_time = time.time()
self.schedule.step()
print(f'schedule time: {time.time() - start_time}')
start_time = time.time()
self.market()
print(f'market time: {time.time() - start_time}')
start_time = time.time()
self.datacollector.collect(self)
print(f'datacollector time: {time.time() - start_time}')
class SeparationBarrierModel(Model):
def __init__(self, height, width, palestinian_density, settlement_density,
settlers_violence_rate, settlers_growth_rate, suicide_rate, greed_level,
settler_vision=1, palestinian_vision=1,
movement=True, max_iters=1000):
super(SeparationBarrierModel, self).__init__()
self.height = height
self.width = width
self.palestinian_density = palestinian_density
self.settler_vision = settler_vision
self.palestinian_vision = palestinian_vision
self.settlement_density = settlement_density
self.movement = movement
self.running = True
self.max_iters = max_iters
self.iteration = 0
self.schedule = RandomActivation(self)
self.settlers_violence_rate = settlers_violence_rate
self.settlers_growth_rate = settlers_growth_rate
self.suicide_rate = suicide_rate
self.greed_level = greed_level
self.total_violence = 0
self.grid = SingleGrid(height, width, torus=False)
model_reporters = {
}
agent_reporters = {
# "x": lambda a: a.pos[0],
# "y": lambda a: a.pos[1],
}
self.dc = DataCollector(model_reporters=model_reporters,
agent_reporters=agent_reporters)
self.unique_id = 0
# Israelis and palestinans split the region in half
for (contents, x, y) in self.grid.coord_iter():
if random.random() < self.palestinian_density:
palestinian = Palestinian(self.unique_id, (x, y), vision=self.palestinian_vision, breed="Palestinian",
model=self)
self.unique_id += 1
self.grid.position_agent(palestinian, x,y)
self.schedule.add(palestinian)
elif ((y > (self.grid.height) * (1-self.settlement_density)) and random.random() < self.settlement_density):
settler = Settler(self.unique_id, (x, y),
vision=self.settler_vision, model=self, breed="Settler")
self.unique_id += 1
self.grid.position_agent(settler, x,y)
self.schedule.add(settler)
def add_settler(self, pos):
settler = Settler(self.unique_id, pos,
vision=self.settler_vision, model=self, breed="Settler")
self.unique_id += 1
self.grid.position_agent(settler, pos[0], pos[1])
self.schedule.add(settler)
def set_barrier(self,victim_pos, violent_pos):
#print("Set barrier - Greed level", self.greed_level)
visible_spots = self.grid.get_neighborhood(victim_pos,
moore=True, radius=self.greed_level + 1)
furthest_empty = self.find_furthest_empty_or_palestinian(victim_pos, visible_spots)
x,y = furthest_empty
current = self.grid[y][x]
#print ("Set barrier!!", pos, current)
free = True
if (current is not None and current.breed == "Palestinian"):
#print ("Relocating Palestinian")
free = self.relocate_palestinian(current, current.pos)
if (free):
barrier = Barrier(-1, furthest_empty, model=self)
self.grid.position_agent(barrier, x,y)
# Relocate the violent palestinian
#violent_x, violent_y = violent_pos
#if violent_pos != furthest_empty:
# violent_palestinian = self.grid[violent_y][violent_x]
# self.relocate_palestinian(violent_palestinian, furthest_empty)
def relocate_palestinian(self, palestinian, destination):
#print ("Relocating Palestinian in ", palestinian.pos, "To somehwhere near ", destination)
visible_spots = self.grid.get_neighborhood(destination,
moore=True, radius=palestinian.vision)
nearest_empty = self.find_nearest_empty(destination, visible_spots)
#print("First Nearest empty to ", palestinian.pos, " Is ", nearest_empty)
if (nearest_empty):
self.grid.move_agent(palestinian, nearest_empty)
else:
#print ("Moveing to random empty")
if (self.grid.exists_empty_cells()):
self.grid.move_to_empty(palestinian)
else:
return False
return True
def find_nearest_empty(self, pos, neighborhood):
nearest_empty = None
sorted_spots = self.sort_neighborhood_by_distance(pos, neighborhood)
index = 0
while (nearest_empty is None and index < len(sorted_spots)):
if self.grid.is_cell_empty(sorted_spots[index]):
nearest_empty = sorted_spots[index]
index += 1
return nearest_empty
def find_furthest_empty_or_palestinian(self, pos, neighborhood):
furthest_empty = None
sorted_spots = self.sort_neighborhood_by_distance(pos, neighborhood)
sorted_spots.reverse()
index = 0
while (furthest_empty is None and index < len(sorted_spots)):
spot = sorted_spots[index]
if self.grid.is_cell_empty(spot) or self.grid[spot[1]][spot[0]].breed == "Palestinian" :
furthest_empty = sorted_spots[index]
index += 1
return furthest_empty
def sort_neighborhood_by_distance(self, from_pos, neighbor_spots):
from_x, from_y = from_pos
return sorted(neighbor_spots, key = lambda spot: self.eucledean_distance(from_x, spot[0], from_y, spot[1], self.grid.width, self.grid.height))
def eucledean_distance(self, x1,x2,y1,y2,w,h):
# http://stackoverflow.com/questions/2123947/calculate-distance-between-two-x-y-coordinates
return math.sqrt(min(abs(x1 - x2), w - abs(x1 - x2)) ** 2 + min(abs(y1 - y2), h - abs(y1-y2)) ** 2)
def step(self):
"""
Advance the model by one step and collect data.
"""
self.violence_count = 0
# for i in range(100):
self.schedule.step()
self.total_violence += self.violence_count
# average = self.violence_count / 100
#print("Violence average %f " % average)
print("Total Violence: ", self.total_violence)
