def main(processes, rounds):
simulation = abce.Simulation(processes=processes)
print('build Killer')
killer = simulation.build_agents(Killer, 'killer', 1)
print('build Victim')
victims = simulation.build_agents(Victim, 'victim', rounds)
print('build Victim loudvictim')
loudvictims = simulation.build_agents(Victim, 'loudvictim', rounds)
print('build AddAgent')
balls = simulation.build_agents(Ball, 'ball', 0)
for time in range(rounds):
simulation.advance_round(time)
assert len(balls) == time, len(balls)
deads = killer.kill_silent()
victims.delete_agents(deads)
deads = killer.kill_loud()
loudvictims.delete_agents(deads)
victims.am_I_dead()
loudvictims.am_I_dead()
balls.create_agents(1)
simulation.finalize()
del simulation
def main(processes):
simulation = abce.Simulation(processes=processes)
simulation.aggregate('agent', variables=['i', 'r'], possessions=['money'])
simulation.panel('agent', variables=['i', 'r'], possessions=['money'])
agents = simulation.build_agents(Agent, 'agent', 10, parameters='')
for r in range(100):
simulation.advance_round(r)
agents.do('go')
agents.aggregate()
agents.panel()
simulation.finalize()
if platform.system() == 'Windows':
simulation.path = simulation.path.replace('/', '\\')
compare('aggregate_agent.csv',
simulation.path, 'aggregate logging test\t\t')
compare('aggregate_agent_mean.csv',
simulation.path, 'aggregate logging test mean\t')
compare('aggregate_agent_std.csv',
simulation.path, 'aggregate logging test std\t')
compare('aggregate_log_agent.csv',
simulation.path, 'self.log test \t\t\t')
compare('log_agent.csv', simulation.path, 'self.log test\t\t\t\t')
compare('aggregate_panel_agent.csv',
simulation.path, 'aggregated panel logging test\t')
compare('panel_agent.csv', simulation.path, 'panel logging test\t\t\t')
def main(processes, rounds):
simulation = abce.Simulation(name='logging_test_friendly_names',
processes=processes)
agents = simulation.build_agents(Agent,
'friendly_agent',
agent_parameters=[{
'name': 'A'
}, {
'name': 'Davoud'
}, {
'name': "fred"
}, {
'name': "F12"
}])
for rnd in range(10):
for r in range(10):
simulation.advance_round((r, rnd))
agents.go()
agents.agg_log(variables=['i', 'r'], goods=['money'])
agents.panel_log(variables=['i', 'r'], goods=['money'])
simulation.finalize()
compare('aggregated_friendly_agent.csv', simulation.path,
'aggregated logging test\t\t', processes)
compare('aggregate_friendly_agent.csv', simulation.path,
'aggregate logging test\t\t', processes)
compare('panel_friendly_agent.csv', simulation.path,
'aggregate logging test mean\t', processes)
def main(processes, rounds):
sim = abce.Simulation()
sim.advance_round(0)
myagents = sim.build_agents(MyAgent, 'myagent', number=5)
for id in range(5):
assert list(myagents[id].say()) == [id], (list(myagents[id].say()),
[id])
sim.finalize()
def main(processes, rounds):
sim = abce.Simulation(processes=processes)
myagents = sim.build_agents(MyAgent, 'myagent', number=2)
for time in range(rounds):
sim.time = time
myagents.produce()
myagents.all_tests_completed()
sim.finalize()
def main(processes, rounds):
s = abce.Simulation(processes=processes, name='unittest')
endowment = s.build_agents(Endowment, 'endowment', 2, rounds=rounds)
for r in range(rounds):
s.time = r
endowment.refresh_services('labor',
derived_from='labor_endowment',
units=5)
endowment.Iconsume()
endowment.all_tests_completed()
s.finalize()
def main(processes, rounds):
sim = abce.Simulation(name='mysim',
processes=processes,
dbplugin=CustomLogging,
dbpluginargs=['sqlite:///:memory:', 'sometable'])
myagents = sim.build_agents(MyAgent, 'myagent', number=5)
for i in range(rounds):
sim.advance_round(i)
myagents.write()
sim.finalize()
def main(processes, rounds):
sim = abce.Simulation(processes=processes)
returners = sim.build_agents(Returner, 'returner', number=3)
getters = sim.build_agents(Getter, 'getter', number=1)
for y in range(rounds):
sim.advance_round(y)
ret = returners.returnit()
getters.getit(ret)
getters.method('a', 'b', 'c', d='d', f='f', e='e')
sim.finalize()
print('Returning tested \t\t\t\t\t\tOK')
print('Calling with parameters tested \t\t\t\t\tOK')
def main(processes, rounds):
s = abce.Simulation(processes=processes, name='unittest')
print('build MessageA')
messagea = s.build_agents(MessageA, 'messagea', 20)
print('build MessageB')
messageb = s.build_agents(MessageB, 'messageb', 20)
for r in range(rounds):
s.time = r
(messagea + messageb).sendmsg()
(messageb + messagea).recvmsg()
print("Send_envelope and receive test:\t OK")
s.finalize()
def main(processes, rounds=5):
s = abce.Simulation(processes=processes, name='production_consumption_test')
print('build ProductionMultifirm')
productionmultifirm = s.build_agents(ProductionMultifirm, 'productionmultifirm', 1, rounds=rounds)
print('build UtilityHousehold')
utilityhousehold = s.build_agents(UtilityHousehold, 'utilityhousehold', 5, rounds=rounds)
all_agents = utilityhousehold + productionmultifirm
for r in range(rounds):
s.advance_round(r)
productionmultifirm.production()
utilityhousehold.consumption()
all_agents.all_tests_completed()
s.finalize()
def main(processes, rounds):
sim = abce.Simulation()
sim.advance_round(0)
myagents = sim.build_agents(MyAgent, 'myagent', agent_parameters=[{'name': 'me'},
{'name': 'you'},
{'name': 'him'},
{'name': ('firm', 0)}])
names = ['me', 'you', 'him', ('firm', 0)]
for name in names:
assert list(myagents.by_name(name).say()) == [name], (
list(myagents.by_name(name).say()), [name])
assert list(myagents.by_name(name).say()) == [name], (
list(myagents.by_names(names).say()), names)
sim.finalize()
def main(processes, rounds):
simulation = abce.Simulation(name='logging_test', processes=processes)
agents = simulation.build_agents(Agent, 'agent', 10)
for rnd in range(100):
simulation.advance_round(rnd)
agents.go()
agents.agg_log(variables=['i', 'r'], goods=['money'])
agents.panel_log(variables=['i', 'r'], goods=['money'])
simulation.finalize()
compare('aggregated_agent.csv', simulation.path,
'aggregated logging test\t\t', processes)
compare('aggregate_agent.csv', simulation.path,
'aggregate logging test\t\t', processes)
compare('panel_agent.csv', simulation.path,
'aggregate logging test mean\t', processes)
def main(processes, rounds):
sim = abce.Simulation(processes=processes)
aagents = sim.build_agents(Agent, 'aagent', number=5)
bagents = sim.build_agents(Agent, 'bagent', number=5)
actionA = aagents.actionA
actionB = bagents.actionB
for r in range(rounds):
sim.advance_round(r)
(aagents.actionA + aagents.actionB)()
(aagents.actionA + bagents.actionB)()
(aagents.actionB + bagents.actionB)()
aagents.actionA()
bagents.actionB()
(actionA + actionB)()
sim.finalize()
def main(processes):
simulation = abce.Simulation(processes=processes)
agents = simulation.build_agents(Agent, 'agent', 10, parameters='')
for rnd in range(100):
simulation.advance_round(rnd)
agents.go()
agents.agg_log(variables=['i', 'r'], possessions=['money'])
agents.panel_log(variables=['i', 'r'], possessions=['money'])
simulation.finalize()
if platform.system() == 'Windows':
simulation.path = simulation.path.replace('/', '\\')
compare('aggregated_agent.csv', simulation.path,
'aggregated logging test\t\t', processes)
compare('aggregate_agent.csv', simulation.path,
'aggregate logging test\t\t', processes)
compare('panel_agent.csv', simulation.path,
'aggregate logging test mean\t', processes)
def main(processes, rounds):
simulation = abce.Simulation(processes=processes)
print('build Killer')
killer = simulation.build_agents(Killer,
'killer',
1,
parameters={'rounds': rounds})
print('build Victim')
victims = simulation.build_agents(Victim,
'victim',
rounds,
parameters={'rounds': rounds})
print('build Victim loudvictim')
loudvictims = simulation.build_agents(Victim,
'loudvictim',
rounds,
parameters={'rounds': rounds})
print('build AddAgent')
balls = simulation.build_agents(Ball, 'ball', 0)
for time in range(rounds):
simulation.advance_round(time)
assert len(balls.boing()) == time, len(balls.boing())
deads = killer.kill_silent()
for dead in deads:
simulation.delete_agent(*dead)
deads = killer.kill_loud()
for dead in deads:
simulation.delete_agent(*dead)
killer.send_message()
victims.am_I_dead()
loudvictims.am_I_dead()
simulation.create_agent(Ball, 'ball')
simulation.finalize()
del simulation
def main(params):
simulation = abce.Simulation(name='economy', processes=1)
group_of_firms = simulation.build_agents(Firm, "firm", number=params["num_firms"], **params)
people = simulation.build_agents(People, "people", number=1, **params)
for r in range(params["num_days"]):
simulation.time = r
group_of_firms.panel_log(variables=['wage', 'ideal_num_workers'], goods=['workers'])
people.create_labor()
vacancies_list = list(group_of_firms.publish_vacencies())
people.send_workers(vacancies_list)
group_of_firms.production()
group_of_firms.pay_workers()
group_of_firms.pay_dividents()
group_of_firms.send_prices()
people.get_prices()
demand = people.buy_goods()
group_of_firms.sell_goods()
group_of_firms.determine_bounds(demand=list(demand)[0])
(group_of_firms + people).print_possessions()
group_of_firms.determine_wage()
group_of_firms.expand_or_change_price()
(people + group_of_firms).destroy_unused_labor()
people.consumption()
group_of_firms.determine_profits()
print('done')
path = simulation.path
simulation.finalize()
return sim_data = pd.read_csv(path + "/panel_firm.csv")
farm_wage_increment=0.01,
farm_price_increment=0.01,
num_days=1300,
l=0.5, # constant from CS equation
num_days_buffer=
10, # number of days worth of wages a firm will keep after giving profits
phi_upper=10, # phi_upper * demand gives upper bound to inventory
phi_lower=2,
excess=
1.1, # if number of workers offered to work for firm exceeds 110% of ideal number, decrease wage
wage_increment=0.01,
price_increment=0.01,
worker_increment=0.01,
productivity=1,
wage_acceptance=1)
simulation = abce.Simulation(name='economy', processes=1)
group_of_firms = simulation.build_agents(Firm,
"firm",
number=params["num_firms"],
**params)
people = simulation.build_agents(People, "people", number=1, **params)
farms = simulation.build_agents(Farm,
"farm",
number=params["num_farms"],
**params)
farmers = simulation.build_agents(Farmers, "farmers", number=1, **params)
def main(params):
for date in pd.date_range(start='1/1/1880',
import abce as abcEconomics
from bank import Bank
from household import Household
min_capital_ratio = 0.03
sim = abcEconomics.Simulation()
bank = sim.build_agents(Bank,
'bank',
number=1,
min_capital_ratio=min_capital_ratio,
reserves=11000,
deposits=10000)
households = sim.build_agents(Household,
'household',
number=100,
money=100,
loans=0)
for time in range(100):
sim.advance_round(time)
ir = bank.announce_interest_rate()
households.request_loans(list(ir)[0])
bank.grant_loans()
print('bank')
bank.print_balance_sheet()
households.pay_interest()
bank.print_profit_and_loss()
bank.book_end_of_period()
import sys
sys.path.insert(0, '../abcFinance')
import abce
from bank import Bank
from household import Household
min_capital_ratio = 0.03
sim = abce.Simulation()
bank = sim.build_agents(Bank, 'bank', number=1, min_capital_ratio=min_capital_ratio, reserves=11000, deposits=10000)
households = sim.build_agents(Household, 'household', number=100, money=100, loans=0)
for time in range(100):
sim.advance_round(time)
ir = bank.announce_interest_rate()
households.request_loans(list(ir)[0])
bank.grant_loans()
print('bank')
bank.print_balance_sheet()
households.pay_interest()
bank.print_profit_and_loss()
bank.book_end_of_period()
households.book_end_of_period()
bank.print_balance_sheet()
print('bank')
bank.print_balance_sheet()
print('household 0')
self.send(
loan_request.sender, '_autobook',
dict(debit=[('money holdings', amount)],
credit=[('loan liabilities', amount)],
text='Loan'))
class Config:
num_banks = 2
num_households = 3
spending_probability = 0.3
loan_size = 100
sim = abce.Simulation(check_unchecked_msgs=True)
banks = sim.build_agents(Bank, 'bank', Config.num_banks, config=Config)
households = sim.build_agents(Household,
'household',
Config.num_households,
config=Config)
Config.housebank_indices = list(households.return_housebank())
households.get_outside_money()
for r in range(4):
sim.advance_round(r)
households.transfer_money()
funding_needs = list(banks.handle_transfers())
banks.get_funding(funding_needs)
# get access to each row of the dataframe
for i in range(1, len(suppliers_df)):
s = {
'id': suppliers_df.iloc[i].ID,
'county': suppliers_df.iloc[i].County_Soil,
'marg_cost': suppliers_df.iloc[i].marginal_cost,
'marg_qty': suppliers_df.iloc[i].marginal_qty
}
suppliers_list.append(s)
# Create simulation
market_price = 10.0
simulation = abce.Simulation(name="Suppliers")
suppliers = simulation.build_agents(
Supplier_Agent, # agent class
'supplier', # name of the group
agent_parameters = suppliers_list
# no need to pass 'number' explicitly, because abce
# calculates the length of the list automatically
)
# Run the simulation
for r in range(3):
simulation.advance_round(r)
suppliers.whether_to_sell()
def main(processes, rounds):
sim = abce.Simulation()
myagent = sim.build_agents(MyAgent,
'myagent',
agent_parameters=[{
'agent_parameters': 0
}, {
'agent_parameters': 1
}, {
'agent_parameters': 2
}, {
'agent_parameters': 3
}, {
'agent_parameters': 4
}, {
'agent_parameters': 5
}, {
'agent_parameters': 6
}])
differentagent = sim.build_agents(DifferentAgent,
'differentagent',
agent_parameters=[{
'agent_parameters': 0
}, {
'agent_parameters': 1
}, {
'agent_parameters': 2
}, {
'agent_parameters': 3
}, {
'agent_parameters': 4
}, {
'agent_parameters': 5
}, {
'agent_parameters': 6
}])
print('len', len(myagent))
sim.advance_round(0)
myagent.call_me_maybe()
print('simple')
for r in range(1, 14):
sim.advance_round(r)
myagent[r % 7].call_me_maybe()
print('--')
print('two individuals')
for r in range(14, 28):
sim.advance_round(r)
(myagent[r % 7] + myagent[3]).call_me_maybe()
print('--')
print('one class')
for r in range(28, 42):
sim.advance_round(r)
myagent[r % 7, 3].call_me_maybe()
print('--')
print('whole class plus individual')
for r in range(42, 56):
sim.advance_round(r)
(myagent + myagent[r % 7]).call_me_maybe()
print('--')
print('two classes')
for r in range(56, 70):
sim.advance_round(r)
(myagent + differentagent).call_me_maybe()
print('--')
sim.finalize()
def main(simulation_parameters, seed):
np.random.seed(seed)
# create simulation and world objects (identical in non-abce mode)
if isleconfig.use_abce:
simulation = abce.Simulation(processes=1, random_seed=seed)
simulation_parameters['simulation'] = world = InsuranceSimulation(
override_no_riskmodels, replic_ID, simulation_parameters)
if not isleconfig.use_abce:
simulation = world
# create agents: insurance firms
insurancefirms_group = simulation.build_agents(
InsuranceFirm,
'insurancefirm',
parameters=simulation_parameters,
agent_parameters=world.agent_parameters["insurancefirm"])
if isleconfig.use_abce:
insurancefirm_pointers = insurancefirms_group.get_pointer()
else:
insurancefirm_pointers = insurancefirms_group
world.accept_agents("insurancefirm", insurancefirm_pointers,
insurancefirms_group)
# create agents: reinsurance firms
reinsurancefirms_group = simulation.build_agents(
ReinsuranceFirm,
'reinsurance',
parameters=simulation_parameters,
agent_parameters=world.agent_parameters["reinsurance"])
if isleconfig.use_abce:
reinsurancefirm_pointers = reinsurancefirms_group.get_pointer()
else:
reinsurancefirm_pointers = reinsurancefirms_group
world.accept_agents("reinsurance", reinsurancefirm_pointers,
reinsurancefirms_group)
# time iteration
for t in range(simulation_parameters["max_time"]):
# abce time step
simulation.advance_round(t)
# create new agents # TODO: write method for this; this code block is executed almost identically 4 times
if world.insurance_firm_market_entry(agent_type="InsuranceFirm"):
parameters = [
np.random.choice(world.agent_parameters["insurancefirm"])
]
parameters[0]["id"] = world.get_unique_insurer_id()
new_insurance_firm = simulation.build_agents(
InsuranceFirm,
'insurancefirm',
parameters=simulation_parameters,
agent_parameters=parameters)
insurancefirms_group += new_insurance_firm
if isleconfig.use_abce:
# TODO: fix abce
# may fail in abce because addressing individual agents may not be allowed
# may also fail because agent methods may not be callable directly
new_insurancefirm_pointer = [
new_insurance_firm[0].get_pointer()
] # index 0 because this is a list with just 1 object
else:
new_insurancefirm_pointer = new_insurance_firm
world.accept_agents("insurancefirm",
new_insurancefirm_pointer,
new_insurance_firm,
time=t)
if world.insurance_firm_market_entry(agent_type="ReinsuranceFirm"):
parameters = [
np.random.choice(world.agent_parameters["reinsurance"])
]
parameters[0]["id"] = world.get_unique_reinsurer_id()
new_reinsurance_firm = simulation.build_agents(
ReinsuranceFirm,
'reinsurance',
parameters=simulation_parameters,
agent_parameters=parameters)
reinsurancefirms_group += new_reinsurance_firm
if isleconfig.use_abce:
# TODO: fix abce
# may fail in abce because addressing individual agents may not be allowed
# may also fail because agent methods may not be callable directly
new_reinsurancefirm_pointer = [
new_reinsurance_firm[0].get_pointer()
] # index 0 because this is a list with just 1 object
else:
new_reinsurancefirm_pointer = new_reinsurance_firm
world.accept_agents("reinsurance",
new_reinsurancefirm_pointer,
new_reinsurance_firm,
time=t)
# iterate simulation
world.iterate(t)
# log data
if isleconfig.use_abce:
#insurancefirms.logme()
#reinsurancefirms.logme()
insurancefirms_group.agg_log(variables=['cash', 'operational'],
len=['underwritten_contracts'])
#reinsurancefirms_group.agg_log(variables=['cash'])
else:
world.save_data()
#print("here")
# finish simulation, write logs
simulation.finalize()
import abce
from ball import Ball
from killer import Killer
from victim import Victim
rounds = 30
simulation = abce.Simulation(processes=4)
print('build Killer')
killer = simulation.build_agents(Killer,
'killer',
1,
parameters={'rounds': rounds})
print('build Victim')
victims = simulation.build_agents(Victim,
'victim',
rounds,
parameters={'rounds': rounds})
print('build Victim loudvictim')
loudvictims = simulation.build_agents(Victim,
'loudvictim',
rounds,
parameters={'rounds': rounds})
print('build AddAgent')
balls = simulation.build_agents(Ball, 'ball', 0)
for time in range(rounds):
simulation.advance_round(time)
deads = killer.kill_silent()
for dead in deads:
