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:
Julian B 2017-04-17 21:02:18 +02:00 committed by GitHub
parent d1167883dd
commit b5c92e527e
1 changed files with 148 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

204
ARE-DYNAMIC.py
View File

@ -31,7 +31,7 @@ from tkinter.ttk import *
TailleGrilleX = 15 TailleGrilleX = 15
TailleGrilleY = 15 TailleGrilleY = 15
# Grille # la grille
Grille = np.ndarray((TailleGrilleX, TailleGrilleY)) Grille = np.ndarray((TailleGrilleX, TailleGrilleY))
# historique des grilles aux itérations précédentes # historique des grilles aux itérations précédentes
@ -43,9 +43,9 @@ HistoriqueGrilles = list()
# nb_utilisations = nombre total d'utilisations de la stratégie # nb_utilisations = nombre total d'utilisations de la stratégie
# total_ans_prisons = total d'années de prisons subies par les utilisateurs de la stratégie # total_ans_prisons = total d'années de prisons subies par les utilisateurs de la stratégie
# utilisation_detail[i] = une liste de triplets [utilisateurs, utilisations, prisons] # utilisation_detail[i] = une liste de triplets [utilisateurs, utilisations, prisons]
# représentant, à la fin de l'itération i, le nombre d'utilisateurs, le nombre d'utilisations # utilisateur = nombre d'utilisateurs de la stratégie a la FIN de l'iteration i
# ainsi quel le nombre d'années de prisons qu'ils ont accumulés # utilisations = le nombre de fois que la fonction stratégie a été appelée au course de l'itération i
# attention, le nombre d'utilisateurs stockés est # prisons = nombre total d'années de prisons pris par les utilisateurs de la stratégie au course de l'itération i
StratsResultats = list() StratsResultats = list()
# liste des stratégies (fonctions Joueur^2 -> {0, 1} décidant si un joueur nie ou non en fonction de son adversaire) # liste des stratégies (fonctions Joueur^2 -> {0, 1} décidant si un joueur nie ou non en fonction de son adversaire)
@ -72,8 +72,8 @@ AffichageDynamique = True
# nécessaire pour matrice_init_pourcents_choisis() # nécessaire pour matrice_init_pourcents_choisis()
ListePourcents = list() ListePourcents = list()
#Couleurs des Stratégies # couleurs des stratégies (pour l'affichage dynamique)
CouleursStrat=['b','r','black','g','purple','yellow'] CouleursStrat = ['b','r','black','g','purple','yellow']
# Vitesse de défilement des images dans l'affichage dynamique en millisecondes # Vitesse de défilement des images dans l'affichage dynamique en millisecondes
Vitesse = 1 Vitesse = 1
@ -81,32 +81,33 @@ Vitesse = 1
# Fonction pour le GUI # Fonction pour le GUI
def saisir_les_pourcentages(): def saisir_les_pourcentages():
""" """
S'il y a eu clic sur le bouton du S'il y a eu clic sur le bouton du
type 4, affiche 5 entry box pour type 4, affiche 5 entry box pour
saisir les pourcentages voulus saisir les pourcentages voulus
""" """
Label(fenetre, text="% stratégie0:").grid(row=9, column =0) Label(fenetre, text="% stratégie0:").grid(row=9, column =0)
per0=IntVar() per0 = IntVar()
Entry(fenetre, textvariable=per0, width=3).grid(row=9, column=1) Entry(fenetre, textvariable=per0, width=3).grid(row=9, column=1)
Label(fenetre, text ="% stratégie1:").grid(row=10, column=0) Label(fenetre, text ="% stratégie1:").grid(row=10, column=0)
per1 =IntVar() per1 = IntVar()
Entry(fenetre, textvariable=per1, width=3).grid(row=10, column=1) Entry(fenetre, textvariable=per1, width=3).grid(row=10, column=1)
Label(fenetre, text ="% stratégie2:").grid(row=11, column=0) Label(fenetre, text ="% stratégie2:").grid(row=11, column=0)
per2 =IntVar() per2 = IntVar()
Entry(fenetre, textvariable=per2, width=3).grid(row=11, column=1) Entry(fenetre, textvariable=per2, width=3).grid(row=11, column=1)
Label(fenetre, text ="% stratégie3:").grid(row=12, column=0) Label(fenetre, text ="% stratégie3:").grid(row=12, column=0)
per3 =IntVar() per3 = IntVar()
Entry(fenetre, textvariable=per3, width=3).grid(row=12, column=1) Entry(fenetre, textvariable=per3, width=3).grid(row=12, column=1)
Label(fenetre, text ="% stratégie4:").grid(row=13, column=0) Label(fenetre, text ="% stratégie4:").grid(row=13, column=0)
per4 =IntVar() per4 = IntVar()
Entry(fenetre, textvariable=per4, width=3).grid(row=13, column=1) Entry(fenetre, textvariable=per4, width=3).grid(row=13, column=1)
global ListePourcents global ListePourcents
ListePourcents=[per0.get(), per1.get(), per2.get(), per3.get(), per4.get()] ListePourcents = [per0.get(), per1.get(), per2.get(), per3.get(), per4.get()]
@ -119,20 +120,16 @@ Types:
##################################### #####################################
### Génération de la matrice initiale ### Génération de la matrice initiale
def gen_matrice_initiale():
"""
NoneType -> GrilleJoueurs
"""
fonction_gen = ListeGenGrille[TypeGrilleInitiale]
return fonction_gen() def gen_matrice_initiale():
return (ListeGenGrille[TypeGrilleInitiale])()
############################## ##############################
### Execution des tours / jeux ### Execution des tours / jeux
def partie1v1(joueur, adversaire): def partie1v1(joueur, adversaire):
""" """
Joueur^2 -> int Joueur^2 -> int^2
Effectue une partie à deux joueurs Effectue une partie à deux joueurs
Renvoie: paire (prison_joueur, prison_adversaire) Renvoie: paire (prison_joueur, prison_adversaire)
@ -245,8 +242,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
@ -267,8 +262,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
@ -292,8 +285,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,
@ -316,11 +307,11 @@ def matrice_init_avoue_sauf_un():
def matrice_init_equitable(): def matrice_init_equitable():
""" """
Index: 3
Crée la matrice des joueurs tel que le probabilité d'apparition de chaque Crée la matrice des joueurs tel que le probabilité d'apparition de chaque
stratégie est équitable. Les états initiaux de chaque stratégie est équitable. Les états initiaux de chaque
joueur sont aléatoires. joueur sont aléatoires.
Index: 3
""" """
matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int) matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int)
@ -358,8 +349,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.
@ -411,30 +400,21 @@ 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)
""" """
return 0 # 0 : coop return 0 # 0 : coop
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)
""" """
return 1 #1 : traître return 1 #1 : traître
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
""" """
@ -442,20 +422,14 @@ 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)
""" """
return adversaire['historique_etats'][len(adversaire['historique_etats'])-1] == 0 return adversaire['historique_etats'][len(adversaire['historique_etats'])-1] == 0
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)
Si aucun état n’est majoritaire, la coopération l’emporte (le joueur nie) Si aucun état n’est majoritaire, la coopération l’emporte (le joueur nie)
""" """
@ -476,7 +450,6 @@ def strat_principal_adversaire(joueur, adversaire):
def strat_meilleur_gain (joueur, adversaire): def strat_meilleur_gain (joueur, adversaire):
""" """
Joueur^2 -> int
Index : 5 Index : 5
Le joueur adopte l'état de l'adversaire ayant obtenu le meilleur gain (= le moins d'années de prison) Le joueur adopte l'état de l'adversaire ayant obtenu le meilleur gain (= le moins d'années de prison)
""" """
@ -495,26 +468,24 @@ def strat_meilleur_gain (joueur, adversaire):
###################### ######################
#INTERFACE GRAPHIQUE UTILISATEUR (GUI) #INTERFACE GRAPHIQUE UTILISATEUR (GUI)
###################### ######################
# Fonctions pour command
######################
# Initialise la fenetre principale # Initialise la fenetre principale
fenetre=Tk() fenetre = Tk()
# Taille en abscisse de la matrice # Taille en abscisse de la matrice
X=IntVar(fenetre) X = IntVar(fenetre)
# Taille en ordonnée de la matrice # Taille en ordonnée de la matrice
Y=IntVar(fenetre) Y = IntVar(fenetre)
# Strategie definie pour le type 1 # Strategie definie pour le type 1
Strat=IntVar(fenetre) Strat = IntVar(fenetre)
# Type de matrice selectionné par l'user # Type de matrice selectionné par l'user
Var_choix=IntVar(fenetre) Var_choix = IntVar(fenetre)
# Nombre d'itérations maximum # Nombre d'itérations maximum
It=IntVar(fenetre) It = IntVar(fenetre)
# Vitesse de défilement des images dans l'affichage dynamique en millisecondes, pré-variable IntVar # Vitesse de défilement des images dans l'affichage dynamique en millisecondes, pré-variable IntVar
Vit = IntVar() Vit = IntVar()
@ -524,7 +495,7 @@ def affichage_fenetre_infos():
S'il y a eu clic sur le bouton "Infos", affiche une fenetre contenant S'il y a eu clic sur le bouton "Infos", affiche une fenetre contenant
le détail de chaque stratégie et de chaque type de matrice de départ. le détail de chaque stratégie et de chaque type de matrice de départ.
""" """
fenetre_infos=Tk() fenetre_infos = Tk()
Label(fenetre_infos, text="INFORMATIONS").grid() Label(fenetre_infos, text="INFORMATIONS").grid()
Label(fenetre_infos, text=" ").grid(sticky=W) Label(fenetre_infos, text=" ").grid(sticky=W)
Label(fenetre_infos, text="STRATEGIES :").grid(sticky=W) Label(fenetre_infos, text="STRATEGIES :").grid(sticky=W)
@ -548,9 +519,9 @@ def affichage_fenetre_infos():
def affichage_combobox(): def affichage_combobox():
""" """
S'il y a eu clic sur le bouton, S'il y a eu clic sur le bouton,
on affiche un combobox pour selectionner on affiche un combobox pour selectionner
la stratégie par défaut voulue la stratégie par défaut voulue
""" """
global Strat global Strat
Label(fenetre, text="Stratégie n°").grid(row=5, column=0, sticky=E) Label(fenetre, text="Stratégie n°").grid(row=5, column=0, sticky=E)
@ -558,9 +529,9 @@ def affichage_combobox():
def Interface(): def Interface():
""" """
Affiche l'interface graphique utilisateur Affiche l'interface graphique utilisateur
qui permet de saisir les paramètres de la qui permet de saisir les paramètres de la
simulation simulation
""" """
global X global X
@ -630,7 +601,6 @@ def init_complete():
global TailleGrilleY global TailleGrilleY
TailleGrilleX=X.get() TailleGrilleX=X.get()
TailleGrilleY=Y.get() TailleGrilleY=Y.get()
print(TailleGrilleX)
global TypeGrilleInitiale global TypeGrilleInitiale
TypeGrilleInitiale=Var_choix.get() TypeGrilleInitiale=Var_choix.get()
@ -682,35 +652,42 @@ def simulation():
def matRecup(i, param): def matRecup(i, param):
"""array*str-> array """
Récupère la grille avec seulement la valeur de la clef "stratégie" pour chaque joueur , à litération i voulue""" array*str-> array
#on initialise la matrice résultat avec que des 0 Récupère la grille avec seulement la valeur de la clef "stratégie" pour chaque joueur , à litération i voulue
"""
# on initialise la matrice résultat avec que des 0
matR = np.random.randint(0,1,(TailleGrilleX,TailleGrilleY)) matR = np.random.randint(0,1,(TailleGrilleX,TailleGrilleY))
#on récupère la grille à l'itération i voulue # on récupère la grille à l'itération i voulue
matrice = HistoriqueGrilles[i] matrice = HistoriqueGrilles[i]
#on parcourt toute la grille # on parcourt toute la grille
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] #on place à l'indice (ligne,colonne) de matR la valeur de la clef "stratégie" de la grille pour l'individu (ligne,colonne) # on place à l'indice (ligne,colonne) de matR la valeur de la clef "stratégie" de la grille pour l'individu (ligne,colonne)
matR[ligne][colonne] = matrice[ligne][colonne][param]
return matR return matR
def afficher_strat_dynamique(): def afficher_strat_dynamique():
"""Affichage dynamique de l'évolution de la stratégie dans une fenêtre, avec des couleurs""" """
fig=plt.figure() Affichage dynamique de l'évolution de la stratégie dans une fenêtre, avec des couleurs
"""
fig = plt.figure()
fig.suptitle('Animation des stratégies') fig.suptitle('Animation des stratégies')
cmap = mpl.colors.ListedColormap(["b","r" ,"black" ,"g" ,"purple", "yellow"]) cmap = mpl.colors.ListedColormap(["b","r" ,"black" ,"g" ,"purple", "yellow"])
bounds=[0,1,2,3,4,5,6] bounds = [0,1,2,3,4,5,6]
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, 6, 1) labels = np.arange(0, 6, 1)
cb.set_ticklabels(labels) cb.set_ticklabels(labels)
@ -724,17 +701,20 @@ def afficher_strat_dynamique():
def afficher_etat_dynamique(): def afficher_etat_dynamique():
"""Affichage dynamique de l'évolution des états des individus dans une fenêtre, avec des couleurs""" """
fig=plt.figure() Affichage dynamique de l'évolution des états des individus dans une fenêtre, avec des couleurs
"""
fig = plt.figure()
fig.suptitle('Animation des états') fig.suptitle('Animation des états')
cmap = mpl.colors.ListedColormap(["black","white"]) cmap = mpl.colors.ListedColormap(["black","white"])
bounds=[0,1,2] bounds = [0,1,2]
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)
@ -748,39 +728,38 @@ 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 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 """ 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()
#utilisateurs[strat][iter] = nombre d'utilisateur dune stratégie à une itération #utilisateurs[strat][iter] = nombre d'utilisateur d'une stratégie à une itération
#iteration
iteration=[] iteration=[]
#on ajoute des 0 dans les listes gain() et stratUtili() autant qu'il y a de stratégies
# on ajoute des 0 dans les listes gain() et stratUtili() autant qu'il y a de stratégies
for i in range(6): for i in range(6):
gain.append(0) gain.append(0)
stratUtili.append(0) stratUtili.append(0)
for i in range(0,len(ListeStrategies)): #on parcourt les stratégies for i in range(0,len(ListeStrategies)): # on parcourt les stratégies
stratUtili[i]=StratsResultats[i][0] #L'indice i de la liste stratUtili vaut le nombre total d'utilisations de la stratégie i stratUtili[i]=StratsResultats[i][0] # L'indice i de la liste stratUtili vaut le nombre total d'utilisations de la stratégie i
if StratsResultats[i][0]==0: #si la stratégie a été utilisée 0 fois if StratsResultats[i][0]==0: # si la stratégie a été utilisée 0 fois
gain[i] #le gain ne change pas pass # le gain ne change pas
else: else:
gain[i]=StratsResultats[i][1]/StratsResultats[i][0] #Sinon le gain pour la stratégie i vaut le nombre d'années de prison pour une stratégie divisée par son utilisation (pour avoir une moyenne) gain[i]=StratsResultats[i][1]/StratsResultats[i][0] #Sinon le gain pour la stratégie i vaut le nombre d'années de prison pour une stratégie divisée par son utilisation (pour avoir une moyenne)
utilisateurs.append([]) #on initialise une liste vide dans la liste utilisateurs afin de s'en servir juste après utilisateurs.append([]) # on initialise une liste vide dans la liste utilisateurs afin de s'en servir juste après
for i in range(0,MaxIterations+1): #on parcourt toutes les itréations for i in range(0,MaxIterations+1): # on parcourt toutes les itréations
for j in range(0,len(ListeStrategies)): #on parcourt toutes les stratégies for j in range(0,len(ListeStrategies)): # on parcourt toutes les stratégies
utilisateurs[j].append(StratsResultats[j][2][i][0]) #on ajoute à lindice j de la liste utilisateurs le nombre d'utilisateurs d'une stratégie donnée j à l'itération i utilisateurs[j].append(StratsResultats[j][2][i][0]) # on ajoute à lindice j de la liste utilisateurs le nombre d'utilisateurs d'une stratégie donnée j à l'itération i
iteration.append(i) #on ajoute à la liste itération l'indice i iteration.append(i) #on ajoute à la liste itération l'indice i
@ -814,27 +793,16 @@ def affichage_strats_resultats_totaux():
plt.show() plt.show()
plt.legend() plt.legend()
####################### #######################
# SCRIPT # SCRIPT
####################### #######################
Interface() if __name__ == '__main__':
init_complete() Interface()
simulation() init_complete()
afficher_etat_dynamique() simulation()
afficher_strat_dynamique() afficher_etat_dynamique()
affichage_strats_resultats_totaux() afficher_strat_dynamique()
affichage_strats_resultats_totaux()
"""
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]["strategie"]
return K
print(_ext(simulation()))
"""