Exercice 1 et 2 OK

TP_2_3/exo_1_2.py

+import random
+import itertools
+
+class Robot:
+    def __init__(self, id, capacity):
+        self.id = id
+        self.capacity = capacity
+    
+    def __repr__(self):
+        return f"Robot({self.id})"
+        
+
+class Zone:
+    def __init__(self, id, dirt):
+        self.id = id
+        self.dirt = dirt
+    
+    def __repr__(self):
+        return f"Zone({self.id})"
+
+class TaskAllocation:
+    def __init__(self, robotliste, zoneliste):
+        self.robotliste = robotliste
+        self.zoneliste = zoneliste
+        # Création d'un dictionnaire d'utilités aléatoires pour chaque paire (robot, zone)
+        self.dictio = {(robot, zone): random.randint(1, 10) for robot, zone in itertools.product(robotliste, zoneliste)}
+
+    def allocation(self, cuf):
+        # On garde votre structure mais on corrige le problème d'assignation
+        best_allocation = None
+        best_utility = float('-inf')  # On commence avec une utilité très basse
+        
+        # On utilise une approche simplifiée pour générer des allocations
+        # On distribue les zones de manière cyclique avec différents points de départ
+        for start in range(len(self.robotliste)):
+            current_allocation = {robot: [] for robot in self.robotliste}
+            for i, zone in enumerate(self.zoneliste):
+                robot_index = (start + i) % len(self.robotliste)
+                current_allocation[self.robotliste[robot_index]].append(zone)
+            
+            utility = cuf.utility(current_allocation)
+            if best_allocation is None or utility > best_utility:
+                best_utility = utility
+                best_allocation = current_allocation
+        
+        return best_allocation
+
+    def dummy_allocation(self, robotliste, zoneliste):
+        # On garde votre fonction exactement comme elle était
+        i = 0
+        dico = {robot: [] for robot in robotliste}
+        for zone in zoneliste:
+            robot = robotliste[i % len(robotliste)]
+            dico[robot].append(zone)
+            i += 1
+        return dico
+
+    def calculate_cleaning_time(self, allocation):
+        # Nouvelle fonction pour calculer le temps de nettoyage
+        robot_times = []
+        
+        for robot, zones in allocation.items():
+            total_dirt = sum(zone.dirt for zone in zones)
+            cleaning_time = total_dirt / robot.capacity
+            robot_times.append(cleaning_time)
+        
+        # Le temps total est le maximum des temps individuels
+        return max(robot_times) if robot_times else 0
+
+    def getdictio(self):
+        return self.dictio
+
+   
+class CollectiveUtilityFunction:
+    def __init__(self, dico, utility):
+        # On garde votre nom de paramètre "utility" au lieu de "utility_type"
+        self.utility = getattr(self, utility)
+        self.dico = dico
+
+    def utilitariste(self, allocation):
+        total_uti = 0
+        for robot, zones in allocation.items():
+            for zone in zones:
+                total_uti += self.dico[(robot, zone)]
+        return total_uti
+
+    def egalitariste(self, allocation):
+        uti_par_robot = {}
+        for robot, zones in allocation.items():
+            robot_utility = 0
+            for zone in zones:
+                robot_utility += self.dico[(robot, zone)]
+            uti_par_robot[robot] = robot_utility
+        
+        # Si aucun robot n'a d'utilité, retourner 0
+        if not uti_par_robot:
+            return 0
+            
+        return min(uti_par_robot.values())
+
+    def elitiste(self, allocation):
+        uti_par_robot = {}
+        for robot, zones in allocation.items():
+            robot_utility = 0
+            for zone in zones:
+                robot_utility += self.dico[(robot, zone)]
+            uti_par_robot[robot] = robot_utility
+            
+        # Si aucun robot n'a d'utilité, retourner 0
+        if not uti_par_robot:
+            return 0
+            
+        return max(uti_par_robot.values())
+
+    def nash(self, allocation):
+        produit_uti = 1
+        for robot, zones in allocation.items():
+            robot_uti = 0
+            for zone in zones:
+                robot_uti += self.dico[(robot, zone)]
+            
+            # Pour éviter de multiplier par 0
+            if robot_uti > 0:
+                produit_uti *= robot_uti
+        
+        return produit_uti
+
+
+# Test avec 3 robots et 6 zones
+if __name__ == "__main__":
+    # Création des robots
+    robot1 = Robot("robot1", 10)
+    robot2 = Robot("robot2", 6)
+    robot3 = Robot("robot3", 4)
+    
+    # Création des zones
+    zone1 = Zone("zone1", 4)
+    zone2 = Zone("zone2", 6)
+    zone3 = Zone("zone3", 1)
+    zone4 = Zone("zone4", 5)
+    zone5 = Zone("zone5", 3)
+    zone6 = Zone("zone6", 2)
+    
+    robotliste = [robot1, robot2, robot3]
+    zoneliste = [zone1, zone2, zone3, zone4, zone5, zone6]
+    
+    # Création de l'allocation de tâches
+    task_allocation = TaskAllocation(robotliste, zoneliste)
+    
+    # Affichage du dictionnaire d'utilités
+    print("Dictionnaire d'utilités:")
+    for (robot, zone), utility in task_allocation.getdictio().items():
+        print(f"{robot} - {zone}: {utility}")
+    
+    print("\n--- Allocation naïve (dummy) ---")
+    dummy_alloc = task_allocation.dummy_allocation(robotliste, zoneliste)
+    for robot, zones in dummy_alloc.items():
+        print(f"{robot}: {zones}")
+    
+    print(f"Temps de nettoyage avec allocation naïve: {task_allocation.calculate_cleaning_time(dummy_alloc):.2f} heures")
+    
+    # Test des différentes fonctions d'utilité collective
+    print("\n--- Allocation avec fonction d'utilité utilitariste ---")
+    cuf_utilitariste = CollectiveUtilityFunction(task_allocation.getdictio(), "utilitariste")
+    alloc_utilitariste = task_allocation.allocation(cuf_utilitariste)
+    for robot, zones in alloc_utilitariste.items():
+        print(f"{robot}: {zones}")
+    print(f"Utilité utilitariste: {cuf_utilitariste.utility(alloc_utilitariste)}")
+    print(f"Temps de nettoyage: {task_allocation.calculate_cleaning_time(alloc_utilitariste):.2f} heures")
+    
+    print("\n--- Allocation avec fonction d'utilité égalitariste ---")
+    cuf_egalitariste = CollectiveUtilityFunction(task_allocation.getdictio(), "egalitariste")
+    alloc_egalitariste = task_allocation.allocation(cuf_egalitariste)
+    for robot, zones in alloc_egalitariste.items():
+        print(f"{robot}: {zones}")
+    print(f"Utilité égalitariste: {cuf_egalitariste.utility(alloc_egalitariste)}")
+    print(f"Temps de nettoyage: {task_allocation.calculate_cleaning_time(alloc_egalitariste):.2f} heures")
+    
+    print("\n--- Allocation avec fonction d'utilité élitiste ---")
+    cuf_elitiste = CollectiveUtilityFunction(task_allocation.getdictio(), "elitiste")
+    alloc_elitiste = task_allocation.allocation(cuf_elitiste)
+    for robot, zones in alloc_elitiste.items():
+        print(f"{robot}: {zones}")
+    print(f"Utilité élitiste: {cuf_elitiste.utility(alloc_elitiste)}")
+    print(f"Temps de nettoyage: {task_allocation.calculate_cleaning_time(alloc_elitiste):.2f} heures")
+    
+    print("\n--- Allocation avec fonction d'utilité de Nash ---")
+    cuf_nash = CollectiveUtilityFunction(task_allocation.getdictio(), "nash")
+    alloc_nash = task_allocation.allocation(cuf_nash)
+    for robot, zones in alloc_nash.items():
+        print(f"{robot}: {zones}")
+    print(f"Utilité de Nash: {cuf_nash.utility(alloc_nash)}")
+    print(f"Temps de nettoyage: {task_allocation.calculate_cleaning_time(alloc_nash):.2f} heures")
\ No newline at end of file