Refactoring

Author: lecoutre

realistic/RACP/RACP.py

@@ -3,8 +3,7 @@
 See EJOR paper cited below.
 
 The model, below, is close to (can be seen as the close translation of) the one submitted to the 2018/2020 Minizinc challenges.
-The MZN model was proposed by Andreas Schutt.
-No Licence was explicitly mentioned (so, MIT Licence is currently assumed).
+The original MZN model was proposed by Andreas Schutt - no licence was explicitly mentioned (so, MIT Licence is currently assumed).
 
 ## Data Example
   j30-13-6-1-25.json
@@ -18,27 +17,29 @@
 
 ## Links
   - https://www.sciencedirect.com/science/article/abs/pii/S037722171730927X?via%3Dihub
-  - https://www.minizinc.org/challenge2020/results2020.html
+  - https://www.minizinc.org/challenge/2020/results/
 
 ## Tags
   realistic, mzn18, mzn20
 """
 
 from pycsp3 import *
 
-horizon, resourceCosts, durations, successors, needs = data
-nResources, nTasks = len(resourceCosts), len(durations)
+horizon, resourceCosts, durations, successors, needs = data or load_json_data("j30-13-6-1-25.json")
 
-lb_usage, ub_usage = [max(needs[r]) for r in range(nResources)], [sum(needs[r]) for r in range(nResources)]
+nTasks, nResources = len(durations), len(resourceCosts)
+T, R = range(nTasks), range(nResources)
+
+lb_usage, ub_usage = [max(needs[r]) for r in R], [sum(needs[r]) for r in R]
 lb_costs, ub_costs = resourceCosts * lb_usage, resourceCosts * ub_usage
 
 
 def unrelated_tasks():
-    succs = lambda i: successors[i] + list({v for t in [succs(j) for j in successors[i]] for v in t})
+    succs = lambda i: successors[i] + list({v for t in [succs(j) for j in successors[i]] for v in t})  # recursive function
 
-    all_successors = [succs(i) for i in range(nTasks)]
-    all_predecessors = [[j for j in range(nTasks) if i in all_successors[j]] for i in range(nTasks)]
-    return [[j for j in range(nTasks) if j not in all_successors[i] and j not in all_predecessors[i] and j != i] for i in range(nTasks)]
+    all_successors = [succs(i) for i in T]
+    all_predecessors = [[j for j in T if i in all_successors[j]] for i in T]
+    return [[j for j in T if j not in all_successors[i] and j not in all_predecessors[i] and j != i] for i in T]
 
 
 unrelated = unrelated_tasks()
@@ -49,13 +50,12 @@ def compute_ub():
     lct = lambda i: horizon if len(successors[i]) == 0 else min(lct(j) - durations[j] for j in successors[i])
     overlap = lambda si, di, sj, dj: si < sj + dj and sj < si + di
 
-    predecessors = [[j for j in range(nTasks) if i in successors[j]] for i in range(nTasks)]
-    es, ls = [est(i) for i in range(nTasks)], [lct(i) for i in range(nTasks)]
-    rusage_es = [max(needs[r][i] + sum(needs[r][j] for j in unrelated[i] if overlap(es[i], durations[i], es[j], durations[j]))
-                     for i in range(nTasks)) for r in range(nResources)]
+    predecessors = [[j for j in T if i in successors[j]] for i in T]
+    es, ls = [est(i) for i in T], [lct(i) for i in T]
+    rusage_es = [max(needs[r][i] + sum(needs[r][j] for j in unrelated[i] if overlap(es[i], durations[i], es[j], durations[j])) for i in T) for r in R]
     rusage_ls = [max(needs[r][i] + sum(needs[r][j] for j in unrelated[i] if overlap(ls[i] - durations[i], durations[i], ls[j] - durations[j], durations[j]))
-                     for i in range(nTasks)) for r in range(nResources)]
-    return min(sum(resourceCosts[r] * rusage_es[r] for r in range(nResources)), sum(resourceCosts[r] * rusage_ls[r] for r in range(nResources)))
+                     for i in T) for r in R]
+    return min(sum(resourceCosts[r] * rusage_es[r] for r in R), sum(resourceCosts[r] * rusage_ls[r] for r in R))
 
 
 # s[i] is the starting time of the ith task
@@ -69,10 +69,10 @@ def compute_ub():
 
 satisfy(
     # ending tasks before the given horizon
-    [s[i] + durations[i] <= horizon for i in range(nTasks)],
+    [s[i] + durations[i] <= horizon for i in T],
 
     # respecting precedence relations
-    [s[i] + durations[i] <= s[j] for i in range(nTasks) for j in successors[i]],
+    [s[i] + durations[i] <= s[j] for i in T for j in successors[i]],
 
     # redundant non-overlapping constraints   tag(redundant)
     [
@@ -82,7 +82,7 @@ def compute_ub():
                 s[i] + durations[i] <= s[j],
                 s[j] + durations[j] <= s[i]
             )
-        ) for i in range(nTasks) for j in unrelated[i] for r in range(nResources) if needs[r][i] + needs[r][j] > lb_usage[r]
+        ) for i in T for j in unrelated[i] for r in R if needs[r][i] + needs[r][j] > lb_usage[r]
     ],
 
     # redundant constraints on the lower bound of the resource capacities  tag(redundant)
@@ -92,15 +92,15 @@ def compute_ub():
                 s[j] + durations[j] > s[i],
                 s[j] <= s[i]
             ) for j in unrelated[i] if needs[r][j] > 0
-        ) >= needs[r][i] for i in range(nTasks) for r in range(nResources) if needs[r][i] > 0
+        ) >= needs[r][i] for i in T for r in R if needs[r][i] > 0
     ],
 
     [
         Cumulative(
             origins=s,
             lengths=durations,
             heights=needs[r]
-        ) <= u[r] for r in range(nResources)
+        ) <= u[r] for r in R
     ],
 
     # computing the value of the objective

realistic/RCPSP/RCPSP.py

@@ -22,7 +22,8 @@
 
 from pycsp3 import *
 
-jobs, horizon, capacities, _ = data
+jobs, horizon, capacities, _ = data or load_json_data("j030-01-01.json")
+
 durations, successors, quantities = zip(*jobs)  # [job.duration for job in jobs]
 nJobs = len(jobs)
 
@@ -36,7 +37,13 @@
     # resource constraints
     [
         Cumulative(
-            tasks=[Task(origin=s[i], length=durations[i], height=quantities[i][k]) for i in range(nJobs) if quantities[i][k] > 0]
+            tasks=[
+                Task(
+                    origin=s[i],
+                    length=durations[i],
+                    height=quantities[i][k]
+                ) for i in range(nJobs) if quantities[i][k] > 0
+            ]
         ) <= capacity for k, capacity in enumerate(capacities)
     ]
 )

realistic/RCPSP/RCPSP_z.py

@@ -1,6 +1,6 @@
 """
 The model, below, is close to (can be seen as the close translation of) the one submitted to the 2009/2013 Minizinc challenges.
