From ff1fc23a61757d9e2396695c30043675822ab97b Mon Sep 17 00:00:00 2001 From: ConstancePoulain Date: Sat, 22 Apr 2017 18:44:45 +0200 Subject: [PATCH] Add files via upload --- ARE_FINISH.py | 850 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 850 insertions(+) create mode 100644 ARE_FINISH.py diff --git a/ARE_FINISH.py b/ARE_FINISH.py new file mode 100644 index 0000000..d0ac1c9 --- /dev/null +++ b/ARE_FINISH.py @@ -0,0 +1,850 @@ +# -*- 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) + + + +def fermeture_GUI(): + """ + """ + + +""" +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) + """ + #print("joueur " + str(joueur)) + print("len strategies = " +str(len(ListeStrategies))) + print('joueur[strategie]='+str(joueur['strategie'])) + print('adversaire[strategie]='+str(adversaire['strategie'])) + stratj = ListeStrategies[joueur['strategie']] + + strata = ListeStrategies[adversaire['strategie']] + + + etatj = stratj(joueur, adversaire) + etata = strata(adversaire, joueur) + #print('strat joueur ' + str(joueur['strategie'])) + + # 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]) + #print(Grille[0][0]['etat']) + +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 + print('nouvelle stratégie='+str(new_strat)) + # 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(0,5): + 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. + """ + #for i in range(len(ListePourcents)): + #print("pourcent i = " + str(ListePourcents[i])) + + + 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(ListeStrategies)): + list_nb_joueurs_de_chaque.append((TailleGrilleX*TailleGrilleY)*ListePourcents[i]) + + places_vides = TailleGrilleX*TailleGrilleY + for e in range(0,5): + count_joueurs = 0 + #print('Stratégie choisie ='+str(e)) + 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: + 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]} + #print('joueur en sortie'+str(matrice[i][j])) + 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] + +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 + +###################### +#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() +per0=DoubleVar() +per1=DoubleVar() +per2=DoubleVar() +per3=DoubleVar() +per4=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 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), 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) + Label(fenetre, text="Saisir le nombre d'itérations:").grid(row = 15, columnspan=1) + Entry(fenetre, textvariable=It, width=3).grid(row = 16) + + Button(fenetre, text="Infos", command=affichage_fenetre_infos).grid(row=7, column=1, sticky=W) + + 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=fermeture).grid(row=19, column=0) + + fenetre.mainloop() + + +def fermeture(): + """ + """ + global ListePourcents + + ListePourcents=[per0.get(), per1.get(), per2.get(), per3.get(), per4.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_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 + + 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 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"]) + + 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=Vitesse, 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(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[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())) +""" +