Minor refactoring

lecoutre · lecoutre · commit 6b117e982919 · 2024-02-26T18:48:00.000+01:00
diff --git a/crafted/LargeScaleScheduling/LargeScaleScheduling.py b/crafted/LargeScaleScheduling/LargeScaleScheduling.py
@@ -30,7 +30,11 @@
 
 satisfy(
     # resource cumulative constraint
-    Cumulative(origins=x, lengths=durations, heights=heights) <= limit
+    Cumulative(
+        origins=x,
+        lengths=durations,
+        heights=heights
+    ) <= limit
 )
 
 minimize(
diff --git a/crafted/LargeScaleScheduling/LargeScaleScheduling_z.py b/crafted/LargeScaleScheduling/LargeScaleScheduling_z.py
@@ -38,7 +38,11 @@
 
 satisfy(
     # resource cumulative constraint
-    Cumulative(origins=x, lengths=durations, heights=heights) <= limit,
+    Cumulative(
+        origins=x,
+        lengths=durations,
+        heights=heights
+    ) <= limit,
 
     # computing the make-span
     z == Maximum(x[i] + durations[i] for i in range(nTasks)),
diff --git a/crafted/NFC/NFC.py b/crafted/NFC/NFC.py
@@ -24,7 +24,7 @@
 shift, workers = data
 nPeriods = len(workers)
 
-arcs = [(i, (i + 1) % nPeriods) for i in range(nPeriods)] + [(i, (i + nPeriods - shift) % nPeriods) for i in range(nPeriods)]
+A = [(i, (i + 1) % nPeriods) for i in range(nPeriods)] + [(i, (i + nPeriods - shift) % nPeriods) for i in range(nPeriods)]
 
 # w[i] is the number of workers at the ith period
 w = VarArray(size=nPeriods, dom=range(max(workers) + 1))
@@ -39,12 +39,25 @@
     [w[i] >= workers[i] for i in range(nPeriods)],
 
     # computing the cost of the flow
-    Flow(w + f, balance=0, arcs=arcs, weights=[1] * nPeriods + [0] * nPeriods) == z,
-
-    [w[i] == Sum(f[(i + k) % nPeriods] for k in range(1, shift + 1)) for i in range(nPeriods)]
+    Flow(
+        w + f,
+        balance=0,
+        arcs=A,
+        weights=[1] * nPeriods + [0] * nPeriods
+    ) == z,
+
+    [w[i] == Sum(f[i + 1:i + 1 + shift]) for i in range(nPeriods)]
 )
 
 minimize(
     # minimizing the cost of the flow
     z
 )
+
+""" Comments
+1) Note that:
+ Sum(f[i + 1:i + 1 + shift])
+   is equivalent to:
+ Sum(f[(i + k) % nPeriods] for k in range(1, shift + 1)) 
+Here, automatic index auto-adjustment is used
+"""
diff --git a/crafted/NurseRostering_p/NurseRostering_p.py b/crafted/NurseRostering_p/NurseRostering_p.py
@@ -60,11 +60,15 @@ def automaton():
 x = VarArray(size=[n, n], dom=range(n))
 
 satisfy(
+    # respecting preset tasks
     [x[i][j] == k for (i, j, k) in preset],
 
+    # respecting forbidden assignments
     [x[i][j] != k for (i, j, k) in forbidden],
 
+    # respecting job rules for each employee
     [x[i] in A for i in range(n)],
 
+    # all tasks are different at any time
     [AllDifferent(x[:, j]) for j in range(n)]
 )
diff --git a/crafted/Rubik/Rubik.py b/crafted/Rubik/Rubik.py
@@ -29,7 +29,10 @@
 
 satisfy(
     # respecting all clauses
-    Clause([x[abs(v) - 1] for v in clause], phases=[v > 0 for v in clause]) for clause in clauses
+    Clause(
+        [x[abs(v) - 1] for v in clause],
+        phases=[v > 0 for v in clause]
+    ) for clause in clauses
 )
 
 """
diff --git a/realistic/AircraftAssemblyLine/AircraftAssemblyLine.py b/realistic/AircraftAssemblyLine/AircraftAssemblyLine.py
@@ -67,14 +67,14 @@ def station_of_task(i):
     # respecting limit capacities of areas
     [
         Cumulative(
-            Task(origin=x[t], length=durations[t], height=usedAreaRooms[t][i]) for t in areaTasks[i]
+            tasks=[Task(origin=x[t], length=durations[t], height=usedAreaRooms[t][i]) for t in areaTasks[i]]
         ) <= areaCapacities[i] for i in range(nAreas) if len(areaTasks[i]) > 1
     ],
 
     # computing/restricting the number of operators at each station
     [
         Cumulative(
-            Task(origin=x[t], length=durations[t], height=operators[t] * (x[t] // takt == j)) for t in range(nTasks)
+            tasks=[Task(origin=x[t], length=durations[t], height=operators[t] * (x[t] // takt == j)) for t in range(nTasks)]
         ) <= z[j] for j in range(nStations)
     ],
 
diff --git a/realistic/Benzenoide/Benzenoide.py b/realistic/Benzenoide/Benzenoide.py
@@ -76,7 +76,7 @@ def T1(i, j):
 
     # tag(symmetry-breaking)
     [
-        [LexDecreasing(x, [x[row] for row in sym]) for sym in symmetries],
+        [LexDecreasing(x, x[symmetry]) for symmetry in symmetries],
 
         [Precedence(y, values=(1, v)) for v in range(2, n + 1)]
 
@@ -110,6 +110,10 @@ def T1(i, j):
    is a shortcut for:
  [y[k][l] for k, l in neighbors[i][j]] 
 3) Data for the XCSP23 competition are : [6,7,8,9,10,11,12,13,14,15] 
+4) Note that:
+ x[symmetry] 
+   is equivalent to:
+ [x[row] for row in sym]
 """
 
 # [(y[i][j], y[k][l]) in [(ne(1), ANY), (1, 2)] for i in range(n) for j in range(widths[i])
diff --git a/realistic/CVRP/CVRP.py b/realistic/CVRP/CVRP.py
@@ -50,7 +50,12 @@ def max_tour():
     Cardinality(c, occurrences={i: 1 if i > 0 else n0s for i in range(nNodes)}),
 
     # no holes permitted during tours
-    [If(c[i][j] == 0, Then=c[i][j + 1] == 0) for i in range(nVehicles) for j in range(nSteps - 1)],
+    [
+        If(
+            c[i][j] == 0,
+            Then=c[i][j + 1] == 0
+        ) for i in range(nVehicles) for j in range(nSteps - 1)
+    ],
 
     # computing the collected demands
     [demands[c[i][j]] == d[i][j] for i in range(nVehicles) for j in range(nSteps)],
diff --git a/realistic/Cargo/Cargo.py b/realistic/Cargo/Cargo.py
@@ -105,16 +105,31 @@
     [ft[j] - eta[j] - vrd[j] <= limits.maxDelay for j in range(nVessels)],
 
     # not overlapping stockpiles in space and time
-    NoOverlap(origins=(r_st, y), lengths=(r_dt, lengths)),
+    NoOverlap(
+        origins=(r_st, y),
+        lengths=(r_dt, lengths)
+    ),
 
     # not exceeding the pad lengths
-    Cumulative(origins=r_st, lengths=r_dt, heights=lengths) <= H // coeffs.meter,
+    Cumulative(
+        origins=r_st,
+        lengths=r_dt,
+        heights=lengths
+    ) <= H // coeffs.meter,
 
     # not exceeding the daily stacking capacity
-    Cumulative(origins=r_st, lengths=r_sd, heights=dailyStackingTonnages) <= limits.dailyStacking,
+    Cumulative(
+        origins=r_st,
+        lengths=r_sd,
+        heights=dailyStackingTonnages
+    ) <= limits.dailyStacking,
 
     # ensuring that there are always enough reclaimers
-    Cumulative(origins=rt, lengths=rd, heights=1) <= limits.nReclaimers
+    Cumulative(
+        origins=rt,
+        lengths=rd,
+        heights=1
+    ) <= limits.nReclaimers
 )
 
 minimize(
diff --git a/realistic/CityPosition/CityPosition.py b/realistic/CityPosition/CityPosition.py
@@ -41,7 +41,8 @@ def approx_distance(x1, y1, x2, y2):
     [
         y[-3] == Maximum(y),
         x[-2] * 2 > x[-3] + x[-1],
-        x[-1] == 0, y[-1] == 0
+        x[-1] == 0,
+        y[-1] == 0
     ]
 )
 
