Update ARE-DYNAMIC.py
This commit is contained in:
Julian B
GitHub
parent
d1167883dd
commit
b5c92e527e
184
ARE-DYNAMIC.py
184
ARE-DYNAMIC.py
|
|
@ -31,7 +31,7 @@ from tkinter.ttk import *
|
|||
TailleGrilleX = 15
|
||||
TailleGrilleY = 15
|
||||
|
||||
# Grille
|
||||
# la grille
|
||||
Grille = np.ndarray((TailleGrilleX, TailleGrilleY))
|
||||
|
||||
# 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
|
||||
# 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]
|
||||
# représentant, à la fin de l'itération i, le nombre d'utilisateurs, le nombre d'utilisations
|
||||
# ainsi quel le nombre d'années de prisons qu'ils ont accumulés
|
||||
# attention, le nombre d'utilisateurs stockés est
|
||||
# utilisateur = nombre d'utilisateurs de la stratégie a la FIN de l'iteration i
|
||||
# utilisations = le nombre de fois que la fonction stratégie a été appelée au course de l'itération i
|
||||
# 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()
|
||||
|
||||
# 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()
|
||||
ListePourcents = list()
|
||||
|
||||
#Couleurs des Stratégies
|
||||
CouleursStrat=['b','r','black','g','purple','yellow']
|
||||
# couleurs des stratégies (pour l'affichage dynamique)
|
||||
CouleursStrat = ['b','r','black','g','purple','yellow']
|
||||
|
||||
# Vitesse de défilement des images dans l'affichage dynamique en millisecondes
|
||||
Vitesse = 1
|
||||
|
|
@ -85,28 +85,29 @@ def saisir_les_pourcentages():
|
|||
type 4, affiche 5 entry box pour
|
||||
saisir les pourcentages voulus
|
||||
"""
|
||||
|
||||
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)
|
||||
|
||||
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)
|
||||
|
||||
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)
|
||||
|
||||
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)
|
||||
|
||||
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)
|
||||
|
||||
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
|
||||
def gen_matrice_initiale():
|
||||
"""
|
||||
NoneType -> GrilleJoueurs
|
||||
"""
|
||||
fonction_gen = ListeGenGrille[TypeGrilleInitiale]
|
||||
|
||||
return fonction_gen()
|
||||
def gen_matrice_initiale():
|
||||
return (ListeGenGrille[TypeGrilleInitiale])()
|
||||
|
||||
##############################
|
||||
### Execution des tours / jeux
|
||||
|
||||
def partie1v1(joueur, adversaire):
|
||||
"""
|
||||
Joueur^2 -> int
|
||||
Joueur^2 -> int^2
|
||||
|
||||
Effectue une partie à deux joueurs
|
||||
Renvoie: paire (prison_joueur, prison_adversaire)
|
||||
|
|
@ -245,8 +242,6 @@ def matrice_init_vide():
|
|||
|
||||
def matrice_init_meme_strat():
|
||||
"""
|
||||
int -> array
|
||||
|
||||
Index: 0
|
||||
|
||||
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():
|
||||
"""
|
||||
int -> array
|
||||
|
||||
Index: 1
|
||||
|
||||
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():
|
||||
"""
|
||||
int -> array
|
||||
|
||||
Index: 2
|
||||
|
||||
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():
|
||||
"""
|
||||
Index: 3
|
||||
|
||||
Crée la matrice des joueurs tel que le probabilité d'apparition de chaque
|
||||
stratégie est équitable. Les états initiaux de chaque
|
||||
joueur sont aléatoires.
|
||||
|
||||
Index: 3
|
||||
"""
|
||||
|
||||
matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int)
|
||||
|
|
@ -358,8 +349,6 @@ def matrice_init_equitable():
|
|||
|
||||
def matrice_init_pourcents_choisis():
|
||||
"""
|
||||
list[float] -> array
|
||||
|
||||
Index: 4
|
||||
|
||||
ListePourcents contient des float de 0.0 à 1.0.
|
||||
|
|
@ -411,30 +400,21 @@ def matrice_init_pourcents_choisis():
|
|||
|
||||
def strat_toujours_nier(joueur, adversaire):
|
||||
"""
|
||||
Joueur^2 -> int
|
||||
|
||||
Index: 0
|
||||
|
||||
Toujours nier (coopération)
|
||||
"""
|
||||
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_altern(joueur, adversaire):
|
||||
"""
|
||||
Joueur^2 -> int
|
||||
|
||||
Index: 2
|
||||
|
||||
Le joueur alterne entre nier et avouer
|
||||
"""
|
||||
|
||||
|
|
@ -442,20 +422,14 @@ def strat_altern(joueur, adversaire):
|
|||
|
||||
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)
|
||||
"""
|
||||
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)
|
||||
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):
|
||||
"""
|
||||
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)
|
||||
"""
|
||||
|
|
@ -495,26 +468,24 @@ def strat_meilleur_gain (joueur, adversaire):
|
|||
######################
|
||||
#INTERFACE GRAPHIQUE UTILISATEUR (GUI)
|
||||
######################
|
||||
# Fonctions pour command
|
||||
######################
|
||||
|
||||
|
||||
# Initialise la fenetre principale
|
||||
fenetre=Tk()
|
||||
fenetre = Tk()
|
||||
# Taille en abscisse de la matrice
|
||||
X=IntVar(fenetre)
|
||||
X = IntVar(fenetre)
|
||||
|
||||
# Taille en ordonnée de la matrice
|
||||
Y=IntVar(fenetre)
|
||||
Y = IntVar(fenetre)
|
||||
|
||||
# Strategie definie pour le type 1
|
||||
Strat=IntVar(fenetre)
|
||||
Strat = IntVar(fenetre)
|
||||
|
||||
# Type de matrice selectionné par l'user
|
||||
Var_choix=IntVar(fenetre)
|
||||
Var_choix = IntVar(fenetre)
|
||||
|
||||
# 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
|
||||
Vit = IntVar()
|
||||
|
|
@ -524,7 +495,7 @@ def affichage_fenetre_infos():
|
|||
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.
|
||||
"""
|
||||
fenetre_infos=Tk()
|
||||
fenetre_infos = Tk()
|
||||
Label(fenetre_infos, text="INFORMATIONS").grid()
|
||||
Label(fenetre_infos, text=" ").grid(sticky=W)
|
||||
Label(fenetre_infos, text="STRATEGIES :").grid(sticky=W)
|
||||
|
|
@ -630,7 +601,6 @@ def init_complete():
|
|||
global TailleGrilleY
|
||||
TailleGrilleX=X.get()
|
||||
TailleGrilleY=Y.get()
|
||||
print(TailleGrilleX)
|
||||
|
||||
global TypeGrilleInitiale
|
||||
TypeGrilleInitiale=Var_choix.get()
|
||||
|
|
@ -682,35 +652,42 @@ def simulation():
|
|||
|
||||
|
||||
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"""
|
||||
#on initialise la matrice résultat avec que des 0
|
||||
"""
|
||||
array*str-> array
|
||||
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))
|
||||
|
||||
|
||||
#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]
|
||||
|
||||
#on parcourt toute la grille
|
||||
# on parcourt toute la grille
|
||||
for ligne in range (0,TailleGrilleX): #int ligne
|
||||
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
|
||||
|
||||
|
||||
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')
|
||||
|
||||
cmap = mpl.colors.ListedColormap(["b","r" ,"black" ,"g" ,"purple", "yellow"])
|
||||
|
||||
bounds=[0,1,2,3,4,5,6]
|
||||
norm=mpl.colors.BoundaryNorm(bounds, cmap.N)
|
||||
img=plt.imshow(matRecup(0, 'strategie'), interpolation = "nearest", cmap = cmap , norm = norm)
|
||||
bounds = [0,1,2,3,4,5,6]
|
||||
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, 6, 1)
|
||||
cb.set_ticklabels(labels)
|
||||
|
||||
|
|
@ -724,17 +701,20 @@ def afficher_strat_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')
|
||||
|
||||
cmap = mpl.colors.ListedColormap(["black","white"])
|
||||
|
||||
bounds=[0,1,2]
|
||||
norm=mpl.colors.BoundaryNorm(bounds, cmap.N)
|
||||
img=plt.imshow(matRecup(0, 'etat'), interpolation = "nearest", cmap = cmap , norm = norm)
|
||||
bounds = [0,1,2]
|
||||
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)
|
||||
|
||||
|
|
@ -748,39 +728,38 @@ def afficher_etat_dynamique():
|
|||
|
||||
|
||||
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 """
|
||||
de prison en fonction de la stratégie et le nombre d'utilisation de chaque stratégies
|
||||
"""
|
||||
|
||||
#initialisation des paramètres
|
||||
#list gain
|
||||
# initialisation des paramètres
|
||||
gain=[]
|
||||
#list strat
|
||||
stratUtili=[]
|
||||
|
||||
#nb_utilisations
|
||||
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=[]
|
||||
#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):
|
||||
gain.append(0)
|
||||
stratUtili.append(0)
|
||||
|
||||
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
|
||||
if StratsResultats[i][0]==0: #si la stratégie a été utilisée 0 fois
|
||||
gain[i] #le gain ne change pas
|
||||
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
|
||||
if StratsResultats[i][0]==0: # si la stratégie a été utilisée 0 fois
|
||||
pass # le gain ne change pas
|
||||
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)
|
||||
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 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
|
||||
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
|
||||
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
|
||||
|
||||
|
|
@ -814,27 +793,16 @@ def affichage_strats_resultats_totaux():
|
|||
|
||||
plt.show()
|
||||
plt.legend()
|
||||
|
||||
#######################
|
||||
# SCRIPT
|
||||
#######################
|
||||
|
||||
Interface()
|
||||
init_complete()
|
||||
simulation()
|
||||
afficher_etat_dynamique()
|
||||
afficher_strat_dynamique()
|
||||
affichage_strats_resultats_totaux()
|
||||
if __name__ == '__main__':
|
||||
Interface()
|
||||
init_complete()
|
||||
simulation()
|
||||
afficher_etat_dynamique()
|
||||
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()))
|
||||
"""
|
||||
|
|
|
|||
Loading…
Reference in New Issue