-No Licence was explicitly mentioned (MIT Licence assumed).
+For the original MZN model, no licence was explicitly mentioned (MIT Licence assumed).
 
 ## Data Example
   00.json
@@ -13,17 +13,18 @@
   python RCPSP_z.py -data=<datafile.dzn> -parser=RCPSP_ParserZ.py
 
 ## Links
-  - https://www.minizinc.org/challenge2013/results2013.html
+  - https://www.minizinc.org/challenge/2013/results/
 
 ## Tags
   realistic, mzn08, mzn13
 """
 
 from pycsp3 import *
 
-capacities, durations, requirements, successors = data
-nResources, nTasks = len(capacities), len(durations)
+capacities, durations, requirements, successors = data or load_json_data("00.json")
+
 horizon = sum(durations) + 1
+nTasks, nResources = len(durations), len(capacities)
 
 # x[i] is the starting time of the ith task
 x = VarArray(size=nTasks, dom=range(horizon))

realistic/RCPSP_MAX/RCPSP_MAX.py

@@ -19,21 +19,23 @@
   python RCPSP_MAX.py -data=<datafile.dzn> -parser=RCPSP_MAX_ParserZ.py
 
 ## Links
-  - https://www.minizinc.org/challenge2010/results2010.html
+  - https://www.minizinc.org/challenge/2010/results/
 
 ## Tags
   realistic, mzn10
 """
 
 from pycsp3 import *
 
-capacities, durations, requirements, precedences = data
-nResources, nTasks = len(capacities), len(durations)
+capacities, durations, requirements, precedences = data or load_json_data("psp-j20-34.json")
+
+nTasks, nResources = len(durations), len(capacities)
+T, R = range(nTasks), range(nResources)
 
 # trivial upper bound for the project duration
-horizon = sum(max([durations[i]] + [d for (j, d, _) in precedences if j == i]) for i in range(nTasks)) + 1
+horizon = sum(max([durations[i]] + [d for (j, d, _) in precedences if j == i]) for i in T) + 1
 