diff --git a/realistic/CommunityDetection/CommunityDetection_z1.py b/realistic/CommunityDetection/CommunityDetection_z1.py
@@ -32,7 +32,7 @@
 x = VarArray(size=n, dom=range(m))
 
 # z is the weighted sum of nodes belonging to the same communities
-z = Var(range(sum(W[i][j] for i in range(n) for j in range(i)) + 1))
+z = Var(dom=range(sum(W[i][j] for i in range(n) for j in range(i)) + 1))
 
 satisfy(
     # considering nodes that must belong to the same community
diff --git a/realistic/CyclicRCPSP/CyclicRCPSP.py b/realistic/CyclicRCPSP/CyclicRCPSP.py
@@ -47,10 +47,7 @@
 
 satisfy(
     # computing the make-span
-    z == 1 + (
-            Maximum(s[i] - k[i] * s[-1] for i in range(nTasks - 1))
-            - Minimum(s[i] - k[i] * s[-1] for i in range(nTasks - 1))
-    ),
+    z == 1 + Maximum(s[i] - k[i] * s[-1] for i in range(nTasks - 1)) - Minimum(s[i] - k[i] * s[-1] for i in range(nTasks - 1)),
 
     # generalised precedence constraints
     [
diff --git a/realistic/DepotPlacement/DepotPlacement.py b/realistic/DepotPlacement/DepotPlacement.py
@@ -74,7 +74,10 @@
     ],
 
     # warehouses must be visited first
-    [xa[0] == WA, xb[0] == WB],
+    [
+        xa[0] == WA,
+        xb[0] == WB
+    ],
 
     # coming back to the warehouses is possible from second location  tag(symmetry-breaking)
     [
diff --git a/realistic/HSP/HSP.py b/realistic/HSP/HSP.py
@@ -57,7 +57,10 @@ def duration_limit(i, j, delta):
 
 satisfy(
     # the first operation corresponds to starting the cycle by putting a product in the first tank
-    [t[0] == 0, o[0] == 0],
+    [
+        t[0] == 0,
+        o[0] == 0
+    ],
 
     # taking into account the time of going back to tank 0
     [t[i] <= horizon - ld - (i + 1) * ud for i in range(1, nTanks)],
@@ -77,8 +80,14 @@ def duration_limit(i, j, delta):
     # ensuring a duration limit between any two tanks
     [
         (
-            If(o[j] - o[i] == 1, Then=t[j] - t[i] >= duration_limit(i, j, -1)),
-            If(o[i] - o[j] == 1, Then=t[i] - t[j] >= duration_limit(i, j, +1))
+            If(
+                o[j] - o[i] == 1,
+                Then=t[j] - t[i] >= duration_limit(i, j, -1)
+            ),
+            If(
+                o[i] - o[j] == 1,
+                Then=t[i] - t[j] >= duration_limit(i, j, +1)
+            )
         ) for i, j in combinations(nTanks, 2)
     ]
 )
diff --git a/realistic/Hoist/Hoist.py b/realistic/Hoist/Hoist.py
@@ -38,9 +38,9 @@
 def e(i, j):
     ic = nTanks + 1 if i == N + 1 else multtank[i]
     jc = 0 if j == 0 else multtank[j]
-    cyclei = multiplier - 1 if i == N + 1 else (i - 1) // nTanks
-    cyclej = 0 if j == 0 else (j - 1) // nTanks
-    return 5 * abs(cyclei - cyclej) + eTimes[ic - 1, jc]
+    cycle_i = multiplier - 1 if i == N + 1 else (i - 1) // nTanks
+    cycle_j = 0 if j == 0 else (j - 1) // nTanks
+    return 5 * abs(cycle_i - cycle_j) + eTimes[ic - 1, jc]
 
 
 def f(i):
@@ -89,8 +89,14 @@ def f(i):
         If(
             h[i] <= h[j],  # in case higher numbered hoist removes from lower number tank
             Then=[
-                either(r[i] + f(i) + e(i + 1, j) <= r[j], r[j] + f(j) + e(j + 1, i) <= r[i]),  # (1) ensure the times are not overlapping
-                both(r[i] + f(i) + e(i + 1, j) <= r[j] + z, r[j] + f(j) + e(j + 1, i) <= r[i] + z)  # (2) ensure it concludes before the next action
+                either(  # (1) ensure the times are not overlapping
+                    r[i] + f(i) + e(i + 1, j) <= r[j],
+                    r[j] + f(j) + e(j + 1, i) <= r[i]
+                ),
+                both(  # (2) ensure it concludes before the next action
+                    r[i] + f(i) + e(i + 1, j) <= r[j] + z,
+                    r[j] + f(j) + e(j + 1, i) <= r[i] + z
+                )
             ]
         ) for i in range(1, N + 1) for j in range(i)
     ],
diff --git a/realistic/InstructionSelection/InstructionSelection.py b/realistic/InstructionSelection/InstructionSelection.py
@@ -132,7 +132,7 @@ def is_dominated(i2, m2):
     [
         If(
             x[i] == b,
-            Then=Exist((pl[m] == b) if b not in matches[m].spannedBlocks else ((pl[m] == b) | sl[m]) for m in non_dominated)
+            Then=Exist(pl[m] == b if b not in matches[m].spannedBlocks else either(pl[m] == b, sl[m]) for m in non_dominated)
         ) for i in range(nData) for b in range(nBlocks)
     ],
 
@@ -178,17 +178,26 @@ def is_dominated(i2, m2):
     # tag(redundant-constraints)
     [
         # forbidding two matches to be selected together if they imply conflicting successor blocks
-        [either(sl[mi] == 0, sl[mj] == 0) for i, (mi, pi, qi) in enumerate(inBlockSucc) for j, (mj, pj, qj) in enumerate(inBlockSucc)
-         if i < j and (pi == pj) ^ (qi == qj)],
+        [
+            either(
+                sl[mi] == 0,
+                sl[mj] == 0
+            ) for i, (mi, pi, qi) in enumerate(inBlockSucc) for j, (mj, pj, qj) in enumerate(inBlockSucc) if i < j and (pi == pj) ^ (qi == qj)
+        ],
 
         # forbidding two matches to be selected together if the first implies that two locations are equal
         # and the second implies that the intersection of their domains is empty
-        [either(sl[m] == 0, sl[m2] == 0) for m, p, q in sameLoc for m1, l1, mi1, ma1 in locDomain if l1 == p for m2, l2, mi2, ma2 in locDomain
-         if m1 == m2 and l2 == q and (ma1 < mi2 or ma2 < mi1)]
+        [
+            either(
+                sl[m] == 0,
+                sl[m2] == 0
+            ) for m, p, q in sameLoc for m1, l1, mi1, ma1 in locDomain if l1 == p for m2, l2, mi2, ma2 in locDomain
+            if m1 == m2 and l2 == q and (ma1 < mi2 or ma2 < mi1)
+        ]
     ],
 
     # possible detection of symmetry among location values 1..31
-    [y[i] in {0}.union(set(range(31, nLocations))) for i in range(nData)] if possible_early_symmetry else None,
+    [y[i] not in range(1, 31) for i in range(nData)] if possible_early_symmetry else None,
 
     # dominated matches cannot be selected
     [sl[m] == 0 for m in dominated]
@@ -208,4 +217,5 @@ def is_dominated(i2, m2):
   sl == [1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0,
           1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+3) {0}.union(set(range(31, nLocations))
 """
diff --git a/realistic/JapanEncoding/JapanEncoding.py b/realistic/JapanEncoding/JapanEncoding.py
@@ -167,7 +167,12 @@ def notin(v, ranges):
 )
 
 minimize(
-    Sum((x[i] == EUCJP) * scoreEUCJP[b] + (x[i] == SJIS) * scoreSJIS[b] + (x[i] == UTF8) * scoreUTF8[b] for i, b in enumerate(stream))
+    Sum(
+        (x[i] == EUCJP) * scoreEUCJP[b]
+        + (x[i] == SJIS) * scoreSJIS[b]
+        + (x[i] == UTF8) * scoreUTF8[b]
+        for i, b in enumerate(stream)
+    )
     + 1000 * z
 )
 
diff --git a/realistic/LinearToProgram/LinearToProgram.py b/realistic/LinearToProgram/LinearToProgram.py
@@ -59,11 +59,16 @@
     AllDifferent(line_o),
 
     # ordering of the lines (components use the output of previous lines)
-    [line_i[j] < line_o[r] for r in range(nLines) for j in intervals[r]],
+    [
+        line_i[j] < line_o[r]
+        for r in range(nLines) for j in intervals[r]
+    ],
 
     # computing intermediate variables for examples
-    [x_o[s][r] == (x_i[s][lb] + x_i[s][lb + 1] if r < nPlus else - x_i[s][lb])
-     for s in range(nExamples) for r in range(nLines) if [lb := min(intervals[r])]],
+    [
+        x_o[s][r] == (x_i[s][lb] + x_i[s][lb + 1] if r < nPlus else -x_i[s][lb])
+        for s in range(nExamples) for r in range(nLines) if [lb := min(intervals[r])]
+    ],
 
     # linking the general outputs
     [
diff --git a/realistic/MinimalDecisionSets/MinimalDecisionSets.py b/realistic/MinimalDecisionSets/MinimalDecisionSets.py

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,8 @@ def approx_distance(x1, y1, x2, y2):`
`41`	`41`	`[`
`42`	`42`	`y[-3] == Maximum(y),`
`43`	`43`	`x[-2] * 2 > x[-3] + x[-1],`
`44`		`- x[-1] == 0, y[-1] == 0`
	`44`	`+ x[-1] == 0,`
	`45`	`+ y[-1] == 0`
`45`	`46`	`]`
`46`	`47`	`)`
`47`	`48`