-
Notifications
You must be signed in to change notification settings - Fork 0
/
agentframework9a.py
140 lines (123 loc) · 5.39 KB
/
agentframework9a.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#!/usr/bin/env python
# coding: utf-8
# In[5]:
import random as rd
#create the class Agent for model
class Agent():
'''
Python class of Agent
Attributes :
- x,y : integer, spatial coordinates.
- environment (bound_y and bound_x): integer list, food available.
- store : int, food storage.
- others : list of Agents, other agents in environment.
- share_will: float <0.5, propencity to share.
- neighbors : list of Agents, agents within a range from self.
- neighbors_dist : list of float, distance between neighbors.
- fertility:
- starvation:
- hunger:
Methods :
- __init__: initialise coordinates to random integers in [0,100[
- move(): move agent to neighboring cell with uniform random process in tore-like grid(queen neighborhood).
- gety(): access self._y with self.y.
- getx(): access self._x with self.x.
- sety(): modify self._y with self.y.
- setx(): modify self._x with self.x.
- eat(): take food from environment and add it to store.
- give_it_up: drop store in environment when too heavy.
- distance_between: compute distance from self to other agents.
- share_with_neighbors: average store value with other agents in given range.
- reproduce:
-__str__: print attribute values.
'''
#initialise the agent by giving it attributes : here random x and y
def __init__(self, environment,others):#the self variable tells the agent how to call himself
'''
initialise agent with attributes.
'''
#the environment the agent belongs to
self.environment=environment
#coordinates
self._y = rd.randint(0,len(self.environment))
self._x = rd.randint(0,len(self.environment[0]))
#the food stored up
self.store=0
#all the other agents (including themselves)
self.others=others
self.starvation=0
#simple feritlity, 0 and 1
self.fertility=rd.randint(0,1)
#propencity to share with others :
self.share_will=rd.uniform(0,0.5)
self.hunger=rd.random()
self.neighbors=[]
self.neighbor_dist=[]
def gety(self):
'''getter property for y coordinate.'''
return self._y
def getx(self):
'''getter property for x coordinate.'''
return self._x
def setx(self, value):
'''setter property for y coordinate.'''
self._x = value
def sety(self, value):
'''setter property for x coordinate.'''
self._y = value
x=property(getx,setx)
y=property(gety,sety)
#define the method of moving that
def move(self):
'''Agent move method: independantly increment by 1 or -1 y and x with probability 0.5.'''
if rd.random()<0.5:
self.y = (self.y + 1) % len(self.environment)
else:
self.y = (self.y - 1) % len(self.environment)
if rd.random()<0.5:
self.x = (self.x + 1) % len(self.environment[0])
else:
self.x = (self.x - 1) % len(self.environment[0])
def eat(self, quantity=10):
'''Agent eat method: check food in environment and eat 10 or what is left if less.'''
food_left=self.environment[self.y][self.x]
self.environment[self.y][self.x] -= min(self.hunger*quantity,food_left)#an agent can on;y eat how much food is actually there
self.store += min(self.hunger*quantity,food_left)
def give_it_up(self):
'''Agent delesting method: under conditions can store in the environment all of its internal storage.'''
self.environment[self.y][self.x]+=self.store
self.store=0
def distance_between(self,other_agent):
'''Return distance between self and other agent.'''
dist=((self.x-other_agent.x)**2+(self.y-other_agent.y)**2)**0.5
return(dist)
def share_with_neighbors(self,neighborhood):
'''
Agent sharing method: can share food with other agents if closer than given threshold.
Two agents share by averaging their storage.
Neighboring agents are added to the list of neighbors.
'''
neighbors=[]
neighbor_dist=[]
for other_agent in self.others:
dist=self.distance_between(other_agent)
if dist<=neighborhood:
#add the condition the other agent has more needs then the agent himself.
if other_agent.store < self.store:
sum_store=self.store + other_agent.store
average_storage= sum_store/2
self.store=average_storage
other_agent.store=average_storage
neighbors.append(other_agent)
neighbor_dist.append(dist)
#note self is included in neighbors. This is not a big problem here as averaging out won't change store value.
self.neighbors=neighbors
self.neighbor_dist=neighbor_dist
def reproduce(self,baby_energy):
self.others.append(Agent(self.environment,self.others))
self.others[-1].x=self.x
self.others[-1].y=self.y
self.store-=baby_energy
def __str__(self):
'''return the values of attributes if printed.'''
return 'y:'+str(self.y)+'\nx:'+str(self.x)+'\nstore:'+str(self.store)+'\n'+str(len(self.others))+' other agents share the same environment'+'\nneighbors: '+str(len(self.neighbors))