julian
/
ARE_Dynamic_2017
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ARE_Dynamic_2017/ARE-DYNAMIC.py

839 lines
27 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# -*- coding:utf-8 -*-
############################
### ARE-DYNAMIC.py
###
### Auteurs:
### Julian Barathieu (3670170)
### Lucie Hoffmann (3671067)
### Nicolas Boussenina (3670515)
### Constance Poulain (3671006)
###
### Projet: Théorie des Jeux, Dilemne du Prisonier
### ARE-DYNAMIC 2016-2017 UPMC MIPI
###
######################
### Importations
import copy
import random
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from tkinter import *
from tkinter.ttk import *
######################
### Variables Globales
# taille de la grille
TailleGrilleX = 15
TailleGrilleY = 15
# Grille
Grille = np.ndarray((TailleGrilleX, TailleGrilleY))
# historique des grilles aux itérations précédentes
# utilisé durant l'affichage dynamique
HistoriqueGrilles = list()
# chaque StratsResultats[i] est un triplet [nb_utilisations, total_ans_prisons, utilisation_detail] avec:
# i = index de la stratégie en question
# 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
StratsResultats = list()
# liste des stratégies (fonctions Joueur^2 -> {0, 1} décidant si un joueur nie ou non en fonction de son adversaire)
ListeStrategies = list()
# liste des fonctions génératrices de grille
ListeGenGrille = list()
# génératrice de grille à utiliser
TypeGrilleInitiale = 3
# itération actuelle
Iteration = 0
# nombre max d'itérations
MaxIterations = 4
# stratégie par défaut
StratParDefaut = 0
# affichage dynamique
AffichageDynamique = True
# nécessaire pour matrice_init_pourcents_choisis()
ListePourcents = list()
#Couleurs des Stratégies
CouleursStrat=['b','r','black','g','purple']
# Vitesse de défilement des images dans l'affichage dynamique en millisecondes
Vitesse = 1
# Fonction pour le GUI
def saisir_les_pourcentages():
"""
S'il y a eu clic sur le bouton du
type 4, affiche 5 entry box pour
saisir les pourcentages voulus
"""
Label(fenetre, text="% stratégie0:").grid(row=9, column =0)
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()
Entry(fenetre, textvariable=per1, width=3).grid(row=10, column=1)
Label(fenetre, text ="% stratégie2:").grid(row=11, column=0)
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()
Entry(fenetre, textvariable=per3, width=3).grid(row=12, column=1)
Label(fenetre, text ="% stratégie4:").grid(row=13, column=0)
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()]
"""
Types:
Coord = tuple(x, y)
Joueur = dict("x", "y", "etat", "historique_etats", "strategie", "annees_de_prison", "historique_strategies")
GrilleJoueurs = matrice2d(Joueur)
"""
#####################################
### Génération de la matrice initiale
def gen_matrice_initiale():
"""
NoneType -> GrilleJoueurs
"""
fonction_gen = ListeGenGrille[TypeGrilleInitiale]
return fonction_gen()
##############################
### Execution des tours / jeux
def partie1v1(joueur, adversaire):
"""
Joueur^2 -> int
Effectue une partie à deux joueurs
Renvoie: paire (prison_joueur, prison_adversaire)
"""
stratj = ListeStrategies[joueur["strategie"]]
strata = ListeStrategies[adversaire["strategie"]]
etatj = stratj(joueur, adversaire)
etata = strata(adversaire, joueur)
# 1 = avouer
# 0 = nier
if etatj == 0:
if etata == 0:
# nie-nie
ans_prison = (2, 2)
else:
# nie-avoue
ans_prison = (10, 0)
else:
if etata == 0:
# avoue-nie
ans_prison = (0, 10)
else:
# avoue-avoue
ans_prison = (5, 5)
StratsResultats[joueur["strategie"]][0] += 1
StratsResultats[joueur["strategie"]][1] += ans_prison[0]
StratsResultats[adversaire["strategie"]][0] += 1
StratsResultats[adversaire["strategie"]][1] += ans_prison[1]
StratsResultats[joueur["strategie"]][2][Iteration][1] += 1
StratsResultats[joueur["strategie"]][2][Iteration][2] += ans_prison[0]
StratsResultats[adversaire["strategie"]][2][Iteration][1] += 1
StratsResultats[adversaire["strategie"]][2][Iteration][2] += ans_prison[0]
joueur["historique_etats"].append(etatj)
adversaire["historique_etats"].append(etata)
joueur["historique_strategies"].append(stratj)
adversaire["historique_strategies"].append(strata)
joueur["etat"] = etatj
adversaire["etat"] = etata
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):
for j in range (-1,2): #(i,j) sont les coordonnées de l'adversaire
if (0 <= x+i and x+i < TailleGrilleX) and (0 <= y+j and y+j < TailleGrilleY) and i != 0 and j != 0:
partie1v1(Grille[x][y], Grille[x+i][y+j])
def partie_globale():
"""
Effectue une partie de huit par joueur
"""
global Grille
for i in range(TailleGrilleX):
for j in range(TailleGrilleY):
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)
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
min_prison = copie_grille[x][y]["annees_de_prison"]
new_strat = copie_grille[x][y]["strategie"]
for i in range (-1,2):
for j in range (-1,2): #(x+i,y+j) : adversaires autour de (x,y)
if (0 <= x+i and x+i < TailleGrilleX) and (0 <= y+j and y+j < TailleGrilleY) and i != 0 and j != 0:
if min_prison > copie_grille[x+i][y+j]["annees_de_prison"]:
new_strat = copie_grille[x+i][y+j]["strategie"]
Grille[x][y]["strategie"] = new_strat # on modifie la stratégie du joueur dans la Grille et pas dans la copie
# Réinitialisation du nb d'années de prison
for i in range(TailleGrilleX):
for j in range(TailleGrilleY):
Grille[i][j]['annees_de_prison'] = 0
return Grille
#####################################
### Fonction génératrices de matrices
def matrice_init_vide():
"""
Crée une matrice contenant des dicts vides {}
"""
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
mais commence avec des états différents, générés aléatoirement
"""
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] = {'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
nie, sauf un qui avoue. Chaque joueur à la même
stratégie
"""
histo_strat = [StratParDefaut]
matrice = matrice_init_vide()
for i in range(TailleGrilleY):
for j in range(TailleGrilleX):
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)
index_aleatoirey = random.randint(0,TailleGrilleY-1)
(matrice[index_aleatoirex][index_aleatoirey])['etat'] = 0
return matrice
def matrice_init_avoue_sauf_un():
"""
int -> array
Index: 2
Créer la matrice des joueurs tel que chaque joueur avoue,
sauf un qui nie. Tous les joueurs ont la même strategie
"""
histo_strat = [StratParDefaut]
matrice = matrice_init_vide()
for i in range(TailleGrilleY):
for j in range(TailleGrilleX):
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)
index_aleatoirey = random.randint(0,TailleGrilleY-1)
(matrice[index_aleatoirex][index_aleatoirey])['etat'] = 1
return matrice
def matrice_init_equitable():
"""
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)
nb_de_joueurs_de_chaque = int((TailleGrilleX*TailleGrilleY)/len(ListeStrategies))
places_vides = TailleGrilleX*TailleGrilleY
for e in range(len(ListeStrategies)):
count_joueurs = 0
while count_joueurs <= nb_de_joueurs_de_chaque:
index_aleatoirex = random.randint(0,TailleGrilleX-1)
index_aleatoirey = random.randint(0,TailleGrilleY-1)
if matrice_strat[index_aleatoirex][index_aleatoirey] != -1:
if places_vides < 1:
break
continue
matrice_strat[index_aleatoirex][index_aleatoirey] = e
count_joueurs += 1
places_vides -= 1
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))
matrice = matrice_init_vide()
for i in range(TailleGrilleY):
for j in range(TailleGrilleX):
etat = random.randint(0, 1)
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.
Crée la matrice des joueurs tel que le pourcentage de
chaque stratégie est choisi. Les états initiaux sont
choisis aléatoirement.
"""
if (len(ListePourcents) != len(ListeStrategies)):
print("Erreur: matrice_init_pourcents_choisis: liste_pourcent est de taille incorrecte!")
matrice_strat = np.full((TailleGrilleX, TailleGrilleY), -1, dtype=int)
list_nb_joueurs_de_chaque = list()
for i in range(len(ListePourcents)):
list_nb_joueurs_de_chaque.append((TailleGrilleX*TailleGrilleY)*ListePourcents[i])
places_vides = TailleGrilleX*TailleGrilleY
for e in range(len(ListePourcents)):
count_joueurs = 0
while count_joueurs <= list_nb_joueurs_de_chaque[e]:
index_aleatoirex = random.randint(0,TailleGrilleX-1)
index_aleatoirey = random.randint(0,TailleGrilleY-1)
if matrice_strat[index_aleatoirex][index_aleatoirey] != -1:
if places_vides < 1:
break
continue
matrice_strat[index_aleatoirex][index_aleatoirey] = e
count_joueurs += 1
places_vides -= 1
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] == 0:
matrice_strat[i][j] = random.randint(0, len(ListePourcents))
matrice = matrice_init_vide()
for i in range(TailleGrilleY):
for j in range(TailleGrilleX):
etat = random.randint(0, 1)
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
#######################
### Fonction stratégies
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
"""
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)
"""
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)
"""
s = 0 # somme des entiers représentant les états
for i in adversaire['historique_etats']:
s += i
if len(adversaire['historique_etats']) == 0:
return 0
elif (s/len(adversaire['historique_etats'])) > 0.5:
return 1
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']
for i in range (-1,2):
for j in range (-1,2): #(i,j) sont les coordonnées de l'adversaire
x = joueur['x']
y = joueur['y']
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
######################
#INTERFACE GRAPHIQUE UTILISATEUR (GUI)
######################
# Fonctions pour command
######################
# Initialise la fenetre principale
fenetre=Tk()
# Taille en abscisse de la matrice
X=IntVar(fenetre)
# Taille en ordonnée de la matrice
Y=IntVar(fenetre)
# Strategie definie pour le type 1
Strat=IntVar(fenetre)
# Type de matrice selectionné par l'user
Var_choix=IntVar(fenetre)
# Nombre d'itérations maximum
It=IntVar(fenetre)
# Vitesse de défilement des images dans l'affichage dynamique en millisecondes, pré-variable IntVar
Vit = IntVar()
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()
Label(fenetre_infos, text="INFORMATIONS").grid()
Label(fenetre_infos, text=" ").grid(sticky=W)
Label(fenetre_infos, text="STRATEGIES :").grid(sticky=W)
Label(fenetre_infos, text="Stratégie 0 : Toujours nier.").grid(sticky=W)
Label(fenetre_infos, text="Stratégie 1 : Toujours avouer.").grid(sticky=W)
Label(fenetre_infos, text="Stratégie 2 : Alterner entre avouer et nier.").grid(sticky=W)
Label(fenetre_infos, text="Stratégie 3 : Choisis l'état de son adversaire précédent.").grid(sticky=W)
Label(fenetre_infos, text="Stratégie 4 : Choisis l'état que son adversaire a majoritairement choisi avant.").grid(sticky=W)
Label(fenetre_infos, text="Stratégie 5 : Choisis l'état de son voisin ayant obtenu le meilleur gain.").grid(sticky=W)
Label(fenetre_infos, text=" ").grid(sticky=W)
Label(fenetre_infos, text="GRILLES DE DEPART :").grid(sticky=W)
Label(fenetre_infos, text="Type 0 : Même stratégie pour tout le monde, les états sont aléatoires.").grid(sticky=W)
Label(fenetre_infos, text="Type 1 : Tous les joueurs nient sauf un qui avoue, même stratégie pour tous.").grid(sticky=W)
Label(fenetre_infos, text="Type 2 : Tous les joueurs avouent sauf un qui nie, même stratégie pour tous.").grid(sticky=W)
Label(fenetre_infos, text="Type 3 : La répartition des stratégies est équitable, les états de départs sont aléatoires.").grid(sticky=W)
Label(fenetre_infos, text="Type 4 : Les pourcentages de chaque stratégie sont choisis, les états de départ sont aléatoires.").grid(sticky=W)
fenetre_infos.mainloop()
def affichage_combobox():
"""
S'il y a eu clic sur le bouton,
on affiche un combobox pour selectionner
la stratégie par défaut voulue
"""
global Strat
Label(fenetre, text="Stratégie n°").grid(row=5, column=0, sticky=E)
Combobox(fenetre, textvariable=Strat, values=(0, 1, 2, 3, 4, 5), width=3).grid(row=5, column=1, sticky=W)
def Interface():
"""
Affiche l'interface graphique utilisateur
qui permet de saisir les paramètres de la
simulation
"""
global X
global Y
global Var_choix
global Vit
Label(fenetre, text = "Paramétrage des variables").grid(row = 0, columnspan = 2)
Label(fenetre, text = "Saisir la taille de la matrice souhaitée:").grid(row=1, columnspan = 2)
Label(fenetre, text = "X =").grid(row = 2, column = 0, sticky=E)
Entry(fenetre, textvariable = X, width = 3).grid(row = 2, column = 1, sticky = W)
Label(fenetre, text = "Y =").grid(row=3, sticky = E, column=0)
Entry(fenetre, textvariable=Y, width=3).grid(row=3, column=1, sticky = W)
Label(fenetre, text="Choisir le type de la matrice initiale:").grid(row=4, columnspan = 2)
Radiobutton(fenetre, text="Type 0", variable=Var_choix, value=0, command=affichage_combobox).grid(row=5, sticky=W)
Radiobutton(fenetre, text="Type 1", variable=Var_choix, value=1, command=affichage_combobox).grid(row=6, sticky=W)
Radiobutton(fenetre, text="Type 2", variable=Var_choix, value=2, command=affichage_combobox).grid(row=7, sticky=W)
Radiobutton(fenetre, text="Type 3", variable=Var_choix, value=3).grid(row=8, sticky=W)
Radiobutton(fenetre, text="Type 4", variable=Var_choix, value=4, command=saisir_les_pourcentages).grid(row=9, sticky=W)
Button(fenetre, text="Infos", command=affichage_fenetre_infos).grid(row=7, column=1, sticky=W)
Label(fenetre, text="Saisir le nombre d'itérations:").grid(row = 15, columnspan=1)
Entry(fenetre, textvariable=It, width=3).grid(row = 16)
Label(fenetre, text="Saisir la vitesse de défilement des images:").grid(row=17)
Entry(fenetre, textvariable=Vit, width=3).grid(row=18)
Button(fenetre, text="Continuer", command=fenetre.quit).grid(row=19, column=0)
fenetre.mainloop()
###############################################################################
##############
### Simulation
def init_complete():
"""
Rajoute à ListeStrategies toutes les fonctions stratégies
Rajoute à ListeGenGrille toutes les fonctions de génération de grille
"""
ListeGenGrille.append(matrice_init_meme_strat) # 0
ListeGenGrille.append(matrice_init_nie_sauf_un) # 1
ListeGenGrille.append(matrice_init_avoue_sauf_un) # 2
ListeGenGrille.append(matrice_init_equitable) # 3
ListeGenGrille.append(matrice_init_pourcents_choisis) # 4
ListeStrategies.append(strat_toujours_nier) # 0
ListeStrategies.append(strat_toujours_avouer) # 1
ListeStrategies.append(strat_altern) # 2
ListeStrategies.append(strat_precedent_adversaire) # 3
ListeStrategies.append(strat_principal_adversaire) # 4
ListeStrategies.append(strat_meilleur_gain) # 5
global Grille
global StratsResultats
global Vitesse
Vitesse = Vit.get()
global TailleGrilleX
global TailleGrilleY
TailleGrilleX=X.get()
TailleGrilleY=Y.get()
print(TailleGrilleX)
global TypeGrilleInitiale
TypeGrilleInitiale=Var_choix.get()
global StratParDefaut
StratParDefaut=Strat.get()
global MaxIterations
MaxIterations=It.get()
Grille = gen_matrice_initiale()
for i in range(len(ListeStrategies)):
StratsResultats.append([0, 0, [ [0, 0, 0] ]])
for x in range(TailleGrilleX):
for y in range(TailleGrilleY):
if Grille[x][y]["strategie"] == i:
StratsResultats[i][2][0][0] += 1
return Grille
def simulation():
global Iteration
global HistoriqueGrilles
Iteration = 0
while Iteration <= MaxIterations:
HistoriqueGrilles.append(copy.deepcopy(Grille))
Iteration += 1
for i in range(len(StratsResultats)):
StratsResultats[i][2].append([0, 0, 0])
partie_globale()
for i in range(len(StratsResultats)):
for x in range(TailleGrilleX):
for y in range(TailleGrilleY):
if Grille[x][y]["strategie"] == i:
StratsResultats[i][2][Iteration][0] += 1
return Grille
###############################################################################
### Affichage dynamique et graphiques
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"""
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]
return matR
def afficher_strat_dynamique():
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]
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)
labels = np.arange(0, 5, 1)
cb.set_ticklabels(labels)
def update(next_iteration,*args):
img.set_array(matRecup(next_iteration , 'strategie'))
return [img]
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')
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)
cb=plt.colorbar(img , cmap=cmap , norm=norm , boundaries = bounds , ticks=bounds)
labels = np.arange(0, 2, 1)
cb.set_ticklabels(labels)
def update(next_iteration,*args):
img.set_array(matRecup(next_iteration , 'etat'))
return [img]
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
#iteration
iteration=[]
for i in range(6):
gain.append(0)
stratUtili.append(0)
for i in range(0,len(ListeStrategies)):
stratUtili[i]=StratsResultats[i][0]
if StratsResultats[i][0]==0:
gain[i]
else:
gain[i]=StratsResultats[i][1]/StratsResultats[i][0]
utilisateurs.append([])
for i in range(0,MaxIterations+1):
for j in range(0,len(ListeStrategies)):
utilisateurs[j].append(StratsResultats[j][2][i][0])
iteration.append(i)
Strat=('0','1', '2','3' ,'4')
x_pos = np.arange(len(Strat))
plt.subplot(221)
plt.title("Nombre d'adoptions de chaque stratégie")
plt.bar(x_pos, stratUtili, align='center' , color=CouleursStrat)
plt.xlabel("Stratégies")
plt.ylabel("Nombre individus ayant adopté stratégie")
plt.xticks(x_pos,Strat)
plt.subplot(222)
plt.title("Nombre moyen d'années de prison de chaque stratégie")
plt.bar(x_pos, gain, align='center', color=CouleursStrat )
plt.xlabel("Stratégies")
plt.ylabel("Nombre moyen d'années de prison ")
plt.xticks(x_pos,Strat)
plt.subplot(223)
plt.title("Evolution du nombre d'utilisateurs de chaque stratégie au cours des itérations")
plt.xlabel('Iterations')
plt.ylabel("Nombre utilisateurs")
for i in range(len(ListeStrategies)):
plt.plot(iteration,utilisateurs[i], CouleursStrat[i] ,linewidth=5 ,label="Stratégie" + str(i))
plt.show()
plt.legend()
#######################
# SCRIPT
#######################
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()))
"""
Reference in New Issue View Git Blame Copy Permalink