Esempio n. 1
0
 def __init__(self, size, step, name):
     pygame.init()
     pygame.display.set_caption(name)
     screen = pygame.display.set_mode((size, size))
     screen.fill((235, 235, 235))
     gril = grille.Grille(size, step)
     gril.createTab("0")
     self.use = balle.Balle(screen, gril, 3, 2, int(step / 2))
     gril.draw(pygame, screen)
Esempio n. 2
0
def resolution_nbr_cases(nbLignes = default_nbLignes,
                         nbCol = default_nbCol,
                         p = default_p,
                         gamma = default_gamma,
                         epsilon = default_epsilon):
    size = nbLignes * nbCol
    couts = [0, 1, size ** 1, size ** 2, size ** 3]
    reward = 1000
    grid = grille.Grille(nbLignes,nbCol,2,0.2,0.2,0.2,0.2,0.2,couts,reward)
    d,v,t,time = p2.iteration_de_la_valeur(grid.g,p,gamma,epsilon)
    print(ot.from_action_to_dir(d,grid.g))
Esempio n. 3
0
    def __init__(self, taille, saison):
        """

        :param taille: taille de la grille
        :type taille: tuple
        :param saison: saison
        :type saison:string
        :return:
        """
        self.taille = taille
        self.saison = saison
        self.grille = g.Grille(self.taille, self.saison)
        self.grille.remplir_case()
Esempio n. 4
0
 def __init__(self, size, step, name):
     pygame.init()
     pygame.display.set_caption(name)
     screen = pygame.display.set_mode((size, size))
     screen.fill((235, 235, 235))
     gril = grille.Grille(size, step)
     gril.createTab("0")  # cré une table rempli de 0
     self.finish = arrive.Arrive(screen, gril, 2,
                                 2)  # instancie une arrivé en position 2,2
     self.use = balle.Balle(
         screen, gril, 3, 2, int(step / 2)
     )  # instancie une balle en position 3,2 avec un rayon qui vaut la moitié de la taille d'une case
     gril.draw(pygame, screen)
Esempio n. 5
0
def impact_q(variation_q,
             nbLignes = default_nbLignes,
             nbCol = default_nbCol,
             p = default_p,
             gamma = default_gamma,
             epsilon = default_epsilon):
    couts = [0,1,2,3,4]
    for q in variation_q:
        random.seed(1)
        np.random.seed(1)
        print(q)
        new_couts = [x**q for x in couts]
        g = grille.Grille(nbLignes,nbCol,2,0.2,0.2,0.2,0.2,0.2,new_couts,1000).g
        d,v,t,time = p2.iteration_de_la_valeur(g,p,gamma,epsilon)
        print(ot.from_action_to_dir(d,g))
Esempio n. 6
0
def main():
    
    pygame.init()
    size=[dim,dim]
    
    screen=pygame.display.set_mode(size)
    g=grille.Grille()
    
    while 1:
        event = pygame.event.poll()  
        if event.type == pygame.QUIT: break 
        
        g.deplacements()
        affichage(screen,g)
        
    pygame.quit()
Esempio n. 7
0
def fond(screen,g):
    
    
    #on récupère les coordonnées des obstacles,portes,des voyageurs(mobiles)
    #Grille.getVoyageurs.keys (on récupère les tuples)
    #Grille.getObstacles.keys  (on récupère les bstacles)
    g = grille.Grille()
    
    #on récupère les coordonnées des obstacles
    OBSTACLES=g.getObstacles()
    
    #on récupère les coordonnées des portes
    PORTES=g.getPortes()
    
    
    dessiner_grille(screen)
    
    
    case = pygame.Surface((taille,taille)) # une surface grise
 
            
            
    #on place les obstacles
    
    for obstacle in OBSTACLES:
        
        obst=OBSTACLES[obstacle]
        case.fill(obst.couleur)
        screen.blit(case,obstacle)
    #on place les portes
    
    for porte in PORTES:
        
        p=PORTES[porte]
        case.fill(p.couleur)   
        screen.blit(case,porte) 
    
        
        
            
    pygame.display.flip()
