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

840 lines
29 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
# la 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]
# 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)
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 (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
# On initialise la seed pour les futurs random.
random.seed()
# 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)
Entry(fenetre, textvariable=per0, width=3).grid(row=9, column=1)
Label(fenetre, text ="% stratégie1:").grid(row=10, column=0)
Entry(fenetre, textvariable=per1, width=3).grid(row=10, column=1)
Label(fenetre, text ="% stratégie2:").grid(row=11, column=0)
Entry(fenetre, textvariable=per2, width=3).grid(row=11, column=1)
Label(fenetre, text ="% stratégie3:").grid(row=12, column=0)
Entry(fenetre, textvariable=per3, width=3).grid(row=12, column=1)
Label(fenetre, text ="% stratégie4:").grid(row=13, column=0)
Entry(fenetre, textvariable=per4, width=3).grid(row=13, column=1)
Label(fenetre, text ="% stratégie5:").grid(row=14, column=0)
Entry(fenetre, textvariable=per5, width=3).grid(row=14, column=1)
#####################################
# 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():
return (ListeGenGrille[TypeGrilleInitiale])()
##############################
### Execution des tours / jeux
def partie1v1(joueur, adversaire):
"""
Joueur^2 -> int^2
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[1]
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():
"""
Index: 3
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():
"""
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():
"""
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():
"""
Index: 0
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.
"""
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():
"""
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(0, 6):
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] == -1:
while matrice_strat[i][j] == -1:
strat_aleatoire = random.randint(0, len(ListePourcents))
if ListePourcents[strat_aleatoire] != 0.0:
matrice_strat[i][j] = strat_aleatoire
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):
"""
Index: 0
Toujours nier (coopération)
"""
return 0 # 0 : coop
def strat_toujours_avouer(joueur, adversaire):
"""
Index: 1
Toujours avouer (trahir)
"""
return 1 #1 : traître
def strat_altern(joueur, adversaire):
"""
Obsolète.
Le joueur alterne entre nier et avouer
"""
return 1 - joueur['etat']
def strat_precedent_adversaire(joueur, adversaire):
"""
Index: 3
Fait ce que l'adversaire a fait a son dernier tour
"""
return adversaire['historique_etats'][len(adversaire['historique_etats'])-1]
def strat_principal_adversaire(joueur, adversaire):
"""
Index: 3
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):
"""
Obsolète.
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
def strat_tit_for_tat(joueur, adversaire):
"""
coopérer tant que l'autre joueur est coopératif, à la première trahison
reproduire à chaque fois le comportement de l'adversaire du coup précédent
"""
for i in adversaire['historique_etats']:
if i == 1:
return adversaire['historique_etats'][len(adversaire['historique_etats'])-1]
return 0
def strat_tit_for_tat_sorry(joueur, adversaire):
"""
coopérer tant que l'autre joueur est coopératif, à la première trahison
reproduire à chaque fois le comportement de l'adversaire du coup précédent,
avec en plus une proba de 5% de coopérer après une défection : un peu d'espoir !
"""
for i in adversaire['historique_etats']:
if i == 1:
tirage = random.random()
if tirage <= 0.05:
return 0
return adversaire['historique_etats'][len(adversaire['historique_etats'])-1]
return 0
######################
#INTERFACE GRAPHIQUE UTILISATEUR (GUI)
######################
# 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()
# Variables des pourcentages
per0=DoubleVar()
per1=DoubleVar()
per2=DoubleVar()
per3=DoubleVar()
per4=DoubleVar()
per5=DoubleVar()
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 2 : Fait l'inverse de ce que l'adversaire a fait a son dernier tour.").grid(sticky=W)
Label(fenetre_infos, text="Stratégie 3 : 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 : La répartition des stratégies est équitable, les états de départs 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 : Même stratégie pour tout le monde, les états 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).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, command=affichage_combobox).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 en ms:").grid(row=17)
Entry(fenetre, textvariable=Vit, width=3).grid(row=18)
Button(fenetre, text="Continuer", command=fermeture).grid(row=19, column=0)
fenetre.mainloop()
def fermeture():
"""
"""
global ListePourcents
ListePourcents=[per0.get(), per1.get(), per2.get(), per3.get(), per4.get(), per5.get()]
fenetre.quit()
###############################################################################
##############
### 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_equitable) # 0
ListeGenGrille.append(matrice_init_avoue_sauf_un) # 1
ListeGenGrille.append(matrice_init_nie_sauf_un) # 2
ListeGenGrille.append(matrice_init_meme_strat) # 3
ListeGenGrille.append(matrice_init_pourcents_choisis) # 4
ListeStrategies.append(strat_toujours_nier) # 0
ListeStrategies.append(strat_toujours_avouer) # 1
ListeStrategies.append(strat_precedent_adversaire) # 2
ListeStrategies.append(strat_principal_adversaire) # 3
ListeStrategies.append(strat_tit_for_tat) # 4
ListeStrategies.append(strat_tit_for_tat_sorry) # 5
global Grille
global StratsResultats
global Vitesse
Vitesse = Vit.get()
global TailleGrilleX
global TailleGrilleY
TailleGrilleX=X.get()
TailleGrilleY=Y.get()
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 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
matrice = HistoriqueGrilles[i]
# on parcourt toute la grille
for ligne in range (0,TailleGrilleX): #int ligne
for colonne in range (0, TailleGrilleY): #int 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()
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)
cb = plt.colorbar(img , cmap=cmap , norm=norm , boundaries = bounds , ticks=bounds)
labels = np.arange(0, 6, 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=Vitesse, repeat = False)
plt.show(block = True)
def afficher_etat_dynamique():
"""
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)
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=Vitesse, repeat = False)
plt.show(block = True)
def affichage_strats_resultats_totaux():
"""
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
gain=[]
stratUtili=[]
#nb_utilisations
utilisateurs=list()
#utilisateurs[strat][iter] = nombre d'utilisateur d'une stratégie à une itération
iteration=[]
# on ajoute des 0 dans les listes gain() et stratUtili() autant qu'il y a de stratégies
for i in range(0,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
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
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
Strat=('0','1', '2','3','4','5')
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()
Reference in New Issue View Git Blame Copy Permalink