def test_main():
#
# Define Messages
#
belief = Belief('stressed', ('degree', ))
belief.set_values(10.0)
direction1 = Direction('collect_amount', ('intake_volume', ))
#
# Define Scaffold and Map for it
#
agent_resources = Resource('internal_molecules', ('A', 'B', 'C'))
agent_resources.set_values([2.0, 1.0, 0.5])
added_a = ResourceMap('get_A', 'delta_scale', 'A', (
'add',
'dilute',
))
added_b = ResourceMap('get_B', 'delta_scale', 'B', (
'add',
'dilute',
))
added_c = ResourceMap('get_C', 'delta_scale', 'C', (
'add',
'dilute',
))
add_internal = MapCollection([added_a, added_b, added_c])
#
# Define Organs and their associated messages
#
moulder1 = Moulder('discard_or_not', make_decision, belief, direction1)
env = Env()
actuator1 = Actuator('collect', env.excretor, direction1, add_internal)
#
# Initialize Agent
#
agent = Agent('test_agent', strict_engine=True)
agent.set_organ(moulder1)
agent.set_organ(actuator1)
agent.set_scaffold(agent_resources)
#
# Decide on direction and execute action
#
agent.mould('discard_or_not')
agent.act('collect')
for mol in REF:
assert (isclose(REF[mol], agent.resource[mol], abs_tol=0.0001))
try:
agent.act('collect')
raise AssertionError(
'Acting twice in sequence did not raise correct exception')
except EmptyFlashError:
pass
def __init__(self, name):
super().__init__(name, strict_engine=True)
essence = Essence('Trusting', ('degree',))
essence.set_values([100.0])
belief = Belief('Knowledge', ('path to water', 'time to sow'))
belief.set_values(['dummy_instruction_1', 20180101])
direction = Direction('Share this', ('knowledge label', 'knowledge unit'))
moulder = Moulder('What to share', self.what_to_share, belief, direction,
essence_op_input=essence)
self.set_organ(moulder)
self.set_scaffold(essence)
self.set_message(belief)
def __init__(self, name, intent, strength, precision):
super().__init__(name)
essence = Essence('Skills', ('strength', 'precision'))
essence.set_values([strength, precision])
belief = Belief('Intent to kill', ('yes_no', ))
belief.set_values([intent])
direction = Direction('Push spear outward', ('yes_no', ))
moulder = Moulder('Attempt to kill', lambda x: x, belief, direction)
self.set_organ(moulder)
self.set_messages(belief, direction)
self.set_scaffold(essence)
def __init__(self, name):
super().__init__(name, True)
essence = Essence('Trusting', ('degree',))
essence.set_values([10.0])
belief = Belief('Knowledge', ('path to water', 'time to sow'))
belief.set_values(['stupid_idea', 20180731])
buzz = Buzz('Knowledge feed', ('words',))
interpreter = Interpreter('Should I accept teaching',
self.what_to_accept, buzz, belief,
essence_op_input=essence,
belief_updater=True)
self.set_organ(interpreter)
self.set_scaffold(essence)
self.set_message(buzz)
def __init__(self, name, diameter_init, energy_init, essence_value):
super().__init__(name, strict_engine=True)
belief = Belief('The diameter of the world', ('value', 'precision'))
belief.set_values([diameter_init, 10.0])
resource = Resource('Dietary energy', ('value',))
essence = Essence('Persistence', ('value',))
resource.set_values(energy_init)
essence.set_values(essence_value)
self.set_scaffolds(resource, essence)
metabolism = ResourceMap('Dietary energy adjustment', 'delta', 'value', ('shift',))
interpreter = Interpreter('Contemplate', self.contemplation, belief, belief,
metabolism)
self.set_organ(interpreter)
def __init__(self, name, e1, e2, r1, r2, b1, b2):
super().__init__(name, strict_engine=True)
essence = Essence('Bacteria Essence', ['E1', 'E2'])
essence.set_values([e1, e2])
resource = Resource('Bacteria Resource', ['R1', 'R2'])
resource.set_values([r1, r2])
belief = Belief('Bacteria Belief', ['B1', 'B2'])
belief.set_values([b1, b2])
self.set_scaffolds(essence, resource)
self.set_message(belief)
imprints = self.get_imprint_repr()
total_a_sampler = AgentSampler('full_state',
resource_args=imprints['resource'],
essence_args=imprints['essence'],
belief_args=imprints['belief'])
self.set_sampler(total_a_sampler)
def test_main():
#
# Define Messages
#
belief = Belief('Projectile status', ('speed', 'height', 'angle'))
belief.set_values([100.0, 0.3, 0.2])
direction = Direction('motion', ('horizontal direction',
'horizontal magnitude',
'vertical direction',
'vertical magnitude'))
#
# Define Scaffold and Map for it
#
agent_resources = Resource('internal_resource', ('internal_energy',))
agent_resources.set_values(20.0)
change_energy = ResourceMap('adjust_energy', 'delta', 'internal_energy', ('expend_energy',))
#
# Define Organs and their associated messages
#
moulder = Moulder('take evasive action?', make_decision,
belief, direction,
change_energy)
splitter_1 = MessageOperator(direction, slice_labels=['horizontal direction',
'horizontal magnitude'])
splitter_2 = MessageOperator(direction, slice_labels=['vertical direction',
'vertical magnitude'])
actuator1 = Actuator('move left right', move_rule_horizontal, splitter_1)
actuator2 = Actuator('move up down', move_rule_vertical, splitter_2)
#
# Initialize Agent
#
agent = Agent('test_agent', strict_engine=True)
agent.set_organ(moulder)
agent.set_organ(actuator1)
agent.set_organ(actuator2)
agent.set_scaffold(agent_resources)
agent.set_message(belief)
#
# Decide on direction and execute action
#
agent.mould('take evasive action?')
agent.act('move up down')
agent.act('move left right')
assert (agent.resource['internal_energy'] == REF_E[0])
belief.set_values([100.0, 1.3, -0.5])
agent.mould('take evasive action?')
agent.act('move up down')
agent.act('move left right')
assert (agent.resource['internal_energy'] == REF_E[1])
for e1, e2 in zip(REPO, REF_REPO):
assert(e1 == e2)
try:
agent.act('move up down')
raise AssertionError('Action without preceding moulding did not raise exception')
except EmptyFlashError:
pass
else:
raise AssertionError('Action without preceding moulding did not raise expected exception')
try:
agent.act('move left right')
raise AssertionError('Action without preceding moulding did not raise exception')
except EmptyFlashError:
pass
else:
raise AssertionError('Action without preceding moulding did not raise expected exception')
def __init__(self, name,
midpoint_share=0.0, max_share=0.0,
midpoint_gulp=0.0, max_gulp=0.0,
midpoint_tox=0.0, max_tox=0.0,
truthful_reveal=1.0, inverse_forget_rate=0.5,
birth_cost=2.0,
agent_id=None):
super().__init__(name, agent_id_system=agent_id, strict_engine=STRICT_ENGINE)
#
# Essence
unit_essence = Essence('Exterior Disposition',
('midpoint_share', 'max_share',
'midpoint_gulp', 'max_gulp',
'midpoint_tox', 'max_tox',
'truthful_reveal', 'inv_forget_rate'))
unit_essence.set_values([midpoint_share, max_share,
midpoint_gulp, max_gulp,
midpoint_tox, max_tox,
truthful_reveal, inverse_forget_rate])
self.set_scaffold(unit_essence)
# Essence reset map, convenience function for offspring creation
self.essence_map_reset = universal_map_maker(unit_essence, 'reset', ('value',))
#
# Resource
unit_resource = Resource('Internal Resources',
('info_a', 'info_b', 'info_c',
'bad_info'))
unit_resource.set_values([0.0, 0.0, 0.0, 0.0])
self.set_scaffold(unit_resource)
# Resource reset and scale map, convenience function for offspring creation
self.resource_reset = universal_map_maker(unit_resource, 'reset', ('value',))
self.resource_scale = universal_map_maker(unit_resource, 'delta_scale',
('value1', 'value2'))
# Resource operator only relating to info resource, not toxin
unit_resource_info = MessageOperator(unit_resource,
slice_labels=['info_a', 'info_b', 'info_c'])
#
# Belief
unit_belief = Belief('Surrounding', ('cooperative_env',))
unit_belief.set_values([0.0])
self.set_message(unit_belief)
#
# Interpreters
buzz = Buzz('Neighbour Cooperator', ('revealed_coop',))
self.set_message(buzz)
interpreter = Interpreter('Friendly Environment',
self._cmp_friendly_env,
buzz,
unit_belief,
belief_updater=True)
self.set_organ(interpreter)
#
# Moulders
direction = Direction('Resources to Share',
('d_info_a', 'd_info_b', 'd_info_c'))
moulder = Moulder('Share Resources', self._cmp_share_resources,
unit_belief,
direction,
resource_op_input=unit_resource_info)
self.set_organ(moulder)
direction = Direction('Fraction to Gulp', ('f_gulp',))
moulder = Moulder('Gulp from Env', self._cmp_gulp_fraction,
unit_belief,
direction)
self.set_organ(moulder)
split_resource = universal_map_maker(self.resource, 'delta_scale',
('delta', 'factor',))
direction = Direction('Offspring', ('agent_split',))
moulder = Moulder('Create Agent Offspring', self._cmp_offspring,
None,
direction,
resource_map_output=split_resource,
moulder_func_kwargs={'birth_delta':birth_cost})
self.set_organ(moulder)
direction = Direction('Lies to Eject', ('amount',))
moulder = Moulder('Eject Lies', self._cmp_lies_ejection,
unit_belief,
direction,
resource_op_input=unit_resource_info)
self.set_organ(moulder)
#
# Cortex
coop_expose = Feature('Cooperative Reveal',
('coop_with_coop',))
cortex = Cortex('Reveal Cooperation', self._cmp_cooperative_feature,
None, coop_expose)
self.set_organ(cortex)
def test_main():
#
# Define Messages
#
belief = Belief('rich_environment',
('stuff_1', 'stuff_2', 'stuff_3', 'stuff_4'))
belief.set_values([0.7, 0.3, 0.6, 0.1])
direction1 = Direction('grab_this_much', ('grab_volume', ))
direction2 = Direction('shout_loud', ('volume', ))
#
# Define Scaffold and Map for it
#
agent_resources = Resource('internal_resource',
('internal_energy', 'carrot', 'leek'))
agent_resources.set_values([100.0, 4, 5])
change_energy = ResourceMap('adjust_energy', 'delta', 'internal_energy',
('expend_energy', ))
change_carrot = ResourceMap('adjust_carrot', 'delta', 'carrot',
('tweak_carrot', ))
change_leek = ResourceMap('adjust_leek', 'delta', 'leek', ('tweak_leek', ))
hoarding_food = MapCollection([change_carrot, change_leek])
#
# Define Organs and their associated messages
#
moulder1 = Moulder('reach_and_grab', make_decision, belief, direction1,
change_energy)
moulder2 = Moulder('shout_how_much', shouter, belief, direction2)
env = Env()
actuator1 = Actuator('grab_it', env.grabber, direction1, hoarding_food)
actuator2 = Actuator('shout', env.shout_into_void, direction2)
#
# Initialize Agent
#
agent = Agent('test_agent', strict_engine=True)
agent.set_organ(moulder1)
agent.set_organ(moulder2)
agent.set_organ(actuator1)
agent.set_organ(actuator2)
agent.set_scaffold(agent_resources)
#
# Decide on direction and execute action
#
agent.mould('reach_and_grab')
agent.act('grab_it')
assert (agent.resource.values() == REF_RESOURCE_OUTCOME)
agent.mould('shout_how_much')
agent.act('shout')
agent.mould('shout_how_much')
agent.act('shout')
assert (isclose(env.loud_cumsum, 3.4))
try:
agent.act('shout')
raise AssertionError(
'Action without preceding moulding did not raise exception')
except EmptyFlashError:
pass
else:
raise AssertionError(
'Action without preceding moulding did not raise expected exception'
)
def test_main():
belief = Belief('dummy', ('a1', ))
resource = Resource('internal energy', ('level', ))
mapper = ResourceMap('eat energy', 'delta', 'level', ('shift', ))
interpreter1 = Interpreter('thinker',
lambda x: (x + 1, -1),
belief,
belief,
resource_map_output=mapper)
interpreter2 = Interpreter('thinker X',
lambda x: (x + 1, -3),
belief,
belief,
resource_map_output=mapper)
battery = AutoResourceCondition('battery left', lambda x: x > 0)
heart_1 = Heartbeat('big heart',
battery,
ticker_arithmetic=lambda: 2,
max_ticker=4)
heart_2 = Heartbeat('small heart',
battery,
ticker_arithmetic=lambda: 1,
max_ticker=4)
agent_1 = Agent('A1')
agent_1.set_organs(interpreter1, interpreter2)
belief.set_values([1])
resource.set_values([10])
agent_1.set_message(belief)
agent_1.set_scaffold(resource)
agent_1.set_policies(heart_1, heart_2)
assert (agent_1.belief['dummy'].values()[0] == REF_B1[0])
assert (agent_1.inert == REF_I1[0])
agent_1.pump('big heart')
agent_1.interpret('thinker')
assert (agent_1.belief['dummy'].values()[0] == REF_B1[1])
assert (agent_1.inert == REF_I1[1])
agent_1.pump('big heart')
agent_1.interpret('thinker')
assert (agent_1.belief['dummy'].values()[0] == REF_B1[2])
assert (agent_1.inert == REF_I1[2])
agent_1.pump('big heart')
agent_1.interpret('thinker')
assert (agent_1.belief['dummy'].values()[0] == REF_B1[3])
assert (agent_1.inert == REF_I1[3])
agent_1.revive()
assert (agent_1.inert == False)
agent_1.pump('small heart')
agent_1.interpret('thinker X')
assert (agent_1.belief['dummy'].values()[0] == REF_B2[0])
assert (agent_1.inert == REF_I2[0])
agent_1.pump('small heart')
agent_1.interpret('thinker X')
assert (agent_1.belief['dummy'].values()[0] == REF_B2[1])
assert (agent_1.inert == REF_I2[1])
agent_1.pump('small heart')
agent_1.interpret('thinker X')
assert (agent_1.belief['dummy'].values()[0] == REF_B2[2])
assert (agent_1.inert == REF_I2[2])
agent_1.pump('small heart')
agent_1.interpret('thinker X')
assert (agent_1.belief['dummy'].values()[0] == REF_B2[3])
assert (agent_1.inert == REF_I2[3])
agent_1.pump('small heart')
agent_1.interpret('thinker X')
assert (agent_1.belief['dummy'].values()[0] == REF_B2[4])
assert (agent_1.inert == REF_I2[4])
def test_main():
#
# Define Messages
#
belief_input_1 = Belief('hostile_neighbourhood', ['hostility_index'])
belief_input_2 = Belief('i_am_followed', ['probability'])
belief_output = Belief('i_am_about_to_be_mugged', ['best_guess'])
belief_merge_input = MessageOperator([belief_input_1, belief_input_2],
extend=True)
#
# Define Organs and their associated messages
#
interpreter = Interpreter('about_to_be_mugged', evaluate,
belief_merge_input, belief_output)
#
# Initialize Agent
#
agent = Agent('test_agent', strict_engine=True)
agent.set_organ(interpreter)
agent._set('belief', 'hostile_neighbourhood', belief_input_1)
agent._set('belief', 'i_am_followed', belief_input_2)
belief_input_1.set_values(0.8)
belief_input_2.set_values(0.95)
agent.interpret('about_to_be_mugged')
outcome_1 = agent.belief['i_am_about_to_be_mugged'].values()
belief_input_1.set_values(0.0)
belief_input_2.set_values(0.0)
agent.interpret('about_to_be_mugged')
outcome_2 = agent.belief['i_am_about_to_be_mugged'].values()
belief_input_1.set_values(0.9)
belief_input_2.set_values(1.0)
agent.interpret('about_to_be_mugged')
outcome_3 = agent.belief['i_am_about_to_be_mugged'].values()
assert (outcome_1[0] == REFVALUES[0])
assert (outcome_2[0] == REFVALUES[1])
assert (outcome_3[0] == REFVALUES[2])