Esempio n. 8
0
def resolution_nbr_cases(nbLignes=default_nbLignes,
                         nbCol=default_nbCol,
                         p=default_p,
                         gamma=default_gamma,
                         epsilon=default_epsilon):
    size = nbLignes * nbCol
    couts = [0, 1, size**1, size**2, size**3]
    reward = 1000
    grid = grille.Grille(nbLignes, nbCol, 2, 0.2, 0.2, 0.2, 0.2, 0.2, couts,
                         reward)
    d, v, t, time = algos.iteration_de_la_valeur(grid.g, p, gamma, epsilon)
    print(ot.from_action_to_dir(d, grid.g))

    #affichage dans la GUI
    grid.resultat.config(state=tk.NORMAL)
    grid.resultat.delete(1.0, tk.END)
    grid.resultat.insert(tk.INSERT, ot.from_action_to_dir(d, grid.g))
    grid.resultat.insert(tk.INSERT, '\nnumber of iteration :' + str(t))
    grid.resultat.insert(tk.INSERT, '\ntime :' + str(time))
    grid.resultat.config(state=tk.DISABLED)
    grid.Mafenetre.mainloop()


# resolution_nbr_cases()
Esempio n. 9
0
def impact_size(sizes,
                nbr_tests = default_tests,
                p = default_p,
                gamma = default_gamma,
                epsilon = default_epsilon):
    df = pd.DataFrame(columns = ["dimensions",
                                 "taille",
                                 "iter_val",
                                 "iter_pol",
                                 #"iter_pl",
                                 "time_val",
                                 "time_pol",
                                 #"time_pl",
                                 ])
    for i, taille in enumerate(sizes) : 
        print(taille)
        somme1_it = 0
        somme1_t = 0
        somme2_it =0 
        somme2_t =0
       # TODO : à decommenter pour le PL
        #somme3_it = 0
        #somme3_t=0
        for k in range(nbr_tests):
            g = grille.Grille(taille[0],taille[1],2,0.2,0.2,0.2,0.2,0.2,[0,1,2,3,4],1000).g
            #print(g)
            #print("run "+str(k+1)+" out of "+str(nbr_tests))
            # iteration de la valeur
            d,v,t, time = p2.iteration_de_la_valeur(g,p,gamma,epsilon)
            somme1_it += t
            somme1_t += time
            # iteration de la politique
            d,v,t, time = p2.iteration_de_la_politique(g,p,gamma,epsilon)
            somme2_it += t
            somme2_t += time
            # TODO : à decommenter avec le PL
            #d,v,t,time = p2.pl(g,p,gamma,epsilon)
            #somme3_it += t
            #somme3_t += time
            # ajouter le pl
            line = pd.Series({'dimensions' : taille,
                              'taille' : taille[0]*taille[1],
                              'iter_val' : somme1_it/nbr_tests,
                              'iter_pol': somme2_it/nbr_tests,
                              #'iter_pl' : somme3_it/nbr_tests,
                              'time_val': somme1_t/nbr_tests,
                              'time_pol': somme2_t/nbr_tests,
                              #'time_pl': somme3_t/nbr_tests,
                              })
        df = df.append(line, ignore_index=True)
        
    # Affichage des résultats    
    print(df)
  
    plt.figure(1)
    ax1 = plt.subplot(211)
    plt.scatter(df.taille, df.iter_val, label = "Iteration de la valeur")
    plt.scatter(df.taille, df.iter_pol, label = "Iteration de la politique")    
   # plt.scatter(df.taille, df.iter_pl, label = "Programmation mathématique")
    #plt.xlabel("Taille de l'instance")
    plt.ylabel("Nombre d'itérations")
    plt.setp(ax1.get_xticklabels(), visible=False)
    
    plt.legend(bbox_to_anchor=(1.05, 1), loc = 0, borderaxespad = 0.)  
    
    plt.subplot(212, sharex = ax1)
    plt.scatter(df.taille, df.time_val, label = "Iteration de la valeur")
    plt.scatter(df.taille, df.time_pol, label = "Iteration de la politique")
  #  plt.scatter(df.taille, df.time_pl, label = "Programmation mathématique")
    plt.xlabel("Taille de l'instance")
    plt.ylabel("Durée d'execution")
    
    plt.show()
