julian
/
ARE_Dynamic_2017
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update ARE-DYNAMIC.py

This commit is contained in:
julianb0 2017-03-29 09:46:20 +02:00 committed by GitHub
parent aabe636773
commit f603fff8ce
1 changed files with 40 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
ARE-DYNAMIC.py
View File

@ -59,7 +59,7 @@ TypeGrilleInitiale = 3
Iteration = 0 Iteration = 0
# nombre max d'itérations # nombre max d'itérations
MaxIterations = 4 MaxIterations = 100
# stratégie par défaut # stratégie par défaut
StratParDefaut = 0 StratParDefaut = 0
@ -96,10 +96,7 @@ def gen_matrice_initiale():
def partie1v1(joueur, adversaire): def partie1v1(joueur, adversaire):
""" """
Joueur^2 -> int
Effectue une partie à deux joueurs Effectue une partie à deux joueurs
Renvoie: paire (prison_joueur, prison_adversaire)
""" """
stratj = ListeStrategies[joueur["strategie"]] stratj = ListeStrategies[joueur["strategie"]]
@ -141,12 +138,8 @@ def partie1v1(joueur, adversaire):
joueur["annees_de_prison"] += ans_prison[0] joueur["annees_de_prison"] += ans_prison[0]
adversaire["annees_de_prison"] += ans_prison[1] adversaire["annees_de_prison"] += ans_prison[1]
return ans_prison
def partie8tours(x,y): def partie8tours(x,y):
""" """
Coord -> NoneType
Effectue huit parties 1v1 entre le joueur et chacun de ses voisins l'un après l'autre Effectue huit parties 1v1 entre le joueur et chacun de ses voisins l'un après l'autre
""" """
for i in range (-1,2): for i in range (-1,2):
@ -166,13 +159,12 @@ def partie_globale():
partie8tours(i,j) partie8tours(i,j)
# Changement des stratégies # Changement des stratégies
# On parcourt une copie de la grille pour avoir accès aux anciennes stratégies et non pas aux nouvelles adoptées # On parcourt une copie de la grille pour avoir accès aux anciennes stratégies et non pas aux nouvelles adoptées
copie_grille = np.copy(Grille) copie_grille = np.copy(Grille)
for x in range(len(copie_grille)): for x in range(len(copie_grille)):
for y in range(len(copie_grille[0])): for y in range(len(copie_grille[0])):
#(x,y) : joueur dont on va modifier la stratégie, si besoin # (x,y) : joueur dont on va modifier la stratégie, si besoin
min_prison = copie_grille[x][y]["annees_de_prison"] min_prison = copie_grille[x][y]["annees_de_prison"]
new_strat = copie_grille[x][y]["strategie"] new_strat = copie_grille[x][y]["strategie"]
for i in range (-1,2): for i in range (-1,2):
@ -186,9 +178,6 @@ def partie_globale():
for j in range(len(Grille[0])): for j in range(len(Grille[0])):
Grille[i][j]['annees_de_prison'] = 0 Grille[i][j]['annees_de_prison'] = 0
return Grille
##################################### #####################################
### Fonction génératrices de matrices ### Fonction génératrices de matrices
@ -202,8 +191,6 @@ def matrice_init_vide():
def matrice_init_meme_strat(): def matrice_init_meme_strat():
""" """
int -> array
Index: 0 Index: 0
Crée la matrice des joueurs où chacun a la même stratégie Crée la matrice des joueurs où chacun a la même stratégie
@ -213,7 +200,6 @@ def matrice_init_meme_strat():
histo_strat = [StratParDefaut] histo_strat = [StratParDefaut]
matrice = matrice_init_vide() matrice = matrice_init_vide()
for i in range(TailleGrilleY): for i in range(TailleGrilleY):
for j in range(TailleGrilleX): for j in range(TailleGrilleX):
etat = random.randint(0, 1) etat = random.randint(0, 1)
@ -224,8 +210,6 @@ def matrice_init_meme_strat():
def matrice_init_nie_sauf_un(): def matrice_init_nie_sauf_un():
""" """
int -> array
Index: 1 Index: 1
Crée la matrice des joueurs tel que chaque joueurs Crée la matrice des joueurs tel que chaque joueurs
@ -249,8 +233,6 @@ def matrice_init_nie_sauf_un():
def matrice_init_avoue_sauf_un(): def matrice_init_avoue_sauf_un():
""" """
int -> array
Index: 2 Index: 2
Créer la matrice des joueurs tel que chaque joueur avoue, Créer la matrice des joueurs tel que chaque joueur avoue,
@ -298,7 +280,7 @@ def matrice_init_equitable():
count_joueurs += 1 count_joueurs += 1
places_vides -= 1 places_vides -= 1
for i in range(TailleGrilleY): #on vérifie qu'il n'y a pas d'index vides for i in range(TailleGrilleY): #on vérifie qu'il ne reste pas d'index vides
for j in range(TailleGrilleX): #si oui, on le rempli avec une strat aléatoire for j in range(TailleGrilleX): #si oui, on le rempli avec une strat aléatoire
if matrice_strat[i][j] == -1: if matrice_strat[i][j] == -1:
matrice_strat[i][j] = random.randint(0, len(ListeStrategies)) matrice_strat[i][j] = random.randint(0, len(ListeStrategies))
@ -315,8 +297,6 @@ def matrice_init_equitable():
def matrice_init_pourcents_choisis(): def matrice_init_pourcents_choisis():
""" """
list[float] -> array
Index: 4 Index: 4
ListePourcents contient des float de 0.0 à 1.0. ListePourcents contient des float de 0.0 à 1.0.
@ -368,8 +348,6 @@ def matrice_init_pourcents_choisis():
def strat_toujours_nier(joueur, adversaire): def strat_toujours_nier(joueur, adversaire):
""" """
Joueur^2 -> int
Index: 0 Index: 0
Toujours nier (coopération) Toujours nier (coopération)
@ -378,8 +356,6 @@ def strat_toujours_nier(joueur, adversaire):
def strat_toujours_avouer(joueur, adversaire): def strat_toujours_avouer(joueur, adversaire):
""" """
Joueur^2 -> int
Index: 1 Index: 1
Toujours avouer (trahir) Toujours avouer (trahir)
@ -388,8 +364,6 @@ def strat_toujours_avouer(joueur, adversaire):
def strat_altern(joueur, adversaire): def strat_altern(joueur, adversaire):
""" """
Joueur^2 -> int
Index: 2 Index: 2
Le joueur alterne entre nier et avouer Le joueur alterne entre nier et avouer
@ -399,8 +373,6 @@ def strat_altern(joueur, adversaire):
def strat_precedent_adversaire(joueur, adversaire): def strat_precedent_adversaire(joueur, adversaire):
""" """
Joueur^2 -> int
Index: 3 Index: 3
Le joueur avoue/nie si durant la partie locale précédente, son adversaire avait avoué/nié (on utilise l'hisorique des états) Le joueur avoue/nie si durant la partie locale précédente, son adversaire avait avoué/nié (on utilise l'hisorique des états)
@ -409,8 +381,6 @@ def strat_precedent_adversaire(joueur, adversaire):
def strat_principal_adversaire(joueur, adversaire): def strat_principal_adversaire(joueur, adversaire):
""" """
Joueur^2 -> int
Index: 4 Index: 4
Le joueur avoue/nie si l’adversaire avait majoritairement avoué/nié durant ses parties précédentes (on utilise l'hisorique des états) Le joueur avoue/nie si l’adversaire avait majoritairement avoué/nié durant ses parties précédentes (on utilise l'hisorique des états)
@ -440,6 +410,7 @@ def init_complete():
""" """
Rajoute à ListeStrategies toutes les fonctions stratégies Rajoute à ListeStrategies toutes les fonctions stratégies
Rajoute à ListeGenGrille toutes les fonctions de génération de grille Rajoute à ListeGenGrille toutes les fonctions de génération de grille
Initialise la grille et StratsResultats
""" """
ListeGenGrille.append(matrice_init_meme_strat) # 0 ListeGenGrille.append(matrice_init_meme_strat) # 0
@ -472,6 +443,7 @@ def simulation():
global Iteration global Iteration
global HistoriqueGrilles global HistoriqueGrilles
Iteration = 0 Iteration = 0
while Iteration <= MaxIterations: while Iteration <= MaxIterations:
@ -498,14 +470,15 @@ def simulation():
def matRecup(i, param): def matRecup(i, param):
"""array*str-> array """
Récupère la matrice avec seulement le paramètre stratégie pour chaque joueur , à litération i voulue""" array * str -> array
Récupère la matrice avec seulement le paramètre stratégie pour chaque joueur , à litération i voulue
"""
matR = np.random.randint(0,1,(TailleGrilleX,TailleGrilleY)) matR = np.random.randint(0,1,(TailleGrilleX,TailleGrilleY))
matrice = HistoriqueGrilles[i] matrice = HistoriqueGrilles[i]
for ligne in range (0,TailleGrilleX): #int ligne for ligne in range (0,TailleGrilleX): #int ligne
for colonne in range (0, TailleGrilleY): #int colonne for colonne in range (0, TailleGrilleY): #int colonne
matR[ligne][colonne]=matrice[ligne][colonne][param] matR[ligne][colonne]=matrice[ligne][colonne][param]
@ -514,6 +487,7 @@ def matRecup(i, param):
def afficher_strat_dynamique(): def afficher_strat_dynamique():
fig=plt.figure() fig=plt.figure()
fig.suptitle('Animation des stratégies') fig.suptitle('Animation des stratégies')
@ -523,7 +497,7 @@ def afficher_strat_dynamique():
norm=mpl.colors.BoundaryNorm(bounds, cmap.N) norm=mpl.colors.BoundaryNorm(bounds, cmap.N)
img=plt.imshow(matRecup(0, 'strategie'), interpolation = "nearest", cmap = cmap , norm = norm) img=plt.imshow(matRecup(0, 'strategie'), interpolation = "nearest", cmap = cmap , norm = norm)
cb=plt.colorbar(img , cmap=cmap , norm=norm , boundaries = bounds , ticks=bounds) cb=plt.colorbar(img , cmap = cmap , norm=norm , boundaries = bounds , ticks = bounds)
labels = np.arange(0, 5, 1) labels = np.arange(0, 5, 1)
cb.set_ticklabels(labels) cb.set_ticklabels(labels)
@ -537,6 +511,7 @@ def afficher_strat_dynamique():
def afficher_etat_dynamique(): def afficher_etat_dynamique():
fig=plt.figure() fig=plt.figure()
fig.suptitle('Animation des états') fig.suptitle('Animation des états')
@ -546,7 +521,7 @@ def afficher_etat_dynamique():
norm=mpl.colors.BoundaryNorm(bounds, cmap.N) norm=mpl.colors.BoundaryNorm(bounds, cmap.N)
img=plt.imshow(matRecup(0, 'etat'), interpolation = "nearest", cmap = cmap , norm = norm) img=plt.imshow(matRecup(0, 'etat'), interpolation = "nearest", cmap = cmap , norm = norm)
cb=plt.colorbar(img , cmap=cmap , norm=norm , boundaries = bounds , ticks=bounds) cb=plt.colorbar(img , cmap = cmap , norm = norm , boundaries = bounds , ticks = bounds)
labels = np.arange(0, 2, 1) labels = np.arange(0, 2, 1)
cb.set_ticklabels(labels) cb.set_ticklabels(labels)
@ -560,34 +535,24 @@ def afficher_etat_dynamique():
def affichage_strats_resultats_totaux(): def affichage_strats_resultats_totaux():
"""array->graph
Retourne les diagrammes en baton qui mettent en évidence le nombre moyen d'années
de prison en fonction de la stratégie et le nombre d'utilisation de chaque stratégies """
#initialisation des paramètres #initialisation des paramètres
#list gain
gain=[] gain=[]
#list strat
stratUtili=[] stratUtili=[]
#nb_utilisations #nb_utilisations
utilisateurs=list() utilisateurs=list()
#uti[strat][iter] = nb #uti[strat][iter] = nb
#iteration #iterations
iteration=[] iteration=[]
for i in range(5): for i in range(len(ListeStrategies)):
gain.append(0) stratUtili.append(StratsResultats[i][0])
stratUtili.append(0)
for i in range(0,len(ListeStrategies)):
stratUtili[i]=StratsResultats[i][0]
if StratsResultats[i][0]==0: if StratsResultats[i][0]==0:
gain[i] gain.append(0)
else: else:
gain[i]=StratsResultats[i][1]/StratsResultats[i][0] gain.append(StratsResultats[i][1]/StratsResultats[i][0])
utilisateurs.append([]) utilisateurs.append([])
for i in range(0,MaxIterations+1): for i in range(0,MaxIterations+1):
@ -628,23 +593,22 @@ def affichage_strats_resultats_totaux():
plt.legend() plt.legend()
if __name__ == "__main__":
init_complete()
simulation()
affichage_strats_resultats_totaux()
# fonction de debug, ne pas utiliser
""" """
def _ext(M): def _ext(M):
K = np.ndarray((TailleGrilleX, TailleGrilleY)) K = np.ndarray((TailleGrilleX, TailleGrilleY))
for x in range(len(M)): for x in range(len(M)):
for y in range(len(M[0])): for y in range(len(M[0])):
K[x][y] = M[x][y]["strategie"] K[x][y] = M[x][y]["etat"]
return K return K
print(_ext(simulation()))
""" """
if __name__ == "__main__":
init_complete()
simulation()
afficher_strat_dynamique()