New Example: Facility Location

Author: CameleoGrey

examples/object_oriented/boiler_plate_code/scripts/solve_task.py

@@ -34,7 +34,7 @@
                              migration_rate=0.00001, migration_frequency=1, termination_strategy=termination_strategy)"""
     """agent = LateAcceptance(late_acceptance_size=10, tabu_entity_rate=0.0, 
                            mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0, 0, 0, 0], 
-                           compare_to_global_frequency=1, termination_strategy=termination_strategy)"""
+                           compare_to_global_frequency=1000, termination_strategy=termination_strategy)"""
     """agent = SimulatedAnnealing(initial_temperature=[1.0], cooling_rate=0.9999, tabu_entity_rate=0.0, 
                                mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0, 0, 0, 0], 
                                migration_frequency=10, compare_to_global_frequency=10, termination_strategy=termination_strategy)"""

examples/object_oriented/facility_location/__init__.py

@@ -0,0 +1,11 @@
+
+
+
+
+class CotConsumer:
+
+    def __init__(self, customer_id, location_id, demand, facility_id):
+        self.customer_id = customer_id
+        self.location_id = location_id
+        self.demand = demand
+        self.facility_id = facility_id

examples/object_oriented/facility_location/cotwin/CotConsumer.py

@@ -0,0 +1,11 @@
+
+
+
+
+class CotFacility:
+
+    def __init__(self, facility_id, location_id, setup_cost, capacity):
+        self.facility_id = facility_id
+        self.location_id = location_id
+        self.setup_cost = setup_cost
+        self.capacity = capacity

examples/object_oriented/facility_location/cotwin/CotFacility.py

@@ -0,0 +1,7 @@
+
+
+from greyjack.cotwin.CotwinBase import CotwinBase
+
+class Cotwin(CotwinBase):
+    def __init__(self):
+        super().__init__()

examples/object_oriented/facility_location/cotwin/Cotwin.py

@@ -0,0 +1,36 @@
+class Consumer:
+    """
+    Consumer has a demand that can be satisfied by any Facility with sufficient capacity.
+    
+    Closer facilities are preferred as the distance affects travel time, signal quality, etc.
+    This requirement is expressed by the distance from facility constraint.
+    
+    One of the FLP's goals is to minimize total set-up cost by selecting cheaper facilities.
+    This requirement is expressed by the setup cost constraint.
+    """
+
+    def __init__(self, id=None, location=None, demand=None):
+        self.id = id
+        self.location = location
+        self.demand = demand
+        self.facility = None
+
+    def is_assigned(self):
+        return self.facility is not None
+
+    def distance_from_facility(self):
+        """
+        Get distance from the facility.
+        
+        Returns:
+            distance in meters
+        
+        Raises:
+            RuntimeError: if no facility is assigned
+        """
+        if self.facility is None:
+            raise RuntimeError("No facility is assigned.")
+        return self.facility.location.get_distance_to(self.location)
+
+    def __str__(self):
+        return f"Consumer {self.id} ({self.demand} dem)"

examples/object_oriented/facility_location/cotwin/__init__.py

@@ -0,0 +1,20 @@
+class Facility:
+    """
+    Facility satisfies consumers' demand. Cumulative demand of all consumers assigned to this facility must not exceed
+    the facility's capacity. This requirement is expressed by the facility capacity constraint.
+    """
+    
+    def __init__(self, id=None, location=None, setup_cost=None, capacity=None):
+        self.id = id
+        self.location = location
+        self.setup_cost = setup_cost
+        self.capacity = capacity
+
+    def get_used_capacity(self):
+        return sum(consumer.demand for consumer in self.consumers)
+
+    def is_used(self):
+        return len(self.consumers) > 0
+
+    def __str__(self):
+        return f"Facility {self.id} (${self.setup_cost}, {self.capacity} cap)"

examples/object_oriented/facility_location/domain/Consumer.py

@@ -0,0 +1,69 @@
+
+
+from examples.object_oriented.facility_location.domain import Location
+
+class FacilityLocationDomain:
+    def __init__(self, facilities=None, consumers=None, south_west_corner=None, north_east_corner=None):
+        self.facilities = facilities if facilities is not None else []
+        self.consumers = consumers if consumers is not None else []
+        self.score = None
+        self.south_west_corner = south_west_corner
+        self.north_east_corner = north_east_corner
+        # Constraint weight overrides placeholder
+        self.constraint_weight_overrides = {"distance from facility": (0, 6)}  # (hard, soft) weights
+
+    def print_metrics(self):
+        if self.consumers is None or len(self.consumers) == 0:
+            print("No cosumers. Check domain initialization.")
+        
+        total_distance = 0
+        facilities_usages = {}
+        for consumer in self.consumers:
+            total_distance += consumer.distance_from_facility()
+
+            if consumer.facility not in facilities_usages:
+                facilities_usages[consumer.facility] = 0
+
+            facilities_usages[consumer.facility] += consumer.demand
+        
+        total_setup_cost = 0
+        for facility in facilities_usages.keys():
+            total_setup_cost += facility.setup_cost
+        
+        print("Facility usages:")
+        for facility in facilities_usages:
+            facility_id = facility.id
+            facility_usage = facilities_usages[facility]
+            facility_capacity = facility.capacity
+            print("{}: {}/{}".format(facility_id, facility_usage, facility_capacity))
+        print("Total distance: {} m".format(total_distance))
+        print("Total setup cost: {}$".format(total_setup_cost))
+
+
+
+    @classmethod
+    def empty(cls):
+        return cls(
+            facilities=[],
+            consumers=[],
+            south_west_corner=Location(-90, -180),
+            north_east_corner=Location(90, 180)
+        )
+
+    def get_bounds(self):
+        return [self.south_west_corner, self.north_east_corner]
+
+    def get_total_cost(self):
+        return sum(facility.setup_cost for facility in self.facilities if facility.is_used())
+
+    def get_potential_cost(self):
+        return sum(facility.setup_cost for facility in self.facilities)
+
+    def get_total_distance(self):
+        distance = sum(consumer.distance_from_facility() 
+                      for consumer in self.consumers if consumer.is_assigned())
+        return f"{distance // 1000} km"
+
+    def __str__(self):
+        return (f"FacilityLocationProblem{{facilities: {len(self.facilities)}, "
+                f"consumers: {len(self.consumers)}, score: {self.score}}}")

examples/object_oriented/facility_location/domain/Facility.py

@@ -0,0 +1,19 @@
+import math
+
+class Location:
+    # Approximate Metric Equivalents for Degrees. At the equator for longitude and for latitude anywhere,
+    # the following approximations are valid: 1° = 111 km (or 60 nautical miles) 0.1° = 11.1 km.
+    METERS_PER_DEGREE = 111000
+
+    def __init__(self, latitude, longitude):
+        self.latitude = latitude
+        self.longitude = longitude
+
+    def __str__(self):
+        return f"[{self.latitude:.4f}N, {self.longitude:.4f}E]"
+
+    def get_distance_to(self, other):
+        latitude_diff = other.latitude - self.latitude
+        longitude_diff = other.longitude - self.longitude
+        distance_degrees = math.sqrt(latitude_diff**2 + longitude_diff**2)
+        return math.ceil(distance_degrees * self.METERS_PER_DEGREE)