Esempio n. 10
0
def impact_p(interval_p,
             nbr_tests = default_tests,
             nbLignes = default_nbLignes,
             nbCol = default_nbCol,
             gamma = default_gamma,
             epsilon = default_epsilon):
    df = pd.DataFrame(columns = ["p", 
                                 "iter_val",
                                 "iter_pol",
                                 #"iter_pl",
                                 "time_val",
                                 "time_pol",
                                 #"time_pl",
                                 ])
    for p in interval_p:
        print("p = "+ str(p))
        somme1_it = 0
        somme1_t = 0
        somme2_it =0 
        somme2_t =0
        for k in range(nbr_tests):
            g = grille.Grille(nbLignes,nbCol,2,0.2,0.2,0.2,0.2,0.2,[0,1,2,3,4],1000).g
            #print(g)
            #print("run "+str(k+1)+" out of "+str(nbr_tests))
            d,v,t, time = p2.iteration_de_la_valeur(g,p,gamma,epsilon)
            somme1_it += t
            somme1_t += time
            d,v,t,time = p2.iteration_de_la_politique(g,p,gamma,epsilon)
            somme2_it += t
            somme2_t += time
            #TODO : à decommenter avec le PL
            #d,v,t,time = p2.pl(g,p,gamma,epsilon)
            #somme3_it += t
            #somme3_t += time
            # ajouter le pl
            line = pd.Series({'p' : p,
                              'iter_val' : somme1_it/nbr_tests,
                              'iter_pol': somme2_it/nbr_tests,
                              #'iter_pl' : somme3_it/nbr_tests,
                              'time_val': somme1_t/nbr_tests,
                              'time_pol': somme2_t/nbr_tests,
                              #'time_pl': somme3_t/nbr_tests,
                              })
        df = df.append(line, ignore_index=True)
    
    print(df)
    
    plt.figure(1)
    ax1 = plt.subplot(211)
    plt.scatter(df.p, df.iter_val, label = "Iteration de la valeur")
    plt.scatter(df.p, df.iter_pol, label = "Iteration de la politique")
    # plt.scatter(df.p, df.iter_pl, label = "Programmation mathématique")

    plt.ylabel("Nombre d'itérations")
    plt.setp(ax1.get_xticklabels(), visible=False)
    
    plt.legend(bbox_to_anchor=(1.05, 1), loc = 0, borderaxespad = 0.)  
    
    plt.subplot(212, sharex = ax1)
    plt.scatter(df.p, df.time_val, label = "Iteration de la valeur")
    plt.scatter(df.p, df.time_pol, label = "Iteration de la politique")
    # plt.scatter(df.p, df.time_pl, label = "Programmation mathématique")

    plt.xlabel("Valeur de p")
    plt.ylabel("Durée d'execution")
        
    plt.show()
Esempio n. 11
0
import environnement
import grille
"""
Petit programme de test de la classe Grille
"""

if __name__ == '__main__':
    noir = (0, 0, 0)
    rouge = (255, 0, 0)
    vert = (0, 255, 0)
    g = grille.Grille()
    p1 = environnement.Porte(vert, g)
    voy1 = environnement.Voyageur(rouge, [p1], g)
    obs1 = environnement.Obstacle(noir, g)
    g.addObstacle([(0, 0), (5, 4), (5, 5), (6, 5), (9, 9)], obs1)
    g.addVoyageur((1, 1), voy1)
    g.addPorte([(7, 8), (7, 9)], p1)
    print(g)
    print(g.getContenuCase((0, 0)), g.getContenuCase((1, 1)))
    print(g.getDirection(voy1, p1))
    g.deplacements()
    print(g)
    g.deplacements()
    print(g)
    g.deleteVoyageur(voy1)
    print(g)
    print("fini !")
