class Money_Model(Model):
def __init__(self, N, width=50, height=50, torus=True):
self.num_agents = N
self.schedule = RandomActivation(self)
self.grid = MultiGrid(height, width, torus)
self.create_agents()
self.dc = DataCollector({"Gini": lambda m: m.compute_gini()},
{"Wealth": lambda a: a.wealth})
self.running = True
def create_agents(self):
for i in range(self.num_agents):
a = Money_Agent(i)
self.schedule.add(a)
x = random.randrange(self.grid.width)
y = random.randrange(self.grid.height)
self.grid.place_agent(a, (x, y))
def step(self):
self.dc.collect(self)
self.schedule.step()
def run_model(self, steps):
for i in range(steps):
self.step()
def compute_gini(self):
agent_wealths = [agent.wealth for agent in self.schedule.agents]
x = sorted(agent_wealths)
N = self.num_agents
B = sum( xi * (N-i) for i,xi in enumerate(x) ) / (N*sum(x))
return (1 + (1/N) - 2*B)
class MoneyModel(Model):
"""A simple model of an economy where agents exchange currency at random.
All the agents begin with one unit of currency, and each time step can give
a unit of currency to another agent. Note how, over time, this produces a
highly skewed distribution of wealth.
"""
def __init__(self, N, width, height):
self.num_agents = N
self.running = True
self.grid = MultiGrid(height, width, True)
self.schedule = RandomActivation(self)
self.datacollector = DataCollector(
model_reporters={"Gini": compute_gini},
agent_reporters={"Wealth": lambda a: a.wealth}
)
# Create agents
for i in range(self.num_agents):
a = MoneyAgent(i, self)
self.schedule.add(a)
# Add the agent to a random grid cell
x = random.randrange(self.grid.width)
y = random.randrange(self.grid.height)
self.grid.place_agent(a, (x, y))
def step(self):
self.datacollector.collect(self)
self.schedule.step()
def run_model(self, n):
for i in range(n):
self.step()
开发者ID:GeoESW，项目名称:mesa，代码行数:33，代码来源:model.py
示例4: MoneyModel
class MoneyModel(Model):
"""A model with some number of agents."""
def __init__(self, N, width, height):
self.num_agents = N
self.running = True
self.grid = MultiGrid(height, width, True)
self.schedule = RandomActivation(self)
self.datacollector = DataCollector(model_reporters={"Gini": compute_gini},
agent_reporters={"Wealth": lambda a: a.wealth})
# Create agents
for i in range(self.num_agents):
a = MoneyAgent(i)
self.schedule.add(a)
# Add the agent to a random grid cell
x = random.randrange(self.grid.width)
y = random.randrange(self.grid.height)
self.grid.place_agent(a, (x, y))
def step(self):
self.datacollector.collect(self)
self.schedule.step()
def run_model(self, n):
for i in range(n):
self.step()
class Charts(Model):
# grid height
grid_h = 20
# grid width
grid_w = 20
"""init parameters "init_people", "rich_threshold", and "reserve_percent"
are all UserSettableParameters"""
def __init__(self, height=grid_h, width=grid_w, init_people=2, rich_threshold=10,
reserve_percent=50,):
self.height = height
self.width = width
self.init_people = init_people
self.schedule = RandomActivation(self)
self.grid = MultiGrid(self.width, self.height, torus=True)
# rich_threshold is the amount of savings a person needs to be considered "rich"
self.rich_threshold = rich_threshold
self.reserve_percent = reserve_percent
# see datacollector functions above
self.datacollector = DataCollector(model_reporters={
"Rich": get_num_rich_agents,
"Poor": get_num_poor_agents,
"Middle Class": get_num_mid_agents,
"Savings": get_total_savings,
"Wallets": get_total_wallets,
"Money": get_total_money,
"Loans": get_total_loans},
agent_reporters={
"Wealth": lambda x: x.wealth})
# create a single bank for the model
self.bank = Bank(1, self, self.reserve_percent)
# create people for the model according to number of people set by user
for i in range(self.init_people):
# set x, y coords randomly within the grid
x = self.random.randrange(self.width)
y = self.random.randrange(self.height)
p = Person(i, (x, y), self, True, self.bank, self.rich_threshold)
# place the Person object on the grid at coordinates (x, y)
self.grid.place_agent(p, (x, y))
# add the Person object to the model schedule
self.schedule.add(p)
self.running = True
self.datacollector.collect(self)
def step(self):
# tell all the agents in the model to run their step function
self.schedule.step()
# collect data
self.datacollector.collect(self)
def run_model(self):
for i in range(self.run_time):
self.step()
开发者ID:projectmesa，项目名称:mesa，代码行数:57，代码来源:model.py
示例6: TestMultiGrid
class TestMultiGrid(unittest.TestCase):
'''
Testing a toroidal MultiGrid
'''
torus = True
def setUp(self):
'''
Create a test non-toroidal grid and populate it with Mock Agents
'''
width = 3
height = 5
self.grid = MultiGrid(width, height, self.torus)
self.agents = []
counter = 0
for x in range(width):
for y in range(height):
for i in range(TEST_MULTIGRID[x][y]):
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_agent_positions(self):
'''
Ensure that the agents are all placed properly on the MultiGrid.
'''
for agent in self.agents:
x, y = agent.pos
assert agent in self.grid[x][y]
def test_neighbors(self):
'''
Test the toroidal MultiGrid neighborhood methods.
'''
neighborhood = self.grid.get_neighborhood((1, 1), moore=True)
assert len(neighborhood) == 8
neighborhood = self.grid.get_neighborhood((1, 4), moore=True)
assert len(neighborhood) == 8
neighborhood = self.grid.get_neighborhood((0, 0), moore=False)
assert len(neighborhood) == 4
neighbors = self.grid.get_neighbors((1, 4), moore=False)
assert len(neighbors) == 0
neighbors = self.grid.get_neighbors((1, 4), moore=True)
assert len(neighbors) == 5
neighbors = self.grid.get_neighbors((1, 1), moore=False,
include_center=True)
assert len(neighbors) == 7
neighbors = self.grid.get_neighbors((1, 3), moore=False, radius=2)
assert len(neighbors) == 11
def __init__(self, height=20, width=20,
initial_sheep=100, initial_wolves=50, sheep_reproduce=0.04,
wolf_reproduce=0.05, wolf_gain_from_food=20,
grass=False, sheep_gain_from_food=4):
'''
Create a new Wolf-Sheep model with the given parameters.
Args:
initial_sheep: Number of sheep to start with
initial_wolves: Number of wolves to start with
sheep_reproduce: Probability of each sheep reproducing each step
wolf_reproduce: Probability of each wolf reproducing each step
wolf_gain_from_food: Energy a wolf gains from eating a sheep
grass: Whether to have the sheep eat grass for energy
sheep_gain_from_food: Energy sheep gain from grass, if enabled.
'''
# Set parameters
self.height = height
self.width = width
self.initial_sheep = initial_sheep
self.initial_wolves = initial_wolves
self.sheep_reproduce = sheep_reproduce
self.wolf_reproduce = wolf_reproduce
self.wolf_gain_from_food = wolf_gain_from_food
self.grass = grass
self.sheep_gain_from_food = sheep_gain_from_food
self.schedule = RandomActivation(self)
self.grid = MultiGrid(self.height, self.width, torus=True)
# Create sheep:
for i in range(self.initial_sheep):
x = random.randrange(self.width)
y = random.randrange(self.height)
sheep = Sheep(self.grid, x, y, True)
self.grid.place_agent(sheep, (x, y))
self.schedule.add(sheep)
# Create wolves
for i in range(self.initial_wolves):
x = random.randrange(self.width)
y = random.randrange(self.height)
energy = random.randrange(2 * self.wolf_gain_from_food)
wolf = Wolf(self.grid, x, y, True, energy)
self.grid.place_agent(wolf, (x, y))
self.schedule.add(wolf)
self.running = True
def setUp(self):
'''
Create a test non-toroidal grid and populate it with Mock Agents
'''
self.grid = MultiGrid(3, 5, self.torus)
self.agents = []
counter = 0
for y in range(3):
for x in range(5):
for i in range(TEST_MULTIGRID[y][x]):
counter += 1
# Create and place the mock agent
a = MockAgent(counter, None)
self.agents.append(a)
self.grid.place_agent(a, (x, y))
def setUp(self):
'''
Create a test non-toroidal grid and populate it with Mock Agents
'''
width = 3
height = 5
self.grid = MultiGrid(width, height, self.torus)
self.agents = []
counter = 0
for x in range(width):
for y in range(height):
for i in range(TEST_MULTIGRID[x][y]):
counter += 1
# Create and place the mock agent
a = MockAgent(counter, None)
self.agents.append(a)
self.grid.place_agent(a, (x, y))
开发者ID:GeoESW，项目名称:mesa，代码行数:17，代码来源:test_grid.py
示例11: __init__
def __init__(self, N, width, height):
self.num_agents = N
self.running = True
self.grid = MultiGrid(height, width, True)
self.schedule = RandomActivation(self)
self.datacollector = DataCollector(
model_reporters={"Gini": compute_gini},
agent_reporters={"Wealth": lambda a: a.wealth}
)
# Create agents
for i in range(self.num_agents):
a = MoneyAgent(i, self)
self.schedule.add(a)
# Add the agent to a random grid cell
x = random.randrange(self.grid.width)
y = random.randrange(self.grid.height)
self.grid.place_agent(a, (x, y))
def __init__(self, height=grid_h, width=grid_w, init_people=2, rich_threshold=10,
reserve_percent=50,):
self.uid = next(self.id_gen)
self.height = height
self.width = width
self.init_people = init_people
self.schedule = RandomActivation(self)
self.grid = MultiGrid(self.width, self.height, torus=True)
# rich_threshold is the amount of savings a person needs to be considered "rich"
self.rich_threshold = rich_threshold
self.reserve_percent = reserve_percent
# see datacollector functions above
self.datacollector = DataCollector(model_reporters={
"Rich": get_num_rich_agents,
"Poor": get_num_poor_agents,
"Middle Class": get_num_mid_agents,
"Savings": get_total_savings,
"Wallets": get_total_wallets,
"Money": get_total_money,
"Loans": get_total_loans,
"Model Params": track_params,
"Run": track_run},
agent_reporters={
"Wealth": lambda x: x.wealth})
# create a single bank for the model
self.bank = Bank(1, self, self.reserve_percent)
# create people for the model according to number of people set by user
for i in range(self.init_people):
# set x coordinate as a random number within the width of the grid
x = self.random.randrange(self.width)
# set y coordinate as a random number within the height of the grid
y = self.random.randrange(self.height)
p = Person(i, (x, y), self, True, self.bank, self.rich_threshold)
# place the Person object on the grid at coordinates (x, y)
self.grid.place_agent(p, (x, y))
# add the Person object to the model schedule
self.schedule.add(p)
self.running = True
def __init__(self, width = 0, height = 0, torus = False,
time = 0, step_in_year = 0,
number_of_families = family_setting, number_of_monkeys = 0, monkey_birth_count = 0,
monkey_death_count = 0, monkey_id_count = 0,
number_of_humans = 0, grid_type = human_setting, run_type = run_setting, human_id_count = 0):
# change the # of families here for graph.py, but use server.py to change # of families in the movement model
# torus = False means monkey movement can't 'wrap around' edges
super().__init__()
self.width = width
self.height = height
self.time = time # time increases by 1/73 (decimal) each step
self.step_in_year = step_in_year # 1-73; each step is 5 days, and 5 * 73 = 365 days in a year
self.number_of_families = number_of_families
self.number_of_monkeys = number_of_monkeys # total, not in each family
self.monkey_birth_count = monkey_birth_count
self.monkey_death_count = monkey_death_count
self.monkey_id_count = monkey_id_count
self.number_of_humans = number_of_humans
self.grid_type = grid_type # string 'with_humans' or 'without_humans'
self.run_type = run_type # string with 'normal_run' or 'first_run'
self.human_id_count = human_id_count
# width = self._readASCII(vegetation_file)[1] # width as listed at the beginning of the ASCII file
# height = self._readASCII(vegetation_file)[2] # height as listed at the beginning of the ASCII file
width = 85
height = 100
self.grid = MultiGrid(width, height, torus) # creates environmental grid, sets schedule
# MultiGrid is a Mesa function that sets up the grid; options are between SingleGrid and MultiGrid
# MultiGrid allows you to put multiple layers on the grid
self.schedule = RandomActivation(self) # Mesa: Random vs. Staged Activation
# similar to NetLogo's Ask Agents - determines order (or lack of) in which each agents act
empty_masterdict = {'Outside_FNNR': [], 'Elevation_Out_of_Bound': [], 'Household': [], 'PES': [], 'Farm': [],
'Forest': [], 'Bamboo': [], 'Coniferous': [], 'Broadleaf': [], 'Mixed': [], 'Lichen': [],
'Deciduous': [], 'Shrublands': [], 'Clouds': [], 'Farmland': []}
# generate land
if self.run_type == 'first_run':
gridlist = self._readASCII(vegetation_file)[0] # list of all coordinate values; see readASCII function
gridlist2 = self._readASCII(elevation_file)[0] # list of all elevation values
gridlist3 = self._readASCII(household_file)[0] # list of all household coordinate values
gridlist4 = self._readASCII(pes_file)[0] # list of all PES coordinate values
gridlist5 = self._readASCII(farm_file)[0] # list of all farm coordinate values
gridlist6 = self._readASCII(forest_file)[0] # list of all managed forest coordinate values
# The '_populate' function below builds the environmental grid.
for x in [Elevation_Out_of_Bound]:
self._populate(empty_masterdict, gridlist2, x, width, height)
for x in [Household]:
self._populate(empty_masterdict, gridlist3, x, width, height)
for x in [PES]:
self._populate(empty_masterdict, gridlist4, x, width, height)
for x in [Farm]:
self._populate(empty_masterdict, gridlist5, x, width, height)
for x in [Forest]:
self._populate(empty_masterdict, gridlist6, x, width, height)
for x in [Bamboo, Coniferous, Broadleaf, Mixed, Lichen, Deciduous,
Shrublands, Clouds, Farmland, Outside_FNNR]:
self._populate(empty_masterdict, gridlist, x, width, height)
self.saveLoad(empty_masterdict, 'masterdict_veg', 'save')
self.saveLoad(self.grid, 'grid_veg', 'save')
self.saveLoad(self.schedule, 'schedule_veg', 'save')
# Pickling below
load_dict = {} # placeholder for model parameters, leave this here even though it does nothing
if self.grid_type == 'with_humans':
empty_masterdict = self.saveLoad(load_dict, 'masterdict_veg', 'load')
self.grid = self.saveLoad(self.grid, 'grid_veg', 'load')
if self.grid_type == 'without_humans':
empty_masterdict = self.saveLoad(load_dict, 'masterdict_without_humans', 'load')
self.grid = self.saveLoad(load_dict, 'grid_without_humans', 'load')
masterdict = empty_masterdict
startinglist = masterdict['Broadleaf'] + masterdict['Mixed'] + masterdict['Deciduous']
# Agents will start out in high-probability areas.
for coordinate in masterdict['Elevation_Out_of_Bound'] + masterdict['Household'] + masterdict['PES'] \
+ masterdict['Farm'] + masterdict['Forest']:
if coordinate in startinglist:
startinglist.remove(coordinate)
# Creation of resources (yellow dots in simulation)
# These include Fuelwood, Herbs, Bamboo, etc., but right now resource type and frequency are not used
if self.grid_type == 'with_humans':
for line in _readCSV('hh_survey.csv')[1:]: # see 'hh_survey.csv'
hh_id_match = int(line[0])
resource_name = line[1] # frequency is monthly; currently not-used
frequency = float(line[2]) / 6 # divided by 6 for 5-day frequency, as opposed to 30-day (1 month)
y = int(line[5])
x = int(line[6])
resource = Resource(_readCSV('hh_survey.csv')[1:].index(line),
self, (x, y), hh_id_match, resource_name, frequency)
self.grid.place_agent(resource, (int(x), int(y)))
resource_dict.setdefault(hh_id_match, []).append(resource)
if self.run_type == 'first_run':
self.saveLoad(resource_dict, 'resource_dict', 'save')
# Creation of land parcels
land_parcel_count = 0
#.........这里部分代码省略.........
def __init__(self, height=20, width=20,
initial_sheep=100, initial_wolves=50,
sheep_reproduce=0.04, wolf_reproduce=0.05,
wolf_gain_from_food=20,
grass=False, grass_regrowth_time=30, sheep_gain_from_food=4):
'''
Create a new Wolf-Sheep model with the given parameters.
Args:
initial_sheep: Number of sheep to start with
initial_wolves: Number of wolves to start with
sheep_reproduce: Probability of each sheep reproducing each step
wolf_reproduce: Probability of each wolf reproducing each step
wolf_gain_from_food: Energy a wolf gains from eating a sheep
grass: Whether to have the sheep eat grass for energy
grass_regrowth_time: How long it takes for a grass patch to regrow
once it is eaten
sheep_gain_from_food: Energy sheep gain from grass, if enabled.
'''
super().__init__()
# Set parameters
self.height = height
self.width = width
self.initial_sheep = initial_sheep
self.initial_wolves = initial_wolves
self.sheep_reproduce = sheep_reproduce
self.wolf_reproduce = wolf_reproduce
self.wolf_gain_from_food = wolf_gain_from_food
self.grass = grass
self.grass_regrowth_time = grass_regrowth_time
self.sheep_gain_from_food = sheep_gain_from_food
self.schedule = RandomActivationByBreed(self)
self.grid = MultiGrid(self.height, self.width, torus=True)
self.datacollector = DataCollector(
{"Wolves": lambda m: m.schedule.get_breed_count(Wolf),
"Sheep": lambda m: m.schedule.get_breed_count(Sheep)})
# Create sheep:
for i in range(self.initial_sheep):
x = self.random.randrange(self.width)
y = self.random.randrange(self.height)
energy = self.random.randrange(2 * self.sheep_gain_from_food)
sheep = Sheep(self.next_id(), (x, y), self, True, energy)
self.grid.place_agent(sheep, (x, y))
self.schedule.add(sheep)
# Create wolves
for i in range(self.initial_wolves):
x = self.random.randrange(self.width)
y = self.random.randrange(self.height)
energy = self.random.randrange(2 * self.wolf_gain_from_food)
wolf = Wolf(self.next_id(), (x, y), self, True, energy)
self.grid.place_agent(wolf, (x, y))
self.schedule.add(wolf)
# Create grass patches
if self.grass:
for agent, x, y in self.grid.coord_iter():
fully_grown = self.random.choice([True, False])
if fully_grown:
countdown = self.grass_regrowth_time
else:
countdown = self.random.randrange(self.grass_regrowth_time)
patch = GrassPatch(self.next_id(), (x, y), self,
fully_grown, countdown)
self.grid.place_agent(patch, (x, y))
self.schedule.add(patch)
self.running = True
self.datacollector.collect(self)
开发者ID:bangtree，项目名称:mesa，代码行数:74，代码来源:model.py
示例17: WolfSheep
class WolfSheep(Model):
'''
Wolf-Sheep Predation Model
'''
height = 20
width = 20
initial_sheep = 100
initial_wolves = 50
sheep_reproduce = 0.04
wolf_reproduce = 0.05
wolf_gain_from_food = 20
grass = False
grass_regrowth_time = 30
sheep_gain_from_food = 4
verbose = False # Print-monitoring
description = 'A model for simulating wolf and sheep (predator-prey) ecosystem modelling.'
def __init__(self, height=20, width=20,
initial_sheep=100, initial_wolves=50,
sheep_reproduce=0.04, wolf_reproduce=0.05,
wolf_gain_from_food=20,
grass=False, grass_regrowth_time=30, sheep_gain_from_food=4):
'''
Create a new Wolf-Sheep model with the given parameters.
Args:
initial_sheep: Number of sheep to start with
initial_wolves: Number of wolves to start with
sheep_reproduce: Probability of each sheep reproducing each step
wolf_reproduce: Probability of each wolf reproducing each step
wolf_gain_from_food: Energy a wolf gains from eating a sheep
grass: Whether to have the sheep eat grass for energy
grass_regrowth_time: How long it takes for a grass patch to regrow
once it is eaten
sheep_gain_from_food: Energy sheep gain from grass, if enabled.
'''
super().__init__()
# Set parameters
self.height = height
self.width = width
self.initial_sheep = initial_sheep
self.initial_wolves = initial_wolves
self.sheep_reproduce = sheep_reproduce
self.wolf_reproduce = wolf_reproduce
self.wolf_gain_from_food = wolf_gain_from_food
self.grass = grass
self.grass_regrowth_time = grass_regrowth_time
self.sheep_gain_from_food = sheep_gain_from_food
self.schedule = RandomActivationByBreed(self)
self.grid = MultiGrid(self.height, self.width, torus=True)
self.datacollector = DataCollector(
{"Wolves": lambda m: m.schedule.get_breed_count(Wolf),
"Sheep": lambda m: m.schedule.get_breed_count(Sheep)})
# Create sheep:
for i in range(self.initial_sheep):
x = self.random.randrange(self.width)
y = self.random.randrange(self.height)
energy = self.random.randrange(2 * self.sheep_gain_from_food)
sheep = Sheep(self.next_id(), (x, y), self, True, energy)
self.grid.place_agent(sheep, (x, y))
self.schedule.add(sheep)
# Create wolves
for i in range(self.initial_wolves):
x = self.random.randrange(self.width)
y = self.random.randrange(self.height)
energy = self.random.randrange(2 * self.wolf_gain_from_food)
wolf = Wolf(self.next_id(), (x, y), self, True, energy)
self.grid.place_agent(wolf, (x, y))
self.schedule.add(wolf)
# Create grass patches
if self.grass:
for agent, x, y in self.grid.coord_iter():
fully_grown = self.random.choice([True, False])
if fully_grown:
countdown = self.grass_regrowth_time
else:
countdown = self.random.randrange(self.grass_regrowth_time)
patch = GrassPatch(self.next_id(), (x, y), self,
fully_grown, countdown)
self.grid.place_agent(patch, (x, y))
self.schedule.add(patch)
self.running = True
self.datacollector.collect(self)
def step(self):
#.........这里部分代码省略.........
开发者ID:bangtree，项目名称:mesa，代码行数:101，代码来源:model.py
示例18: Sugarscape2ConstantGrowback
class Sugarscape2ConstantGrowback(Model):
'''
Sugarscape 2 Constant Growback
'''
verbose = True # Print-monitoring
def __init__(self, height=50, width=50,
initial_population=100):
'''
Create a new Constant Growback model with the given parameters.
Args:
initial_population: Number of population to start with
'''
# Set parameters
self.height = height
self.width = width
self.initial_population = initial_population
self.schedule = RandomActivationByBreed(self)
self.grid = MultiGrid(self.height, self.width, torus=False)
self.datacollector = DataCollector({"SsAgent": lambda m: m.schedule.get_breed_count(SsAgent), })
# Create sugar
import numpy as np
sugar_distribution = np.genfromtxt("sugarscape/sugar-map.txt")
for _, x, y in self.grid.coord_iter():
max_sugar = sugar_distribution[x, y]
sugar = Sugar((x, y), self, max_sugar)
self.grid.place_agent(sugar, (x, y))
self.schedule.add(sugar)
# Create agent:
for i in range(self.initial_population):
x = random.randrange(self.width)
y = random.randrange(self.height)
sugar = random.randrange(6, 25)
metabolism = random.randrange(2, 4)
vision = random.randrange(1, 6)
ssa = SsAgent((x, y), self, False, sugar, metabolism, vision)
self.grid.place_agent(ssa, (x, y))
self.schedule.add(ssa)
self.running = True
def step(self):
self.schedule.step()
self.datacollector.collect(self)
if self.verbose:
print([self.schedule.time,
self.schedule.get_breed_count(SsAgent)])
def run_model(self, step_count=200):
if self.verbose:
print('Initial number Sugarscape Agent: ',
self.schedule.get_breed_count(SsAgent))
for i in range(step_count):
self.step()
if self.verbose:
print('')
print('Final number Sugarscape Agent: ',
self.schedule.get_breed_count(SsAgent))
开发者ID:GeoESW，项目名称:mesa，代码行数:67，代码来源:model.py
示例19: Trade
class Trade(Model):
verbose = False # Print-monitoring
os.chdir(os.path.dirname(__file__))
fpath = os.getcwd() + '/parameters.csv'
reader = csv.reader(open(fpath, 'r'))
d = dict()
for key, value in reader:
d[key] = float(value)
height = int(d['height'])
width = int(d['width'])
ini_buyers = int(d['ini_buyers'])
ini_sellers = int(d['ini_sellers'])
def __init__(self, height=height, width=width, ini_buyers=ini_buyers, ini_sellers=ini_sellers):
'''Parameters'''
reader = csv.reader(open(self.fpath, 'r'))
d = dict()
for key, value in reader:
d[key] = float(value)
self.height = int(d['height'])
self.width = int(d['width'])
self.ini_buyers = int(d['ini_buyers'])
self.ini_sellers = int(d['ini_sellers'])
self.ini_cash = d['ini_cash']
self.num_w = int(d['num_w'])
self.trust_w = d['trust_w']
self.costs = d['costs'] * ini_buyers
self.mktresearch = d['mktresearch']
self.priceRange = d['priceRange']
self.csa = d['csa']
self.csa_length = int(d['csa_length'])
self.network = d['network']
self.lb = d['lb'] # Lower bound
self.ub = d['ub'] # Upper bound (in effect, unbounded)
self.up = d['up'] # Up rate
self.down = d['down'] # Down rate
'''
Entry mode
0: No entry
1: Full market research
2: Whenever Avg cash balance > entryThreshhold with a random position
3: Whenever Max cash balance > entryThreshhold enter nearby that position
'''
self.entry = int(d['entry'])
self.entryFrequency = int(d['entryFrequency'])
self.entryThreshhold = d['entryThreshhold'] * self.ini_cash
self.entryRadius = int(d['entryRadius']) # Area within high earner that a new seller will plop down
'''Debugging'''
self.sellerDebug = d['sellerDebug']
self.buyerDebug = d['buyerDebug']
self.networkDebug = d['networkDebug']
self.utilweightDebug = d['utilweightDebug']
self.entryDebug = d['entryDebug']
self.schedule = RandomActivationByType(self)
self.grid = MultiGrid(self.height, self.width, torus=True)
self.datacollector = DataCollector(
{"Sellers": lambda m: m.schedule.get_type_count(Seller),
"Buyers": lambda m: m.schedule.get_type_count(Buyer)})
'''Initialization'''
self.cnt = 0 # Period counter
self.buyers = {} # Dictionary of buyer instances
self.sellers = {} # Dictionary of seller instances
self.sid_alive = []
self.pi = [0] * (height * width) # Profitability
prices = {}
for i in range(ini_sellers):
prices[i] = self.priceRange * np.random.rand() + 1
min_price = min(prices.values())
for i in range(self.num_w):
prices[i] = min_price * 0.9
self.prices = prices
e = {} # Embeddedness
for i in range(ini_sellers):
e[i] = 0.8*np.random.rand() + 0.2 # 0.2 - 1.0
for i in range(self.num_w):
e[i] = 0
self.e = e
'''Create buyers'''
for i in range(self.ini_buyers):
# It seems coincidence in the same cell is allowed
x = np.random.randint(self.width)
y = np.random.randint(self.height)
α = d['alpha']
trust = {}
β = d['beta']*np.random.rand()
for j in range(ini_sellers):
trust[j] = np.random.rand()
#.........这里部分代码省略.........
客服电话
APP下载
官方微信
请发表评论