-P = [(i, j) for i, j in combinations(nTasks, 2) if any(requirements[r][i] + requirements[r][j] > capacities[r] for r in range(nResources))]
+P = [(i, j) for i, j in combinations(T, 2) if any(requirements[r][i] + requirements[r][j] > capacities[r] for r in R)]
 P1 = [(i, j) for i, j in P if any(k == i and l == j and -durations[j] < d < durations[i] for (k, d, l) in precedences)]
 P2 = [(i, j) for i, j in P if any(k == j and l == i and -durations[i] < d < durations[j] for (k, d, l) in precedences)]
 P3 = [(i, j) for i, j in P if (i, j) not in P1 and (i, j) not in P2]
@@ -65,12 +67,16 @@
     # cumulative resource constraints
     [
         Cumulative(
-            Task(origin=s[i], length=durations[i], height=requirements[r][i]) for i in range(nTasks)
-        ) <= capacities[r] for r in range(nResources)
+            Task(
+                origin=s[i],
+                length=durations[i],
+                height=requirements[r][i]
+            ) for i in T
+        ) <= capacities[r] for r in R
     ],
 
     # constraining the objective value
-    [s[i] + durations[i] <= z for i in range(nTasks)]
+    [s[i] + durations[i] <= z for i in T]
 )
 
 minimize(

realistic/RCPSP_WET/RCPSP_WET.py

@@ -6,7 +6,7 @@
 the given weight for earliness and tardiness per task.
 
 The model, below, is close to (can be seen as the close translation of) the one submitted to the 2016/2017 challenges.
-The MZN model was proposed by University of Melbourne and NICTA (seems to be a MIT Licence).
+The original MZN model was proposed by University of Melbourne and NICTA (seems to be a MIT Licence).
 
 ## Data Example
   j30-27-5.json
@@ -19,48 +19,55 @@
   python RCPSP_WET.py -data=<datafile.dzn> -parser=RCPSP_WET_ParserZ.py
 
 ## Links
-  - https://www.minizinc.org/challenge2017/results2017.html
+  - https://www.minizinc.org/challenge/2017/results/
 
 ## Tags
   realistic, mzn16, mzn17
 """
 
 from pycsp3 import *
 
-resources, tasks, horizon = data
+resources, tasks, horizon = data or load_json_data("j30-27-5.json")
+
 requirements, capacities = zip(*resources)
 durations, successors, deadlines = zip(*tasks)
+
 nTasks, nResources = len(tasks), len(resources)
+T, R = range(nTasks), range(nResources)
 
-relevantTasks = [[i for i in range(nTasks) if requirements[r][i] > 0 and durations[i] > 0] for r in range(nResources)]
+relevantTasks = [[i for i in T if requirements[r][i] > 0 and durations[i] > 0] for r in R]
 
 # s[i] is the starting time of the ith task
 s = VarArray(size=nTasks, dom=range(horizon))
 
 satisfy(
     # enforcing precedence relations
-    [s[i] + durations[i] <= s[j] for i in range(nTasks) for j in successors[i]],
+    [s[i] + durations[i] <= s[j] for i in T for j in successors[i]],
 
     # cumulative resource constraints
     [
         Cumulative(
-            tasks=[Task(origin=s[i], length=durations[i], height=requirements[r][i]) for i in relevantTasks[r]]
-        ) <= capacities[r] for r in range(nResources) if sum(requirements[r][relevantTasks[r]]) > capacities[r]
+            Task(
+                origin=s[i],
+                length=durations[i],
+                height=requirements[r][i]
+            ) for i in relevantTasks[r]
+        ) <= capacities[r] for r in R if sum(requirements[r][relevantTasks[r]]) > capacities[r]
     ],
 
     # redundant non-overlapping constraints  tag(redundant)
     [
         either(
             s[i] + durations[i] <= s[j],
             s[j] + durations[j] <= s[i]
-        ) for i, j in combinations(nTasks, 2) if any(requirements[r][i] + requirements[r][j] > capacities[r] for r in range(nResources))
+        ) for i, j in combinations(T, 2) if any(requirements[r][i] + requirements[r][j] > capacities[r] for r in R)
     ],
 )
 
 minimize(
     # minimizing the weighted earliness/tardiness objective
     Sum(
-        deadlines[i][1] * max(0, deadlines[i][0] - s[i]) + deadlines[i][2] * max(0, s[i] - deadlines[i][0]) for i in range(nTasks)
+        deadlines[i][1] * max(0, deadlines[i][0] - s[i]) + deadlines[i][2] * max(0, s[i] - deadlines[i][0]) for i in T
     )
 )