def build_graph(self):
"""
Arrange all the nodes (or all but one) as a ring.
Then link them depending on the kind of network desired.
"""
nbr_nodes = SimEngine.gui_get(NBR_NODES)
graph_type = SimEngine.gui_get(GRAPH_TYPE)
# If we are generating a star or a wheel network, arrange nbr_nodes-1 as
# a ring and use the other node as the center node.
# If we are generating another type of graph, arrange all the nodes as a ring.
nbr_ring_nodes = (nbr_nodes -
1) if graph_type in ['star', 'wheel'] else nbr_nodes
# create_ordered_agents() creates the indicated number of nodes and arranges
# them in a ring. It returns a list of the nodes in ring-order.
ring_node_list = self.create_ordered_agents(nbr_ring_nodes)
if graph_type in ['star', 'wheel'] and nbr_nodes > 0:
self.create_agents(1)
# Now link the nodes according to the desired graph.
if nbr_nodes:
self.link_nodes_for_graph(graph_type, nbr_nodes, ring_node_list)
def draw_links(links, sleep_time=0.6):
cached_world_links_set = World.links
World.links = set()
gui_set(gui.GOSTOP,
text='pause',
button_color=('white', 'red'),
enabled=True)
gui_set(gui.GO_ONCE, enabled=False)
gui_set(SimEngine.simple_gui.SETUP, enabled=False)
gui_set(SimEngine.simple_gui.EXIT, enabled=False)
paused = False
while links:
(SimEngine.event, SimEngine.values) = gui.WINDOW.read(timeout=10)
if SimEngine.event == gui.GOSTOP:
gui_set(gui.GOSTOP,
text='pause' if paused else 'continue',
button_color=('white', 'red' if paused else 'green'))
paused = not paused
SimEngine.draw_world()
if not paused:
lnk = links.pop(0)
if lnk in World.links:
World.links.remove(lnk)
World.links.add(lnk)
SimEngine.draw_world()
if sleep_time:
sleep(sleep_time)
gui_set(SimEngine.simple_gui.EXIT, enabled=True)
gui_set(gui.GOSTOP,
text='stop',
button_color=('white', 'red'),
enabled=True)
World.links = cached_world_links_set
def force_as_dxdy(pixel_a: Pixel_xy, pixel_b: Pixel_xy,
screen_distance_unit, repulsive):
"""
Compute the force between pixel_a pixel and pixel_b and return it as a velocity: direction * force.
"""
direction: Velocity = normalize_dxdy((
pixel_a - pixel_b) if repulsive else (pixel_b - pixel_a))
d = pixel_a.distance_to(pixel_b, wrap=False)
if repulsive:
dist = max(
1,
pixel_a.distance_to(pixel_b, wrap=False) /
screen_distance_unit)
rep_coefficient = SimEngine.gui_get('rep_coef')
rep_exponent = SimEngine.gui_get('rep_exponent')
force = direction * (10**rep_coefficient) / 10 * dist**rep_exponent
return force
else: # attraction
dist = max(1, max(d, screen_distance_unit) / screen_distance_unit)
att_exponent = SimEngine.gui_get('att_exponent')
force = direction * dist**att_exponent
# If the link is too short, push away instead of attracting.
if d < screen_distance_unit:
force = force * (-1)
att_coefficient = SimEngine.gui_get('att_coef')
return 10**(att_coefficient - 1) * force
def best_random_route(self):
if SimEngine.gui_get(MIDDLE_ROUTE):
if BraessParadoxWorld.middle == 0 or BraessParadoxWorld.top == 0 or BraessParadoxWorld.bottom == 0:
return randint(0, 2)
else:
if randint(0, 99) < 100 - SimEngine.gui_get(RANDOMNESS):
if BraessParadoxWorld.middle < BraessParadoxWorld.top and BraessParadoxWorld.middle < BraessParadoxWorld.bottom:
return 2
else:
if BraessParadoxWorld.top < BraessParadoxWorld.middle and BraessParadoxWorld.top < BraessParadoxWorld.bottom:
return 0
else:
return 1
else:
return randint(0, 2)
else:
if BraessParadoxWorld.top == 0 or BraessParadoxWorld.bottom == 0:
return randint(0, 1)
else:
if randint(0, 99) < 100 - SimEngine.gui_get(RANDOMNESS):
if BraessParadoxWorld.top < BraessParadoxWorld.bottom:
return 0
else:
return 1
else:
return randint(0, 1)
def end_commute(self):
BraessParadoxWorld.travel_time = (World.ticks - self.birth_tick) / 450
if BraessParadoxWorld.avg == 0:
BraessParadoxWorld.avg = BraessParadoxWorld.travel_time
else:
BraessParadoxWorld.avg = ((19 * BraessParadoxWorld.avg + BraessParadoxWorld.travel_time) / 20)
if self.route == 0:
if BraessParadoxWorld.top == 0:
BraessParadoxWorld.top = BraessParadoxWorld.travel_time
else:
BraessParadoxWorld.top = (BraessParadoxWorld.travel_time + (
SimEngine.gui_get(SMOOTHING) - 1) * BraessParadoxWorld.top) / SimEngine.gui_get(SMOOTHING)
else:
if self.route == 1:
if BraessParadoxWorld.bottom == 0:
BraessParadoxWorld.bottom = BraessParadoxWorld.travel_time
else:
BraessParadoxWorld.bottom = (BraessParadoxWorld.travel_time + (
SimEngine.gui_get(SMOOTHING) - 1) * BraessParadoxWorld.bottom) / SimEngine.gui_get(
SMOOTHING)
else:
if BraessParadoxWorld.middle == 0:
BraessParadoxWorld.middle = BraessParadoxWorld.travel_time
else:
BraessParadoxWorld.middle = (BraessParadoxWorld.travel_time + (
SimEngine.gui_get(SMOOTHING) - 1) * BraessParadoxWorld.middle) / SimEngine.gui_get(
SMOOTHING)
# World.agents.remove gave errors, so move the agent to off-road instead
self.move_to_patch(World.patches[BOTTOM_RIGHT + 3])
self.set_heading(0)
print(BraessParadoxWorld.travel_time)
def best_random_route(self):
middle_on = SimEngine.gui_get("middle_on")
randomness = SimEngine.gui_get("randomness")
middle = Commuter_World.middle
bottom = Commuter_World.bot
top = Commuter_World.top
if middle_on:
if middle == 0 or bottom == 0 or top == 0:
return randint(0, 2)
elif randint(0, 100) < (100 - randomness):
if middle < top and middle < bottom:
return 2
elif top < middle and top < bottom:
return 0
else:
return 1
else:
return randint(0, 2)
elif top == 0 or bottom == 0:
return randint(0, 1)
elif randint(0, 100) < (100 - randomness):
if top < bottom:
return 0
else:
return 1
else:
return randint(0, 1)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# self.pos_to_switch is a dictionary that maps position values in a binary number to range(8) represented
# as 3-digit binary strings:
# {1: '000', 2: '001', 4: '010', 8: '011', 16: '100', 32: '101', 64: '110', 128: '111'}
# The three digits are the rule components and the keys to the switches.
# To see it, try: print(self.pos_to_switch) after executing the next line.
# The function bin_str() is defined in utils.py
# The following two lines do the same thing. Explain how both work.
pos_to_switch_a = {2**i: bin_str(i, 3) for i in range(8)}
pos_to_switch_b = dict(zip([2**i for i in range(8)], CA_World.bin_0_to_7))
assert pos_to_switch_a == pos_to_switch_b
self.pos_to_switch = ... # pos_to_switch_a or pos_to_switch_b
# The rule number used for this run, initially set to 110 as the default rule.
# (You might also try rule 165.)
# The following sets the local variable self.rule_nbr. It doesn't change the 'Rule_nbr' slider widget.
self.rule_nbr = 110
# Set the switches and the binary representation of self.rule_nbr.
self.set_switches_from_rule_nbr()
self.set_binary_nbr_from_rule_nbr()
self.init = None
# self.ca_lines is a list of lines, each of which is a list of 0/1. Each line represents
# a state of the CA, i.e., all the cells in the line. self.ca_list contains the entire
# history of the CA.
self.ca_lines: List[List[int]] = []
# gui.WINDOW['rows'].update(value=len(self.ca_lines))
SimEngine.gui_set('rows', value=len(self.ca_lines))
def setup(self):
Agent.id = 0
Minority_Game_World.steps_to_win = SimEngine.get_gui_value(
STEPS_TO_WIN)
# Adjust how far one step is based on number of steps needed to win
Minority_Game_World.one_step = (
gui.PATCH_COLS -
2) * gui.BLOCK_SPACING() / Minority_Game_World.steps_to_win
# For longer/shorter races, speed up/slow down frames/second
gui.set_fps(round(6 * Minority_Game_World.steps_to_win / 50))
# self.done will be True if this a repeat game with the same agents.
if self.done:
self.reset_agents()
return
# This is the normal setup.
Minority_Game_World.nbr_agents = SimEngine.get_gui_value(NBR_AGENTS)
if Minority_Game_World.nbr_agents % 2 == 0:
Minority_Game_World.nbr_agents += (
1 if Minority_Game_World.nbr_agents <
gui.WINDOW[NBR_AGENTS].Range[1] else (-1))
gui.WINDOW[NBR_AGENTS].update(value=Minority_Game_World.nbr_agents)
Minority_Game_World.random_agent_ids = {
0, Minority_Game_World.nbr_agents - 1
}
# Generate a random initial history
self.history_length = SimEngine.get_gui_value(HISTORY_LENGTH)
self.history = [choice([0, 1]) for _ in range(self.history_length)]
self.generate_the_agents()
def select_route(self):
if SimEngine.gui_get(SELECTION_ALGORITHM) == EMPIRICAL_ANALYTICAl:
return self.analytical_route()
if SimEngine.gui_get(SELECTION_ALGORITHM) == PROBABILISTIC_GREEDY:
return self.probabilistic_greedy_route()
if SimEngine.gui_get(SELECTION_ALGORITHM) == BEST_RANDOM:
return self.best_random_route()
def step(self):
"""
Take one step in the simulation.
(a) Generate an additional line for the ca. (Use a copy of self.ca_lines[-1].)
(b) Extend all lines in ca_lines if the new line is longer (with additional 1's) than its predecessor.
(c) Trim the new line and add it to the end of self.ca_lines.
(d) Refresh display from values in self.ca_lines.
"""
# (a)
new_line: str = self.generate_new_line_from_current_line(
self.ca_lines[-1])
# (b)
# Extend lines in self.ca_lines at each end as needed. (Don't extend for extra 0's at the ends.)
# If either end is '1', add '0' to that end of all strings.
# Can't drop the 0's first because we would lose track of which end was extended.
...
# (c)
# ==> String-specific <==
# (Must compare to '1'. Can't just use character as boolean. '0' is treated as True.)
start = 0 if new_line[0] == '1' else 1
end = len(new_line) if new_line[-1] == '1' else len(new_line) - 1
trimmed_new_line: str = new_line[start:end]
# Add trimmed_new_line to the end of self.ca_lines
self.ca_lines.append(trimmed_new_line)
# (d)
# Refresh the display from self.ca_lines
self.set_display_from_lines()
# Update the 'rows' widget.
SimEngine.gui_set('rows', value=...)
def flock(self, showing_flockmates):
# NetLogo allows one to specify the units within the Gui widget.
# Here we do it explicitly by multiplying by BLOCK_SPACING().
vision_limit_in_pixels = SimEngine.gui_get('vision') * BLOCK_SPACING()
flockmates = self.agents_in_radius(vision_limit_in_pixels)
if len(flockmates) > 0:
# If showing_flockmates, create links to flockmates if they don't already exist.
if showing_flockmates:
for flockmate in flockmates:
# Don't make a link if it already exists.
if not link_exists(self, flockmate):
Link(self, flockmate, color=Color('skyblue3'))
nearest_neighbor = min(
flockmates, key=lambda flockmate: self.distance_to(flockmate))
min_separation = SimEngine.gui_get(
'minimum separation') * BLOCK_SPACING()
if self.distance_to(nearest_neighbor) < min_separation:
self.separate(nearest_neighbor)
else:
self.align(flockmates)
self.cohere(flockmates)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# self.pos_to_switch is a dictionary that maps position values in a binary number to range(8) represented
# as 3-digit binary strings:
# {1: '000', 2: '001', 4: '010', 8: '011', 16: '100', 32: '101', 64: '110', 128: '111'}
# The three digits are the rule components and the keys to the switches.
# To see it, try: print(self.pos_to_switch) after executing the next line.
# The function bin_str() is defined in utils.py
self.pos_to_switch = dict(
zip([2**i for i in range(8)], CA_World.bin_0_to_7))
# print(self.pos_to_switch)
# The rule number used for this run, initially set to 110 as the default rule.
# (You might also try rule 165.)
# The following sets the local variable self.rule_nbr. It doesn't change the 'Rule_nbr' slider widget.
self.rule_nbr = 110
# Set the switches and the binary representation of self.rule_nbr.
self.set_switches_from_rule_nbr()
self.set_binary_nbr_from_rule_nbr()
self.init = None
# self.ca_lines is a list of lines, each of which is a list of 0/1. Each line represents
# a state of the CA, i.e., all the cells in the line. self.ca_list contains the entire
# history of the CA.
'''self.ca_lines is that cointains the rows of the 1d automaton, the : in pythion denotes the type that will be assigned to the variable
in this case A list containing a list of integers. It is initializing this list as empty'''
self.ca_lines: List[List[int]] = []
# gui.WINDOW['rows'].update(value=len(self.ca_lines))
'''this line is setting the number of ca_lines, (the number of rows) to the graphical representation of the CA,
which in this case will be 0 since it is currently empty'''
SimEngine.gui_set('rows', value=len(self.ca_lines))
def setup(self):
Agent.id = 1
GA_World.individual_class = TSP_Individual
GA_World.chromosome_class = TSP_Chromosome.factory
# The following GUI elements are defined in ga.py.
# We can't set their default values in this file's GUI.
# The only way to do it is explicitly.
gui_set('Max generations', value=float('inf'))
gui_set('prob_random_parent', value=20)
# Don't display the following standard GA features.
for label in ['Discrep:', 'discrepancy', 'Gens:', 'generations']:
gui_set(label, visible=False)
TSP_Agent.show_labels = gui_get('show_labels')
(SimEngine.event, SimEngine.values) = gui.WINDOW.read(timeout=10)
SimEngine.draw_world()
# auto_setup is initially True (by default). The next line aborts setup in that case.
# The purpose is to allow the system to create a display but not run gen_population,
# which is run when the user clicks setup. That works because auto_setup is set to
# False by SimEngine after setup run, which happens automatically. So, if auto_setup
# is False, we will complete setup and generate the initial population.
if not SimEngine.auto_setup:
self.msp_links = None
if gui_get('Animate construction'):
print(
f'\nGenerating the initial population of {gui_get("pop_size")} paths.'
)
super().setup()
def step(self):
"""
Update the world by moving the agents.
"""
spawn_rate = SimEngine.gui_get('spawn rate')
middle_on = SimEngine.gui_get("middle_on")
delay_on = SimEngine.gui_get("delay")
# check if the checkboxes have changed (Middle On? and Move by Delay?)
World.highway.check_delay(middle_on, delay_on)
World.highway.check_middle(middle_on, delay_on)
# set the route count of each route to 0
World.num_top = 0
World.num_bot = 0
World.num_mid = 0
# move the computers
self.move_commuters()
# set the patch color and patch delay
for patch in World.patches:
if patch.road_type == 1:
patch.determine_congestion(spawn_rate, World.highway, delay_on)
# spawn agents
self.spawn_commuter()
def build_initial_line(self):
"""
Construct the initial CA line.
It is a random line if SimEngine.gui_get('Random?').
It is a line (of length ca_display_size) of 0's if SimEngine.gui_get('init_line') == ''.
Otherwise it is the string in SimEngine.gui_get('init_line') converted into 0's and 1's.
(' ' and '0' are converted to 0; everything else is converted to 1.)
However, if the rule includes 000 -> 1,pad the line with 0's on both ends to fill the display.
How much to put on each end depends on the user-specific initial line and the requested justification.
"""
if SimEngine.gui_get('Random?'):
line = [choice([0, 1]) for _ in range(self.ca_display_size)] if self.lists else \
''.join([choice(['0', '1']) for _ in range(self.ca_display_size)])
else:
padding = self.padding_element * (self.ca_display_size)
if SimEngine.gui_get('init_line') == '':
line = padding
else:
line_0 = SimEngine.gui_get('init_line')
# Convert line_0 to 0's and 1's
# Treat '0' and ' ' as "not on".
line = [0 if c in ' 0' else 1 for c in line_0] if self.lists else \
''.join(['0' if c in ' 0' else '1' for c in line_0])
if SimEngine.gui_get('000'):
justification = SimEngine.gui_get('justification')
line_len = len(line)
actual_padding = padding[line_len:]
line = actual_padding + line if justification == 'Right' else \
line + actual_padding if justification == 'Left' else \
actual_padding[len(actual_padding)//2:] + line + actual_padding[len(actual_padding)//2:]
return line
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# self.pos_to_switch is a dictionary that maps position values in a binary number to range(8) represented
# as 3-digit binary strings:
# {1: '000', 2: '001', 4: '010', 8: '011', 16: '100', 32: '101', 64: '110', 128: '111'}
# The three digits are the rule components and the keys to the switches.
# To see it, try: print(self.pos_to_switch) after executing the next line.
# The function bin_str() is defined in utils.py
# self.pos_to_switch0 = {2**i: bin_str(i, 3) for i in range(8)}
self.pos_to_switch = dict(
zip([2**i for i in range(8)], CA_World.bin_0_to_7))
# print(self.pos_to_switch0 == self.pos_to_switch)
# The rule number used for this run, initially set to 110 as the default rule.
# (You might also try rule 165.)
# The following sets the local variable self.rule_nbr. It doesn't change the 'Rule_nbr' slider widget.
self.rule_nbr = 110
# Set the switches and the binary representation of self.rule_nbr.
self.set_switches_from_rule_nbr()
self.set_binary_nbr_from_rule_nbr()
# self.ca_lines is a list of lines, each of which is a list or string of 0/1. Each line
# representsa state of the CA, i.e., all the symbols in the line. self.ca_list contains
# the entire history of the CA.
self.lists = None
self.padding_element = None
self.ca_lines = []
SimEngine.gui_set('rows', value=len(self.ca_lines))
def spawn_commuters(self):
if self.spawn_time >= 250//SimEngine.gui_get('spawn_rate'):
time = 0
if SimEngine.gui_get('mode') == selfish:
route, time = self.route_dict[SimEngine.gui_get('mode')]()
else:
route = self.route_dict[SimEngine.gui_get('mode')]()
# self.agent_class() creates a class at a certain pixel.
# This line creates an agent at the center pixel of the top left patch.
new_commuter: Commuter = self.agent_class(spawn_pixel=self.top_left_center_pixel, speed=0.0, birth_tick=self.ticks)
new_commuter.route = route
new_commuter.base_speed = new_commuter.base_speed - time
new_commuter.speed = new_commuter.base_speed
if new_commuter.route in (middle_road, dynamic_road):
new_commuter.face_xy(self.top_right_center_pixel)
# Static Route
else:
new_commuter.face_xy(self.bottom_left_center_pixel)
self.spawn_time = 1
else:
self.spawn_time += 1
# Note we probably won't use 250.
# track spawn-time, if spawn-time is greater than 250 / spawn-rate,
# at the patch in the upper left corner, spawn a commuter
# with several values associated with time spawned, the time it is still commuting,
# the route it will take, and it's behavior when choosing a route
pass
def determine_congestion(self):
'''Determines the congestion in the top and bottom road segments'''
#calculate congestion for the top road
#patches in the top road
top_road = self.patches_line(self.top_left_patch,
self.top_right_patch)[1:-1]
top_road_commuters = [
x for x in World.agents if x.current_patch() in top_road
]
delay = len(top_road_commuters) * SimEngine.gui_get(
VARIABLE_CONGESTION_DELAY)
# print(len(top_road_commuters))
for patch in top_road:
patch.delay = delay
#calcultate the congestion for the bottom road
delay = 1
bottom_road = self.patches_line(self.bottom_left_patch,
self.bottom_right_patch)[1:-1]
bottom_road_commuters = [
x for x in World.agents if x.current_patch() in bottom_road
]
delay = len(bottom_road_commuters) * SimEngine.gui_get(
VARIABLE_CONGESTION_DELAY)
for patch in bottom_road:
patch.delay = delay
def select_route(self):
if SimEngine.gui_get(SELECTION_ALGORITHM) == EMPIRICAL_ANALYTICAl:
return self.probabilistic_analytic()
if SimEngine.gui_get(SELECTION_ALGORITHM) == PROBABILISTIC_GREEDY:
return self.greedy()
if SimEngine.gui_get(SELECTION_ALGORITHM) == BEST_KNOWN:
return self.best_route()
def setup(self):
"""
Set up for state 1. Build the contraption piece by piece.
"""
self.top_spring = Braess_Link.vertical_linked_nodes(Braess_Link, self.x, Braess_World.top)
self.top_cord = self.top_spring.extend_linked_nodes(Braess_Cord)
self.bottom_spring = self.top_cord.extend_linked_nodes(Braess_Link)
self.weight_cord = self.bottom_spring.extend_linked_nodes(Braess_Cord)
# Make node_2 of the weight_cord the weight.
Braess_World.weight_node = self.weight_cord.node_2
Braess_World.weight_node.shape_name = CIRCLE
Braess_World.weight_node.color = Color('plum4')
# ## Done with building state 1. ## #
self.adjustable_links = [self.top_spring, self.top_cord, self.bottom_spring, self.weight_cord]
SimEngine.gui_set(Braess_World.CUT_CORD, enabled=False)
Braess_World.state = 1
Agent.some_agent_changed = True
# In case we did the animation in slow motion and this is a second run.
# Can't do this when animation ends because we want to stay
# in slow motion as the springs contract and lift the weight.
SimEngine.fps = 60
def step(self):
# If we are doing animation:
if Braess_World.state == 'a':
if not Agent.key_step_done:
Agent.run_an_animation_step()
else:
self.setup_2()
return
# We are not doing animation. We are in either state_1 or state_2. Process them normally.
# If there was a change during the previous step, see if additional changes are needed.
if Agent.some_agent_changed:
# When a link changes length, Agent.some_agent_changed is set to True.
Agent.some_agent_changed = False
for lnk in self.adjustable_links:
lnk.adjust_nodes()
else:
# Since no agent changed on the previous step, we're done with this state.
# "Click" the STOP button.
gui.WINDOW[GOSTOP].click()
# Enable/disable the Cut-cord button depending on whether we are leaving state 1.
SimEngine.gui_set(Braess_World.CUT_CORD, enabled=(Braess_World.state == 1))
def determine_congestion(self):
trafic_variable_top_road = self.draw_line(self.top_left,
self.top_right)[1:-1]
trafic_variable_top_road_commuters = [
x for x in World.agents
if x.current_patch() in trafic_variable_top_road
]
delay = len(trafic_variable_top_road_commuters) * SimEngine.gui_get(
VARIABLE_CONGESTION_DELAY)
for patch in trafic_variable_top_road:
patch.delay = delay
#calcultate the congestion for the bottom road
delay = 1
bottom_road = self.draw_line(self.bottom_left, self.bottom_right)[1:-1]
bottom_road_commuters = [
x for x in World.agents if x.current_patch() in bottom_road
]
delay = len(bottom_road_commuters) * SimEngine.gui_get(
VARIABLE_CONGESTION_DELAY)
for patch in bottom_road:
patch.delay = delay
def build_initial_line(self):
"""
Construct the initial CA line.
It is a random line if SimEngine.gui_get('Random?').
It is a line (of length ca_display_size) if SimEngine.gui_get('init_line') == ''.
Otherwise it is the string in SimEngine.gui_get('init_line') converted into 0's and 1's.
(' ' and '0' are converted to 0; everything else is converted to 1.)
However, if the rule includes 000 -> 1,pad the line with 0's on both ends to fill the display.
How much to put on each end depends on the user-specific initial line and the requested justification.
"""
if SimEngine.gui_get('Random?'):
line = ...
else:
# A line of 0's.
padding = [0] * (self.ca_display_size)
if SimEngine.gui_get('init_line') == '':
line = padding
else:
line_0 = SimEngine.gui_get('init_line')
# Convert line_0 to 0's and 1's
line = [... for c in line_0]
# If the rule include 000 -> 1, fill out the new line with 0's.
if SimEngine.gui_get('000'):
justification = SimEngine.gui_get('justification')
line_len = len(line)
actual_padding = padding[line_len:]
line = ... if justification == 'Right' else \
... if justification == 'Left' else \
... # justification == 'Center'
return line
def selfish_route(self):
agents_on_dynamic_road = 0
agents_on_static_road = 0
agents_on_middle_road = 0
for commuter in self.agents:
if commuter.route == dynamic_road:
agents_on_dynamic_road += 1
elif commuter.route == static_road:
agents_on_static_road += 1
else:
agents_on_middle_road += 1
static_road_rate = SimEngine.gui_get('static')
dynamic_road_rate = SimEngine.gui_get('dynamic')
static_road_time = static_road_rate + (
agents_on_middle_road + agents_on_static_road) / dynamic_road_rate
middle_road_time = ((agents_on_dynamic_road + agents_on_middle_road) / dynamic_road_rate) \
+ ((agents_on_static_road + agents_on_middle_road) / dynamic_road_rate)
dynamic_road_time = (agents_on_dynamic_road /
dynamic_road_rate) + static_road_rate
if SimEngine.gui_get('middle_on'):
three_roads = [(static_road, static_road_time / 20),
(middle_road, middle_road_time / 20),
(dynamic_road, dynamic_road_time / 20)]
selection = min(three_roads, key=lambda x: x[1])
else:
two_roads = [(static_road, static_road_time / 20),
(dynamic_road, dynamic_road_time / 20)]
selection = min(two_roads, key=lambda x: x[1])
return selection
def PyLogo(world_class=World,
caption=None,
gui_left_upper=None,
gui_right_upper=None,
agent_class=Agent,
patch_class=Patch,
auto_setup=True,
patch_size=11,
board_rows_cols=(51, 51),
clear=None,
bounce=None,
fps=None):
if gui_left_upper is None:
gui_left_upper = []
if caption is None:
caption = utils.extract_class_name(world_class)
sim_engine = SimEngine(gui_left_upper,
caption=caption,
gui_right_upper=gui_right_upper,
patch_size=patch_size,
board_rows_cols=board_rows_cols,
clear=clear,
bounce=bounce,
fps=fps)
gui.WINDOW.read(timeout=10)
the_world = world_class(patch_class, agent_class)
gui.WINDOW.read(timeout=10)
sim_engine.top_loop(the_world, auto_setup=auto_setup)
def make_switches_and_rule_nbr_consistent(self):
"""
Make the Slider, the switches, and the bin number consistent: all should contain self.rule_nbr.
"""
# gui.WINDOW['Rule_nbr'].update(value=self.rule_nbr)
SimEngine.gui_set('Rule_nbr', value=self.rule_nbr)
self.set_switches_from_rule_nbr()
self.set_binary_nbr_from_rule_nbr()
def mutate(self) -> Individual:
if randint(0, 100) <= SimEngine.gui_get('replace_gene'):
(self.chromosome, self.fitness, _) = self.replace_gene_in_chromosome(self.fitness, self.chromosome)
if randint(0, 100) <= SimEngine.gui_get('reverse_subseq'):
self.chromosome = self.reverse_subseq(self.chromosome)
self.fitness = self.compute_fitness()
return self
def __init__(self, **kwargs):
color = SimEngine.gui_get(COLOR)
color = Color(color) if color != RANDOM else None
if 'shape_name' not in kwargs:
shape_name = SimEngine.gui_get(SHAPE)
kwargs['shape_name'] = shape_name
super().__init__(color=color, **kwargs)
# Is the node selected?
self.selected = False
def init_globals(self):
gb.randomness = SimEngine.gui_get('Randomness')
gb.mode = SimEngine.gui_get('Algorithm')
gb.middle_on = SimEngine.gui_get('Middle')
gb.spawn_rate = SimEngine.gui_get('Spawn Rate')
gb.smoothing = SimEngine.gui_get('Smoothing')
gb.top_left = World.patches_array[4, 4]
gb.top_right = World.patches_array[4, 46]
gb.bottom_right = World.patches_array[46, 46]
gb.bottom_left = World.patches_array[46, 4]
def setup(self):
# Create a list of Individuals as the initial population.
# self.pop_size must be even since we generate children two at a time.
self.pop_size = (SimEngine.gui_get('pop_size')//2)*2
self.tournament_size = SimEngine.gui_get('tourn_size')
GA_World.fitness_target = SimEngine.gui_get('fitness_target')
self.population = self.initial_population()
self.best_ind = None
self.generations = 0
self.set_results()
