Moduł planowania trasy #118

planer_module/main.py

@@ -0,0 +1,18 @@
+import json
+
+import numpy as np
+
+from solver.instance import Instance
+from solver.place import Place
+from solver.planer import Planer
+
+with open("tests/1.json") as f:
+    data = json.load(f)
+
+places = [Place(**i) for i in data["places"]]
+distance = np.array(data["distances"])
+
+instance = Instance(places, distance)
+
+planer = Planer()
+planer.plan(instance)

planer_module/solver/instance.py

@@ -0,0 +1,19 @@
+import numpy as np
+from typing import List
+
+from solver.place import Place
+
+
+class Instance:
+    def __init__(self, places: List[Place], distance: np.ndarray):
+        self.places = places
+        self.size = len(places)
+
+        assert distance.shape == (self.size, self.size)
+
+        self.appeal = np.array([i.appeal for i in places])
+        self.open_time = np.array([i.open_time for i in places])
+        self.close_time = np.array([i.close_time for i in places])
+        self.visit_time = np.array([i.visit_time for i in places])
+
+        self.distance = distance

planer_module/solver/place.py

@@ -0,0 +1,9 @@
+class Place:
+    def __init__(
+        self, name: str, open_time: int, close_time: int, visit_time: int, appeal: int
+    ):
+        self.name = name
+        self.open_time = open_time
+        self.close_time = close_time
+        self.visit_time = visit_time
+        self.appeal = appeal

planer_module/solver/planer.py

@@ -0,0 +1,132 @@
+import numpy as np
+import pulp as pl
+
+from solver.instance import Instance
+
+
+class Planer:
+    def __init__(self, M = 10000):
+        self.M = M
+
+    def plan(self, instance):
+        problem, r, w, x = self.make_definition(instance)
+        self.make_goal(problem, r, w, x, instance)
+        self.make_incidence_condition(problem, r, x, instance)
+        self.make_route_condition(problem, r, instance)
+        self.make_consistency_condition(problem, r, instance)
+        self.make_time_condition(problem, r, w, x, instance)
+
+        solution = problem.solve(pl.PULP_CBC_CMD(msg=False))
+
+        if solution != 1:
+            raise ValueError()
+
+        place, time = np.nonzero([[k.value() for k in i] for i in r])
+        result = list(zip(place, time))
+        result.sort(key=lambda x: x[1])
+        result = [instance.places[i[0]].name for i in result]
+
+        print(result)
+
+    def make_definition(self, instance: Instance):
+        problem = pl.LpProblem("Route_planer")
+
+        w = [
+            pl.LpVariable(f"w_{i}", lowBound=0, cat=pl.LpInteger)
+            for i in range(instance.size)
+        ]
+        r = [
+            [pl.LpVariable(f"r_{i}_{k}", cat=pl.LpBinary) for k in range(instance.size)]
+            for i in range(instance.size)
+        ]
+        x = [
+            [
+                [
+                    pl.LpVariable(f"x_{i}_{j}_{k}", cat=pl.LpBinary)
+                    for k in range(instance.size)
+                ]
+                for j in range(instance.size)
+            ]
+            for i in range(instance.size)
+        ]
+
+        return problem, r, w, x
+
+    def make_goal(self, problem, r, w, x, instance: Instance):
+        appeal = pl.lpSum(
+            [instance.appeal[i] * pl.lpSum(r[i]) for i in range(instance.size)]
+        )
+        distance = pl.lpSum(
+            [
+                pl.lpSum(
+                    [
+                        instance.distance[i, j] * pl.lpSum(x[i][j])
+                        for j in range(instance.size)
+                    ]
+                )
+                for i in range(instance.size)
+            ]
+        )
+        waiting_time = pl.lpSum(w)
+
+        problem += -self.M**2 * appeal + self.M * distance + waiting_time
+
+    def make_incidence_condition(self, problem, r, x, instance):
+        for i in range(instance.size):
+            problem += pl.lpSum(x[i][i]) <= 0
+
+        for i in range(instance.size):
+            for j in range(instance.size):
+                for k in range(1, instance.size):
+                    problem += x[i][j][k - 1] >= r[i][k - 1] + r[j][k] - 1
+
+    def make_route_condition(self, problem, r, instance):
+        for i in range(instance.size):
+            problem += pl.lpSum(r[i]) <= 1
+
+        for k in range(instance.size):
+            problem += pl.lpSum([i[k] for i in r]) <= 1
+
+    def make_consistency_condition(self, problem, r, instance):
+        for k in range(1, instance.size):
+            problem += pl.lpSum([i[k] for i in r]) <= pl.lpSum([i[k - 1] for i in r])
+
+    def make_time_condition(self, problem, r, w, x, instance):
+        visit_times = []
+
+        for k in range(instance.size):
+            visit_times.append(
+                pl.lpSum(
+                    [r[i][k] * instance.visit_time[i] for i in range(instance.size)]
+                )
+            )
+
+        travel_times = []
+
+        for k in range(instance.size):
+            travel_times.append(
+                pl.lpSum(
+                    [
+                        [
+                            instance.distance[i, j] * x[i][j][k]
+                            for j in range(instance.size)
+                        ]
+                        for i in range(instance.size)
+                    ]
+                )
+            )
+
+        time_spend = 0
+
+        for k in range(instance.size):
+            time_spend += w[k]
+
+            for i in range(instance.size):
+                problem += time_spend >= r[i][k] * instance.open_time[i]
+
+            time_spend += visit_times[k]
+
+            for i in range(instance.size):
+                problem += time_spend - self.M * (1 - r[i][k]) <= r[i][k] * instance.close_time[i]
+
+            time_spend += travel_times[k]

planer_module/tests/1.json

@@ -0,0 +1,22 @@
+{
+  "places": [
+    {
+      "name": "first",
+      "open_time": 0,
+      "close_time": 10,
+      "visit_time": 8,
+      "appeal": 1
+    },
+    {
+      "name": "second",
+      "open_time": 5,
+      "close_time": 20,
+      "visit_time": 7,
+      "appeal": 5
+    }
+  ],
+  "distances": [
+    [0, 5],
+    [6, 0]
+  ]
+}

planer_module/tests/2.json

@@ -0,0 +1,22 @@
+{
+  "places": [
+    {
+      "name": "first",
+      "open_time": 0,
+      "close_time": 10,
+      "visit_time": 8,
+      "appeal": 1
+    },
+    {
+      "name": "second",
+      "open_time": 0,
+      "close_time": 20,
+      "visit_time": 7,
+      "appeal": 5
+    }
+  ],
+  "distances": [
+    [0, 5],
+    [6, 0]
+  ]
+}

planer_module/tests/3.json

@@ -0,0 +1,22 @@
+{
+  "places": [
+    {
+      "name": "first",
+      "open_time": 0,
+      "close_time": 10,
+      "visit_time": 8,
+      "appeal": 1
+    },
+    {
+      "name": "second",
+      "open_time": 5,
+      "close_time": 20,
+      "visit_time": 7,
+      "appeal": 5
+    }
+  ],
+  "distances": [
+    [0, 6],
+    [5, 0]
+  ]
+}

planer_module/tests/4.json

@@ -0,0 +1,22 @@
+{
+  "places": [
+    {
+      "name": "first",
+      "open_time": 0,
+      "close_time": 10,
+      "visit_time": 9,
+      "appeal": 1
+    },
+    {
+      "name": "second",
+      "open_time": 5,
+      "close_time": 20,
+      "visit_time": 7,
+      "appeal": 5
+    }
+  ],
+  "distances": [
+    [0, 5],
+    [6, 0]
+  ]
+}