Esempio n. 12
0
def impact_size(sizes,
                nbr_tests=default_tests,
                p=default_p,
                gamma=default_gamma,
                epsilon=default_epsilon):
    df = pd.DataFrame(columns=[
        "dimensions",
        "taille",
        "iter_val",
        "iter_pol",
        "iter_pl",
        "time_val",
        "time_pol",
        "time_pl",
    ])
    for i, taille in enumerate(sizes):
        print(taille)
        somme1_it = 0
        somme1_t = 0
        somme2_it = 0
        somme2_t = 0
        somme3_it = 0
        somme3_t = 0
        for k in range(nbr_tests):
            fenetre = grille.Grille(taille[0], taille[1], 2, 0.2, 0.2, 0.2,
                                    0.2, 0.2, [0, 1, 2, 3, 4], 1000)
            g = fenetre.g

            # iteration de la valeur
            d, v, t, time = algos.iteration_de_la_valeur(g, p, gamma, epsilon)
            somme1_it += t
            somme1_t += time

            # iteration de la politique
            d, v, t, time = algos.iteration_de_la_politique(
                g, p, gamma, epsilon)
            somme2_it += t
            somme2_t += time

            #pl
            d, v, t, time = algos.pl(g, p, gamma)
            somme3_it += t
            somme3_t += time
            # ajouter le pl
            line = pd.Series({
                'dimensions': taille,
                'taille': taille[0] * taille[1],
                'iter_val': somme1_it / nbr_tests,
                'iter_pol': somme2_it / nbr_tests,
                'iter_pl': somme3_it / nbr_tests,
                'time_val': somme1_t / nbr_tests,
                'time_pol': somme2_t / nbr_tests,
                'time_pl': somme3_t / nbr_tests,
            })

        df = df.append(line, ignore_index=True)

    # Affichage des résultats
    print(df)
    #stocke dans un fichier csv
    df.to_csv("./impact_size.csv", ';')

    plt.figure(1)

    ax1 = plt.subplot(211)
    plt.scatter(df.taille, df.iter_val, label="Iteration de la valeur")
    plt.scatter(df.taille, df.iter_pol, label="Iteration de la politique")
    plt.scatter(df.taille, df.iter_pl, label="Programmation mathématique")
    plt.xlabel("Taille de l'instance")
    plt.ylabel("Nombre d'itérations")
    plt.setp(ax1.get_xticklabels(), visible=False)

    plt.legend(bbox_to_anchor=(1, 1), loc=0, borderaxespad=0.)

    plt.subplot(212, sharex=ax1)
    plt.scatter(df.taille, df.time_val, label="Iteration de la valeur")
    plt.scatter(df.taille, df.time_pol, label="Iteration de la politique")
    plt.scatter(df.taille, df.time_pl, label="Programmation mathématique")
    plt.xlabel("Taille de l'instance")
    plt.ylabel("Durée d'execution")

    plt.show()
Esempio n. 13
0
def impact_gamma(interval_gamma,
                 nbr_tests=default_tests,
                 nbLignes=default_nbLignes,
                 nbCol=default_nbCol,
                 p=default_p,
                 epsilon=default_epsilon):
    df = pd.DataFrame(columns=[
        "gamma",
        "iter_val",
        "iter_pol",
        "iter_pl",
        "time_val",
        "time_pol",
        "time_pl",
    ])
    for gamma in interval_gamma:
        print("gamma = " + str(gamma))
        somme1_it = 0
        somme1_t = 0
        somme2_it = 0
        somme2_t = 0
        somme3_it = 0
        somme3_t = 0
        for k in range(nbr_tests):
            g = grille.Grille(nbLignes, nbCol, 2, 0.2, 0.2, 0.2, 0.2, 0.2,
                              [0, 1, 2, 3, 4], 1000).g

            #iteration de la valeur
            d, v, t, time = algos.iteration_de_la_valeur(g, p, gamma, epsilon)
            somme1_it += t
            somme1_t += time

            #iteration de la politique
            d, v, t, time = algos.iteration_de_la_politique(
                g, p, gamma, epsilon)
            somme2_it += t
            somme2_t += time

            #PL
            d, v, t, time = algos.pl(g, p, gamma)
            somme3_it += t
            somme3_t += time
            # ajouter le pl
            line = pd.Series({
                'gamma': gamma,
                'iter_val': somme1_it / nbr_tests,
                'iter_pol': somme2_it / nbr_tests,
                'iter_pl': somme3_it / nbr_tests,
                'time_val': somme1_t / nbr_tests,
                'time_pol': somme2_t / nbr_tests,
                'time_pl': somme3_t / nbr_tests,
            })
        df = df.append(line, ignore_index=True)

    print(df)
    df.to_csv("./impact_gamma.csv", ';')
    plt.figure(1)

    ax1 = plt.subplot(211)
    plt.scatter(df.gamma, df.iter_val, label="Iteration de la valeur")
    plt.scatter(df.gamma, df.iter_pol, label="Iteration de la politique")
    plt.scatter(df.gamma, df.iter_pl, label="Programmation mathématique")

    plt.ylabel("Nombre d'itérations")
    plt.setp(ax1.get_xticklabels(), visible=False)

    plt.legend(bbox_to_anchor=(1.05, 1), loc=0, borderaxespad=0.)

    plt.subplot(212, sharex=ax1)
    plt.scatter(df.gamma, df.time_val, label="Iteration de la valeur")
    plt.scatter(df.gamma, df.time_pol, label="Iteration de la valeur")
    plt.scatter(df.gamma, df.time_pl, label="Programmation mathématique")

    plt.xlabel("Valeur de Gamma")
    plt.ylabel("Durée d'execution")

    plt.show()