From 7a7cae0eb8622d5549a9ba552ea510cf40b7664d Mon Sep 17 00:00:00 2001 From: lucieho Date: Wed, 29 Mar 2017 11:26:02 +0200 Subject: [PATCH] Update ARE-DYNAMIC.py --- ARE-DYNAMIC.py | 175 +++++++++++++++++++++++++++++++------------------ 1 file changed, 112 insertions(+), 63 deletions(-) diff --git a/ARE-DYNAMIC.py b/ARE-DYNAMIC.py index 3f4a06a..7c1054d 100644 --- a/ARE-DYNAMIC.py +++ b/ARE-DYNAMIC.py @@ -59,7 +59,7 @@ TypeGrilleInitiale = 3 Iteration = 0 # nombre max d'itérations -MaxIterations = 100 +MaxIterations = 4 # stratégie par défaut StratParDefaut = 0 @@ -73,13 +73,11 @@ ListePourcents = list() #Couleurs des Stratégies CouleursStrat=['b','r','black','g','purple'] -#Vitesse de défilement des affichages dynamiques -Vitesse = 500 """ Types: Coord = tuple(x, y) - Joueur = dict("etat", "historique_etats", "strategie", "annees_de_prison", "historique_strategies") + Joueur = dict("x", "y", "etat", "historique_etats", "strategie", "annees_de_prison", "historique_strategies") GrilleJoueurs = matrice2d(Joueur) """ @@ -98,7 +96,10 @@ def gen_matrice_initiale(): def partie1v1(joueur, adversaire): """ + Joueur^2 -> int + Effectue une partie à deux joueurs + Renvoie: paire (prison_joueur, prison_adversaire) """ stratj = ListeStrategies[joueur["strategie"]] @@ -140,8 +141,12 @@ def partie1v1(joueur, adversaire): joueur["annees_de_prison"] += ans_prison[0] adversaire["annees_de_prison"] += ans_prison[1] + return ans_prison + def partie8tours(x,y): - """ + """ + Coord -> NoneType + Effectue huit parties 1v1 entre le joueur et chacun de ses voisins l'un après l'autre """ for i in range (-1,2): @@ -161,12 +166,13 @@ def partie_globale(): partie8tours(i,j) # 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 - copie_grille = np.copy(Grille) + # 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) for x in range(len(copie_grille)): 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"] new_strat = copie_grille[x][y]["strategie"] for i in range (-1,2): @@ -178,7 +184,10 @@ def partie_globale(): # Réinitialisation du nb d'années de prison for j in range(len(Grille[0])): - Grille[i][j]['annees_de_prison'] = 0 + Grille[i][j]['annees_de_prison'] = 0 + + return Grille + ##################################### @@ -192,7 +201,9 @@ def matrice_init_vide(): return [[dict() for x in range(TailleGrilleX)] for y in range(TailleGrilleY)] def matrice_init_meme_strat(): - """ + """ + int -> array + Index: 0 Crée la matrice des joueurs où chacun a la même stratégie @@ -202,16 +213,19 @@ def matrice_init_meme_strat(): histo_strat = [StratParDefaut] matrice = matrice_init_vide() + for i in range(TailleGrilleY): for j in range(TailleGrilleX): etat = random.randint(0, 1) - matrice[i][j] = {'etat' : etat, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\ + matrice[i][j] = {'x' : i, 'y':j, 'etat' : etat, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\ 'historique_strategies' : histo_strat, 'historique_etats' : [etat]} return matrice def matrice_init_nie_sauf_un(): - """ + """ + int -> array + Index: 1 Crée la matrice des joueurs tel que chaque joueurs @@ -224,7 +238,7 @@ def matrice_init_nie_sauf_un(): for i in range(TailleGrilleY): for j in range(TailleGrilleX): - matrice[i][j] = {'etat' : 1, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\ + matrice[i][j] = {'x' : i, 'y' : j, 'etat' : 1, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\ 'historique_strategies' : histo_strat, 'historique_etats' : [1]} index_aleatoirex = random.randint(0,TailleGrilleX-1) @@ -234,7 +248,9 @@ def matrice_init_nie_sauf_un(): return matrice def matrice_init_avoue_sauf_un(): - """ + """ + int -> array + Index: 2 Créer la matrice des joueurs tel que chaque joueur avoue, @@ -246,7 +262,7 @@ def matrice_init_avoue_sauf_un(): for i in range(TailleGrilleY): for j in range(TailleGrilleX): - matrice[i][j] = {'etat' : 0, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\ + matrice[i][j] = {'x' : i, 'y' : j, 'etat' : 0, 'strategie' : StratParDefaut, 'annees_de_prison' : 0,\ 'historique_strategies' : histo_strat, 'historique_etats' : [0]} index_aleatoirex = random.randint(0,TailleGrilleX-1) @@ -282,7 +298,7 @@ def matrice_init_equitable(): count_joueurs += 1 places_vides -= 1 - for i in range(TailleGrilleY): #on vérifie qu'il ne reste pas d'index vides + for i in range(TailleGrilleY): #on vérifie qu'il n'y a pas d'index vides for j in range(TailleGrilleX): #si oui, on le rempli avec une strat aléatoire if matrice_strat[i][j] == -1: matrice_strat[i][j] = random.randint(0, len(ListeStrategies)) @@ -292,13 +308,15 @@ def matrice_init_equitable(): for i in range(TailleGrilleY): for j in range(TailleGrilleX): etat = random.randint(0, 1) - matrice[i][j] = {'etat' : etat, 'strategie' : matrice_strat[i][j], 'annees_de_prison' : 0,\ + matrice[i][j] = {'x' : i, 'y' : j, 'etat' : etat, 'strategie' : matrice_strat[i][j], 'annees_de_prison' : 0,\ 'historique_strategies' : [matrice_strat[i][j]], 'historique_etats' : [etat]} return matrice def matrice_init_pourcents_choisis(): - """ + """ + list[float] -> array + Index: 4 ListePourcents contient des float de 0.0 à 1.0. @@ -340,7 +358,7 @@ def matrice_init_pourcents_choisis(): for i in range(TailleGrilleY): for j in range(TailleGrilleX): etat = random.randint(0, 1) - matrice[i][j] = {'etat' : etat, 'strategie' : matrice_strat[i][j], 'annees_de_prison' : 0,\ + matrice[i][j] = {'x' : i, 'y' : j, 'etat' : etat, 'strategie' : matrice_strat[i][j], 'annees_de_prison' : 0,\ 'historique_strategies' : [matrice_strat[i][j]], 'historique_etats' : [etat]} return matrice @@ -349,7 +367,9 @@ def matrice_init_pourcents_choisis(): ### Fonction stratégies def strat_toujours_nier(joueur, adversaire): - """ + """ + Joueur^2 -> int + Index: 0 Toujours nier (coopération) @@ -357,31 +377,30 @@ def strat_toujours_nier(joueur, adversaire): return 0 # 0 : coop def strat_toujours_avouer(joueur, adversaire): - """ + """ + Joueur^2 -> int + Index: 1 Toujours avouer (trahir) """ return 1 #1 : traître -def strat_meilleur_gain(joueur, adversaire): +def strat_altern(joueur, adversaire): """ + Joueur^2 -> int + Index: 2 - - Le joueur adopte l'état de l'adversaire ayant obtenu le meilleur gain (= le moins d'années de prison) + + Le joueur alterne entre nier et avouer """ - max_gain = joueur['annees_de_prison'] - nveau_etat = joueur['etat'] - for i in range (-1,2): - for j in range (-1,2): #(i,j) sont les coordonnées de l'adversaire - if (0 <= x+i and x+i < len(Grille)) and (0 <= y+j and y+j < len(Grille[0])) and i != 0 and j != 0: - if Grille[i][j]['annees_de_prison'] < max_gain : - max_gain = Grille[i][j]['annees_de_prison'] - nveau_etat = Grille[i][j]['etat'] - return nveau_etat + + return 1 - joueur['etat'] def strat_precedent_adversaire(joueur, adversaire): - """ + """ + Joueur^2 -> int + 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) @@ -389,7 +408,9 @@ def strat_precedent_adversaire(joueur, adversaire): return adversaire['historique_etats'][len(adversaire['historique_etats'])-1] == 0 def strat_principal_adversaire(joueur, adversaire): - """ + """ + Joueur^2 -> int + 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) @@ -410,6 +431,28 @@ def strat_principal_adversaire(joueur, adversaire): else: return 0 +def strat_meilleur_gain (joueur, adversaire): + """ + Joueur^2 -> int + + Index : 5 + + Le joueur adopte l'état de l'adversaire ayant obtenu le meilleur gain (= le moins d'années de prison) + """ + max_gain = joueur['annees_de_prison'] + nveau_etat = joueur['etat'] + x = joueur['x'] + y = joueur['y'] + for i in range (-1,2): + for j in range (-1,2): #(i,j) sont les coordonnées de l'adversaire + if (0 <= x+i and x+i < len(Grille)) and (0 <= y+j and y+j < len(Grille[0])) and i != 0 and j != 0: + if Grille[i][j]['annees_de_prison'] < max_gain : + max_gain = Grille[i][j]['annees_de_prison'] + nveau_etat = Grille[i][j]['etat'] + return nveau_etat + + + ############################################################################### ############## @@ -419,7 +462,6 @@ def init_complete(): """ Rajoute à ListeStrategies toutes les fonctions stratégies Rajoute à ListeGenGrille toutes les fonctions de génération de grille - Initialise la grille et StratsResultats """ ListeGenGrille.append(matrice_init_meme_strat) # 0 @@ -430,7 +472,7 @@ def init_complete(): ListeStrategies.append(strat_toujours_nier) # 0 ListeStrategies.append(strat_toujours_avouer) # 1 - ListeStrategies.append(strat_meilleur_gain) # 2 + ListeStrategies.append(strat_altern) # 2 ListeStrategies.append(strat_precedent_adversaire) # 3 ListeStrategies.append(strat_principal_adversaire) # 4 @@ -451,7 +493,6 @@ def init_complete(): def simulation(): global Iteration global HistoriqueGrilles - Iteration = 0 @@ -470,7 +511,7 @@ def simulation(): for y in range(TailleGrilleY): if Grille[x][y]["strategie"] == i: StratsResultats[i][2][Iteration][0] += 1 - + return Grille @@ -479,15 +520,14 @@ def simulation(): 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)) + matrice = HistoriqueGrilles[i] + for ligne in range (0,TailleGrilleX): #int ligne for colonne in range (0, TailleGrilleY): #int colonne matR[ligne][colonne]=matrice[ligne][colonne][param] @@ -496,7 +536,6 @@ def matRecup(i, param): def afficher_strat_dynamique(): - fig=plt.figure() fig.suptitle('Animation des stratégies') @@ -506,7 +545,7 @@ def afficher_strat_dynamique(): norm=mpl.colors.BoundaryNorm(bounds, cmap.N) 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) cb.set_ticklabels(labels) @@ -514,13 +553,12 @@ def afficher_strat_dynamique(): img.set_array(matRecup(next_iteration , 'strategie')) return [img] - anim = animation.FuncAnimation(fig, update, frames=range(MaxIterations), interval= Vitesse, repeat = False) + anim = animation.FuncAnimation(fig, update, frames=range(MaxIterations), interval=500, repeat = False) plt.show(block = True) def afficher_etat_dynamique(): - fig=plt.figure() fig.suptitle('Animation des états') @@ -530,7 +568,7 @@ def afficher_etat_dynamique(): norm=mpl.colors.BoundaryNorm(bounds, cmap.N) 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) cb.set_ticklabels(labels) @@ -538,30 +576,40 @@ def afficher_etat_dynamique(): img.set_array(matRecup(next_iteration , 'etat')) return [img] - anim = animation.FuncAnimation(fig, update, frames=range(MaxIterations), interval= Vitesse, repeat = False) + anim = animation.FuncAnimation(fig, update, frames=range(MaxIterations), interval=500, repeat = False) plt.show(block = True) 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 + #list gain gain=[] + #list strat stratUtili=[] #nb_utilisations utilisateurs=list() + #uti[strat][iter] = nb - #iterations + #iteration iteration=[] - for i in range(len(ListeStrategies)): - stratUtili.append(StratsResultats[i][0]) + for i in range(5): + gain.append(0) + stratUtili.append(0) + + for i in range(0,len(ListeStrategies)): + stratUtili[i]=StratsResultats[i][0] if StratsResultats[i][0]==0: - gain.append(0) + gain[i] else: - gain.append(StratsResultats[i][1]/StratsResultats[i][0]) + gain[i]=StratsResultats[i][1]/StratsResultats[i][0] utilisateurs.append([]) for i in range(0,MaxIterations+1): @@ -602,21 +650,22 @@ def affichage_strats_resultats_totaux(): plt.legend() +init_complete() +simulation() +afficher_etat_dynamique() +affichage_strats_resultats_totaux() + + -# fonction de debug, ne pas utiliser """ def _ext(M): K = np.ndarray((TailleGrilleX, TailleGrilleY)) for x in range(len(M)): for y in range(len(M[0])): - K[x][y] = M[x][y]["etat"] + K[x][y] = M[x][y]["strategie"] return K +print(_ext(simulation())) """ -if __name__ == "__main__": - init_complete() - simulation() - afficher_strat_dynamique() -