def main():
from complex_systems.dygraph import DyGraph
import networkx as nx
import pylab as plt
G = DyGraph(time_stop=400.0, time_step=5.0)
G.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=1000,
f_min=1,
f_max=100,
s_min=1,
s_max=100.0,
b_c=2,
radius=200.0,
nb_node=2,
velocity=float(1.0 / 60),
)
time_step = 10.0
graph = G.get_graph(time_step)
i = 1
for g in G:
print "print graph of the slice ", g.graph['slice_time']
pos = nx.get_node_attributes(g, 'pos')
plt.figure()
plt.title('Time = ' + str(g.graph['slice_time'] * 5.0) + ' seconds')
limits = plt.axis('off')
plt.draw()
nx.draw(g, pos=pos, with_labels=False, node_size=20)
filename = 'graph_' + str("%04d" % i) + '.jpg'
plt.savefig(filename)
i += 1
def main():
from complex_systems.dygraph import DyGraph
import networkx as nx
import pylab as plt
G = DyGraph(time_stop=400.0, time_step=5.0)
G.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=1000,
f_min=1,
f_max=100,
s_min=1,
s_max=100.0,
b_c=2,
radius=200.0,
nb_node=2,
velocity=float(1.0 / 60),
)
time_step = 10.0
graph = G.get_graph(time_step)
i = 1
for g in G:
print "print graph of the slice ", g.graph["slice_time"]
pos = nx.get_node_attributes(g, "pos")
plt.figure()
plt.title("Time = " + str(g.graph["slice_time"] * 5.0) + " seconds")
limits = plt.axis("off")
plt.draw()
nx.draw(g, pos=pos, with_labels=False, node_size=20)
filename = "graph_" + str("%04d" % i) + ".jpg"
plt.savefig(filename)
i += 1
def main():
from complex_systems.dygraph import DyGraph
from complex_systems.pgg import PublicGoodGames
from complex_systems.quasi_unit_disk_graph import gen_quasi_unit_disk_weight
from complex_systems.quasi_unit_disk_graph import remove_edges_from_graph
import networkx as nx
import pylab as plt
outer_radius = 75
inner_radius = 40
alpha_quasi_unit_disk = 0.9
synergy = 8
coop_ratio = 0.5
noise_var = 1
nb_node = 400
time_step = 5.0
G = DyGraph(time_stop=2000.0, time_step=time_step)
G.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=1000,
f_min=10,
f_max=1000,
s_min=5,
s_max=1000.0,
b_c=2,
radius=200.0,
nb_node=nb_node,
)
first_run = True
resultats = []
for g in G:
g = gen_quasi_unit_disk_weight(G=g,
outer_radius=outer_radius,
inner_radius=inner_radius,
alpha=alpha_quasi_unit_disk)
g = remove_edges_from_graph(g)
if first_run == True:
PGG = PublicGoodGames(G=g,
synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var)
nb_coop = PGG.run_game(time_step)
resultats.append(nb_coop)
strategies = PGG.get_strategies()
first_run = False
else:
PGG = PublicGoodGames(G=g,
synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var)
PGG.set_strategies(strategies)
nb_coop = PGG.run_game(time_step)
strategies = PGG.get_strategies()
resultats.append(nb_coop)
plt.figure()
plt.plot(resultats, '-o')
plt.show()
def test_iter(self):
import networkx as nx
self.dygraph = DyGraph()
self.dygraph.add_graph(nx.Graph(), 10.0)
self.dygraph.add_graph(nx.Graph(), 20.0)
self.dygraph.add_graph(nx.Graph(), 30.0)
for g in self.dygraph:
print g.graph['slice_time']
self.assertEqual([10.0, 20.0, 30], self.dygraph._slice_time)
def main():
from complex_systems.dygraph import DyGraph
from complex_systems.pgg import PublicGoodGames
from complex_systems.quasi_unit_disk_graph import gen_quasi_unit_disk_weight
from complex_systems.quasi_unit_disk_graph import remove_edges_from_graph
import networkx as nx
import pylab as plt
outer_radius = 75
inner_radius = 40
alpha_quasi_unit_disk = 0.9
synergy = 8
coop_ratio = 0.5
noise_var = 1
nb_node = 400
time_step = 5.0
G = DyGraph(time_stop=2000.0, time_step=time_step)
G.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=1000,
f_min=10,
f_max=1000,
s_min=5,
s_max=1000.0,
b_c=2,
radius=200.0,
nb_node=nb_node,
)
first_run = True
resultats = []
for g in G:
g = gen_quasi_unit_disk_weight(G=g, outer_radius=outer_radius,
inner_radius=inner_radius, alpha=alpha_quasi_unit_disk)
g = remove_edges_from_graph(g)
if first_run == True:
PGG = PublicGoodGames(G=g, synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var)
nb_coop = PGG.run_game(time_step)
resultats.append(nb_coop)
strategies = PGG.get_strategies()
first_run = False
else:
PGG = PublicGoodGames(G=g, synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var)
PGG.set_strategies(strategies)
nb_coop = PGG.run_game(time_step)
strategies = PGG.get_strategies()
resultats.append(nb_coop)
plt.figure()
plt.plot(resultats, '-o')
plt.show()
def test_add_graph(self):
import networkx as nx
self.dygraph = DyGraph()
timeStep = 10.0
G = nx.Graph()
G.add_node(1)
G.add_node(2)
self.dygraph.add_graph(G, timeStep)
self.assertDictEqual(G.node,
self.dygraph._slices[timeStep]['graph'].node)
self.assertEqual(
timeStep,
self.dygraph._slices[timeStep]['graph'].graph['slice_time'])
class test_DyGraph(unittest.TestCase):
def setUp(self):
self.dygraph = DyGraph()
def test_add_graph(self):
import networkx as nx
self.dygraph = DyGraph()
timeStep = 10.0
G = nx.Graph()
G.add_node(1)
G.add_node(2)
self.dygraph.add_graph(G, timeStep)
self.assertDictEqual(G.node,
self.dygraph._slices[timeStep]['graph'
].node)
self.assertEqual(timeStep,
self.dygraph._slices[timeStep]['graph'
].graph['slice_time'])
def test_dygraph(self):
import numpy as N
self.dygraph = DyGraph(time_stop=100.0, time_step=10.0)
self.assertEqual(N.ceil(100.0 / 10.0),
len(self.dygraph._slices))
def test_dygraph_with_timeline(self):
import numpy as N
self.dygraph = DyGraph(timeline=N.arange(0,100,10))
self.assertEqual(N.ceil(100.0 / 10.0),
len(self.dygraph._slices))
def test_iter(self):
import networkx as nx
self.dygraph = DyGraph()
self.dygraph.add_graph(nx.Graph(),10.0)
self.dygraph.add_graph(nx.Graph(),20.0)
self.dygraph.add_graph(nx.Graph(),30.0)
for g in self.dygraph:
print g.graph['slice_time']
self.assertEqual([10.0, 20.0, 30], self.dygraph._slice_time)
def test_gen_mobility(self):
import numpy as N
self.dygraph = DyGraph(time_stop=100.0, time_step=10.0)
self.dygraph.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=100,
f_min=10,
f_max=100,
s_min=1,
s_max=100,
b_c=2,
radius=20.0,
nb_node=10,
)
self.assertEqual(N.ceil(100.0 / 10.0),
len(self.dygraph._slices))
def test_gen_mobility(self):
import numpy as N
self.dygraph = DyGraph(time_stop=100.0, time_step=10.0)
self.dygraph.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=100,
f_min=10,
f_max=100,
s_min=1,
s_max=100,
b_c=2,
radius=20.0,
nb_node=10,
)
self.assertEqual(N.ceil(100.0 / 10.0), len(self.dygraph._slices))
def test_iter(self):
import networkx as nx
self.dygraph = DyGraph()
self.dygraph.add_graph(nx.Graph(),10.0)
self.dygraph.add_graph(nx.Graph(),20.0)
self.dygraph.add_graph(nx.Graph(),30.0)
for g in self.dygraph:
print g.graph['slice_time']
self.assertEqual([10.0, 20.0, 30], self.dygraph._slice_time)
class test_DyGraph(unittest.TestCase):
def setUp(self):
self.dygraph = DyGraph()
def test_add_graph(self):
import networkx as nx
self.dygraph = DyGraph()
timeStep = 10.0
G = nx.Graph()
G.add_node(1)
G.add_node(2)
self.dygraph.add_graph(G, timeStep)
self.assertDictEqual(G.node,
self.dygraph._slices[timeStep]['graph'].node)
self.assertEqual(
timeStep,
self.dygraph._slices[timeStep]['graph'].graph['slice_time'])
def test_dygraph(self):
import numpy as N
self.dygraph = DyGraph(time_stop=100.0, time_step=10.0)
self.assertEqual(N.ceil(100.0 / 10.0), len(self.dygraph._slices))
def test_dygraph_with_timeline(self):
import numpy as N
self.dygraph = DyGraph(timeline=N.arange(0, 100, 10))
self.assertEqual(N.ceil(100.0 / 10.0), len(self.dygraph._slices))
def test_iter(self):
import networkx as nx
self.dygraph = DyGraph()
self.dygraph.add_graph(nx.Graph(), 10.0)
self.dygraph.add_graph(nx.Graph(), 20.0)
self.dygraph.add_graph(nx.Graph(), 30.0)
for g in self.dygraph:
print g.graph['slice_time']
self.assertEqual([10.0, 20.0, 30], self.dygraph._slice_time)
def test_gen_mobility(self):
import numpy as N
self.dygraph = DyGraph(time_stop=100.0, time_step=10.0)
self.dygraph.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=100,
f_min=10,
f_max=100,
s_min=1,
s_max=100,
b_c=2,
radius=20.0,
nb_node=10,
)
self.assertEqual(N.ceil(100.0 / 10.0), len(self.dygraph._slices))
def test_add_graph(self):
import networkx as nx
self.dygraph = DyGraph()
timeStep = 10.0
G = nx.Graph()
G.add_node(1)
G.add_node(2)
self.dygraph.add_graph(G, timeStep)
self.assertDictEqual(G.node,
self.dygraph._slices[timeStep]['graph'
].node)
self.assertEqual(timeStep,
self.dygraph._slices[timeStep]['graph'
].graph['slice_time'])
def test_gen_mobility(self):
import numpy as N
self.dygraph = DyGraph(time_stop=100.0, time_step=10.0)
self.dygraph.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=100,
f_min=10,
f_max=100,
s_min=1,
s_max=100,
b_c=2,
radius=20.0,
nb_node=10,
)
self.assertEqual(N.ceil(100.0 / 10.0),
len(self.dygraph._slices))
def test_dygraph_with_timeline(self):
import numpy as N
self.dygraph = DyGraph(timeline=N.arange(0, 100, 10))
self.assertEqual(N.ceil(100.0 / 10.0), len(self.dygraph._slices))
def main():
from complex_systems.dygraph import DyGraph
from complex_systems.quasi_unit_disk_graph import gen_quasi_unit_disk_weight
from complex_systems.diffusion import Diffusion
import networkx as nx
import pylab as plt
# Variables
size_of_simulation_area = 1000.0
inner_radius = 10
outer_radius = 50
number_of_node = 100
simulation_length = 1000.0
sample_interval = 10.0
alpha = 0.8
# Generate a Graph with position
G = DyGraph(time_stop=simulation_length, time_step=sample_interval)
G.generate_mobility_levy_walk(
alpha=0.9,
beta=0.9,
size_max=size_of_simulation_area,
f_min=10,
f_max=1000,
s_min=5,
s_max=1000.0,
b_c=2,
radius=outer_radius,
nb_node=number_of_node,
)
G.generate_weights(inner_radius=inner_radius,
outer_radius=outer_radius, alpha=alpha)
slice_time_list = G.get_slice_time()
i = 1
for t in slice_time_list:
if t == 0.0:
[states, time_stamps, strategies, payoffs] = G.diffusion(t,
nb_steps=10, synergy=8.0,
cooperator_ratio=0.5)
else:
Gslice = G.get_graph(t)
pos = nx.get_node_attributes(Gslice, 'pos')
[states, time_stamps, strategies, payoffs] = G.diffusion(
t,
nb_steps=10,
synergy=8.0,
states=states,
time_stamps=time_stamps,
strategies=strategies,
payoffs=payoffs,
)
nbcoops = [strategy for strategy in strategies if strategy == 'C'].count()
Gslice = G.get_graph(t)
pos = nx.get_node_attributes(Gslice, 'pos')
nodelist_infected = [key for (key, val) in states.iteritems()
if val == 'I']
nodelist_not_infected = [key for (key, val) in
states.iteritems() if val == 'S']
plt.figure()
nx.draw_networkx(Gslice, nodelist=nodelist_infected, pos=pos, with_labels=False, node_size=20)
nx.draw_networkx(Gslice, nodelist=nodelist_not_infected, pos=pos, with_labels=False, node_size=20, node_color='g')
filename = 'diffusion_' + str("%04d" % i) + '.jpg'
plt.savefig(filename)
i += 1
time_stamps_list = [vals for (key, vals) in time_stamps.iteritems()]
plt.figure()
(n, bins, patches) = plt.hist(time_stamps_list, 50, normed=1,
histtype='bar', rwidth=0.8)
plt.show()
def run_simu(parameters, synergy):
import numpy as np
import networkx as nx
from complex_systems.dygraph import DyGraph
from complex_systems.pgg import PublicGoodGames
from complex_systems.quasi_unit_disk_graph import gen_quasi_unit_disk_weight
from complex_systems.quasi_unit_disk_graph import remove_edges_from_graph
number_of_node = parameters['number_of_node']
size_of_simulation_area = parameters['size_of_simulation_area']
outer_radius = parameters['outer_radius']
inner_radius = parameters['inner_radius']
alpha_quasi_unit_disk = parameters['alpha_quasi_unit_disk']
coop_ratio = parameters['initial_cooperator_ratio']
simulation_length = parameters['simulation_length']
sampling_interval = parameters['sampling_interval']
alpha_levy = parameters['alpha_levy']
noise_var = parameters['noise_variance']
beta = parameters['beta']
f_min = parameters['f_min']
f_max = parameters['f_max']
s_min = parameters['s_min']
s_max = parameters['s_max']
velocity = parameters['velocity']
G = DyGraph(time_stop=simulation_length, time_step=sampling_interval)
G.generate_mobility_levy_walk(
alpha=alpha_levy,
beta=beta,
size_max=size_of_simulation_area,
f_min=f_min,
f_max=f_max,
s_min=s_min,
s_max=s_max,
b_c=2,
radius=outer_radius,
nb_node=number_of_node,
velocity=velocity,
)
first_run = True
resultats = []
for g in G:
g = gen_quasi_unit_disk_weight(G=g,
outer_radius=outer_radius,
inner_radius=inner_radius,
alpha=alpha_quasi_unit_disk)
g = remove_edges_from_graph(g)
if first_run == True:
PGG = PublicGoodGames(G=g,
synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var)
nb_coop = PGG.run_game(sampling_interval)
resultats.append(nb_coop)
strategies = PGG.get_strategies()
first_run = False
else:
PGG = PublicGoodGames(G=g,
synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var)
PGG.set_strategies(strategies)
nb_coop = PGG.run_game(sampling_interval)
strategies = PGG.get_strategies()
resultats.append(nb_coop)
return (synergy, nb_coop, np.mean(G.avg_degree()))
def main(parameters):
import networkx as nx
from complex_systems.dygraph import DyGraph
from complex_systems.pgg_diffusion import PGG_diffusion
from complex_systems.quasi_unit_disk_graph import gen_quasi_unit_disk_weight
from complex_systems.quasi_unit_disk_graph import remove_edges_from_graph
import pylab as plt
import numpy as np
nb_node = 400
xmax = 1000
ymax = 1000
coop_ratio = 0.5
synergy = 9
nb_game_per_round = 1
nb_def = []
nb_coop = []
number_of_node = parameters['number_of_node']
nb_seeder = parameters['number_of_seeder']
size_of_simulation_area = parameters['size_of_simulation_area']
buffer_size = parameters['buffer_size']
outer_radius = parameters['outer_radius']
inner_radius = parameters['inner_radius']
alpha_quasi_unit_disk = parameters['alpha_quasi_unit_disk']
coop_ratio = parameters['initial_cooperator_ratio']
simulation_length = parameters['simulation_length']
sampling_interval = parameters['sampling_interval']
alpha_levy = parameters['alpha_levy']
#noise_var = parameters['noise_variance']
noise_var = 0.1
beta = parameters['beta']
f_min = parameters['f_min']
f_max = parameters['f_max']
s_min = parameters['s_min']
s_max = parameters['s_max']
velocity = parameters['velocity']
G = DyGraph(time_stop=simulation_length,
time_step=sampling_interval)
G.generate_mobility_levy_walk(
alpha=alpha_levy,
beta=beta,
size_max=xmax,
f_min=f_min,
f_max=f_max,
s_min=s_min,
s_max=s_max,
b_c=2,
radius=outer_radius,
nb_node=nb_node,
velocity=velocity,
)
first_run = True
for g in G:
g = gen_quasi_unit_disk_weight(G=g, outer_radius=outer_radius,
inner_radius=inner_radius, alpha=alpha_quasi_unit_disk)
g = remove_edges_from_graph(g)
if first_run == True:
PGG = PGG_diffusion(G=g, synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var,
buffer_size=buffer_size,
nb_seeder=int(nb_seeder))
PGG.run_game()
nb_def.append(PGG.defector_counter())
nb_coop.append(PGG.cooperator_counter())
strategies = PGG.get_strategies()
time_stamps = PGG.get_time_stamps()
states = PGG.get_states()
#sent_update = PGG.get_sent_update()
seeder = PGG.get_seeder()
#print time_stamps[0]
#print sent_update
#print strategies
#print states
first_run = False
else:
PGG = PGG_diffusion(G=g, synergy=synergy,
cooperator_ratio=coop_ratio,
buffer_size=buffer_size,
noise_var=noise_var)
PGG.set_strategies(strategies)
PGG.set_time_stamps(time_stamps)
PGG.set_nodes_states(states)
#PGG.set_sent_update(sent_update)
PGG.set_seeder(seeder)
res = PGG.run_game()
nb_def.append(PGG.defector_counter())
nb_coop.append(PGG.cooperator_counter())
strategies = PGG.get_strategies()
time_stamps = PGG.get_time_stamps()
states = PGG.get_states()
#print states
#print strategies
#print time_stamps[0]
#sent_update = PGG.get_sent_update()
#seeder = PGG.get_seeder()
#print seeder
print synergy, res, np.mean(G.avg_degree())
plt.figure()
plt.plot(nb_def,'b-*')
plt.plot(nb_coop,'r-*')
#plt.figure()
#print np.mean([val for key, val in G.degree().iteritems()])
#nx.draw_networkx(G, node_size=20, pos=p, with_labels = False)
time_stamps_dist = PGG.get_distribution_time_stamps()
x = []
y = []
for key,val in time_stamps_dist.iteritems():
x.append(key)
y.append(val)
plt.figure()
plt.bar(x,y)
plt.show()
def run_simu(parameters, synergy):
import numpy as np
import networkx as nx
from complex_systems.dygraph import DyGraph
from complex_systems.pgg import PublicGoodGames
from complex_systems.quasi_unit_disk_graph import gen_quasi_unit_disk_weight
from complex_systems.quasi_unit_disk_graph import remove_edges_from_graph
number_of_node = parameters['number_of_node']
size_of_simulation_area = parameters['size_of_simulation_area']
outer_radius = parameters['outer_radius']
inner_radius = parameters['inner_radius']
alpha_quasi_unit_disk = parameters['alpha_quasi_unit_disk']
coop_ratio = parameters['initial_cooperator_ratio']
simulation_length = parameters['simulation_length']
sampling_interval = parameters['sampling_interval']
alpha_levy = parameters['alpha_levy']
noise_var = parameters['noise_variance']
beta = parameters['beta']
f_min = parameters['f_min']
f_max = parameters['f_max']
s_min = parameters['s_min']
s_max = parameters['s_max']
velocity = parameters['velocity']
G = DyGraph(time_stop=simulation_length, time_step=sampling_interval)
G.generate_mobility_levy_walk(
alpha=alpha_levy,
beta=beta,
size_max=size_of_simulation_area,
f_min=f_min,
f_max=f_max,
s_min=s_min,
s_max=s_max,
b_c=2,
radius=outer_radius,
nb_node=number_of_node,
velocity=velocity,
)
first_run = True
resultats = []
for g in G:
g = gen_quasi_unit_disk_weight(G=g, outer_radius=outer_radius,
inner_radius=inner_radius, alpha=alpha_quasi_unit_disk)
g = remove_edges_from_graph(g)
if first_run == True:
PGG = PublicGoodGames(G=g, synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var)
nb_coop = PGG.run_game(sampling_interval)
resultats.append(nb_coop)
strategies = PGG.get_strategies()
first_run = False
else:
PGG = PublicGoodGames(G=g, synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var)
PGG.set_strategies(strategies)
nb_coop = PGG.run_game(sampling_interval)
strategies = PGG.get_strategies()
resultats.append(nb_coop)
return (synergy, nb_coop, np.mean(G.avg_degree()))
def main(parameters):
import networkx as nx
from complex_systems.dygraph import DyGraph
from complex_systems.pgg_diffusion import PGG_diffusion
from complex_systems.quasi_unit_disk_graph import gen_quasi_unit_disk_weight
from complex_systems.quasi_unit_disk_graph import remove_edges_from_graph
import pylab as plt
import numpy as np
nb_node = 400
xmax = 1000
ymax = 1000
coop_ratio = 0.5
synergy = 9
nb_game_per_round = 1
nb_def = []
nb_coop = []
number_of_node = parameters['number_of_node']
nb_seeder = parameters['number_of_seeder']
size_of_simulation_area = parameters['size_of_simulation_area']
buffer_size = parameters['buffer_size']
outer_radius = parameters['outer_radius']
inner_radius = parameters['inner_radius']
alpha_quasi_unit_disk = parameters['alpha_quasi_unit_disk']
coop_ratio = parameters['initial_cooperator_ratio']
simulation_length = parameters['simulation_length']
sampling_interval = parameters['sampling_interval']
alpha_levy = parameters['alpha_levy']
#noise_var = parameters['noise_variance']
noise_var = 0.1
beta = parameters['beta']
f_min = parameters['f_min']
f_max = parameters['f_max']
s_min = parameters['s_min']
s_max = parameters['s_max']
velocity = parameters['velocity']
G = DyGraph(time_stop=simulation_length, time_step=sampling_interval)
G.generate_mobility_levy_walk(
alpha=alpha_levy,
beta=beta,
size_max=xmax,
f_min=f_min,
f_max=f_max,
s_min=s_min,
s_max=s_max,
b_c=2,
radius=outer_radius,
nb_node=nb_node,
velocity=velocity,
)
first_run = True
for g in G:
g = gen_quasi_unit_disk_weight(G=g,
outer_radius=outer_radius,
inner_radius=inner_radius,
alpha=alpha_quasi_unit_disk)
g = remove_edges_from_graph(g)
if first_run == True:
PGG = PGG_diffusion(G=g,
synergy=synergy,
cooperator_ratio=coop_ratio,
noise_var=noise_var,
buffer_size=buffer_size,
nb_seeder=int(nb_seeder))
PGG.run_game()
nb_def.append(PGG.defector_counter())
nb_coop.append(PGG.cooperator_counter())
strategies = PGG.get_strategies()
time_stamps = PGG.get_time_stamps()
states = PGG.get_states()
#sent_update = PGG.get_sent_update()
seeder = PGG.get_seeder()
#print time_stamps[0]
#print sent_update
#print strategies
#print states
first_run = False
else:
PGG = PGG_diffusion(G=g,
synergy=synergy,
cooperator_ratio=coop_ratio,
buffer_size=buffer_size,
noise_var=noise_var)
PGG.set_strategies(strategies)
PGG.set_time_stamps(time_stamps)
PGG.set_nodes_states(states)
#PGG.set_sent_update(sent_update)
PGG.set_seeder(seeder)
res = PGG.run_game()
nb_def.append(PGG.defector_counter())
nb_coop.append(PGG.cooperator_counter())
strategies = PGG.get_strategies()
time_stamps = PGG.get_time_stamps()
states = PGG.get_states()
#print states
#print strategies
#print time_stamps[0]
#sent_update = PGG.get_sent_update()
#seeder = PGG.get_seeder()
#print seeder
print synergy, res, np.mean(G.avg_degree())
plt.figure()
plt.plot(nb_def, 'b-*')
plt.plot(nb_coop, 'r-*')
#plt.figure()
#print np.mean([val for key, val in G.degree().iteritems()])
#nx.draw_networkx(G, node_size=20, pos=p, with_labels = False)
time_stamps_dist = PGG.get_distribution_time_stamps()
x = []
y = []
for key, val in time_stamps_dist.iteritems():
x.append(key)
y.append(val)
plt.figure()
plt.bar(x, y)
plt.show()
def test_dygraph(self):
import numpy as N
self.dygraph = DyGraph(time_stop=100.0, time_step=10.0)
self.assertEqual(N.ceil(100.0 / 10.0),
len(self.dygraph._slices))
def test_dygraph_with_timeline(self):
import numpy as N
self.dygraph = DyGraph(timeline=N.arange(0,100,10))
self.assertEqual(N.ceil(100.0 / 10.0),
len(self.dygraph._slices))
def setUp(self):
self.dygraph = DyGraph()
def test_dygraph(self):
import numpy as N
self.dygraph = DyGraph(time_stop=100.0, time_step=10.0)
self.assertEqual(N.ceil(100.0 / 10.0), len(self.dygraph._slices))
def setUp(self):
self.dygraph = DyGraph()
