diff --git a/__pycache__/offline.cpython-310.pyc b/__pycache__/offline.cpython-310.pyc
index 5efa3c684dd1250014f4476d08736088512164ae..155ed6b0c423da99ddf4463dcc1863917313ac7c 100644
Binary files a/__pycache__/offline.cpython-310.pyc and b/__pycache__/offline.cpython-310.pyc differ
diff --git a/offline.py b/offline.py
index 97b006a34a4495900817d8c9db7336daa3ec5a5b..2e43b84b95fd2557630527dda48416d2ce5f7675 100644
--- a/offline.py
+++ b/offline.py
@@ -3,9 +3,8 @@ from gurobipy import GRB
import copy
def Solve(images, blackouts):
- # TODO: if there are no blackouts, no need for the LP, just take the sum of all lengths and put images in random order
- # now the LP crashes if this is the case because there are no indices for the blackouts
-
+
+ # if there are no blackouts, just send the images in a random order after eachother
image_count = len(images)
blackout_count = len(blackouts)
if blackout_count == 0:
@@ -24,11 +23,11 @@ def Solve(images, blackouts):
br = blackouts # tuples (b^L_br, b^U_br) = [start, end)
js = images # real number p_j = image size
- ts = calculate_whiteboxes(copy.deepcopy(blackouts)) # tuples (time_t, δ_t) = [start, end)
+ white_boxes = calculate_whiteboxes(copy.deepcopy(blackouts)) # tuples (time_t, δ_t) = [start, duration)
- print(f"br {blackout_count} = {br}")
- print(f"\njs {image_count} = {js}")
- print(f"\nts {whitebox_count} = {ts}")
+ print(f"br |{blackout_count}| = {br}")
+ print(f"\njs |{image_count}| = {js}")
+ print(f"\nts |{whitebox_count}| = {white_boxes}")
"""PARAMETERS"""
h = GRB.INFINITY # time horizon = infinite
@@ -42,105 +41,201 @@ def Solve(images, blackouts):
ms = model.addVar(lb=0,vtype=GRB.CONTINUOUS) # makespan, objective function minimization value, bounded with constraints
# P_j_br = model.addVars(image_count, blackout_count,lb=0,vtype=GRB.CONTINUOUS) # preemption time, will be set to 0 in Eq (33)
PV_t = model.addVars(whitebox_count,lb=0,vtype=GRB.CONTINUOUS) # sum of length of images in whitebox t
- Tf_j = model.addVars(image_count,lb=0,vtype=GRB.CONTINUOUS) # finish of image j
- Tf_t = model.addVars(whitebox_count,lb=0,vtype=GRB.CONTINUOUS) # finish of all images in whitebox t
- Ts_j = model.addVars(image_count,lb=0,vtype=GRB.CONTINUOUS) # start of image j
- Ts_t = model.addVars(whitebox_count,lb=0,vtype=GRB.CONTINUOUS) # start of timeslot t, probably redundant
+ Tf_j = model.addVars(image_count,lb=0,vtype=GRB.CONTINUOUS) # finish time of image j
+ Tf_t = model.addVars(whitebox_count,lb=0,vtype=GRB.CONTINUOUS) # finish time of ALL images in whitebox t
+ Ts_j = model.addVars(image_count,lb=0,vtype=GRB.CONTINUOUS) # start of processing of image j
+ # Ts_t = model.addVars(whitebox_count,lb=0,vtype=GRB.CONTINUOUS) # start of timeslot t, probably redundant
X_j_t = model.addVars(image_count, whitebox_count,vtype=GRB.BINARY) # order j in whitebox t
Xfree_t = model.addVars(whitebox_count,vtype=GRB.BINARY) # whitebox t has no images in it
- Y_j_jprime = model.addVars(image_count, image_count,vtype=GRB.BINARY) # image j comes before image j' in the global order
+ # Y_j_jprime = model.addVars(image_count, image_count,vtype=GRB.BINARY) # image j comes before image j' in the global order
YA_j_br = model.addVars(image_count, blackout_count,vtype=GRB.BINARY) # order j starts after blackbox br
YB_j_br = model.addVars(image_count, blackout_count,vtype=GRB.BINARY) # order j finishes before blackbox br
"""CONSTRAINTS"""
- # model.addConstr(Y_j_jprime[0,0] == 0)
- # model.addConstr(Y_j_jprime[0,1] == 0)
- # model.addConstr(Y_j_jprime[1,0] == 1)
- # model.addConstr(Y_j_jprime[1,1] == 0)
# (1) minimize makespan
model.setObjective(ms, GRB.MINIMIZE)
- # (3)
+ # (3) make sure the starttime and endtime are exactly picture size apart
model.addConstrs((Tf_j[j] - Ts_j[j] == js[j]
for j in range(image_count)),
name="Eq(3)")
- # (4)
- model.addConstrs((Tf_j[j] * Y_j_jprime[j,jprime] <= Ts_j[jprime] * Y_j_jprime[j,jprime]
- for j in range(image_count)
- for jprime in range(image_count)),
- name="Eq(4)")
+ # (4) let the finishtime of a picture scheduled before another be lower or equal to the starting time of the later picture
+ # model.addConstrs((Tf_j[j] * Y_j_jprime[j,jprime] <= Ts_j[jprime] * Y_j_jprime[j,jprime]
+ # for j in range(image_count)
+ # for jprime in range(image_count)),
+ # name="Eq(4)")
# (4 v2)
# model.addConstrs((Tf_j[j] <= Ts_j[jprime] + tfU_j * (1 - Y_j_jprime[j,jprime])
# for j in range(image_count)
# for jprime in range(image_count)),
# name="Eq(4 v2)")
- # (4 v3)
- # for j in range(image_count):
- # for jprime in range(j+1,image_count):
- # model.addConstr((Tf_j[j] <= Ts_j[jprime] + tfU_j * (1 - Y_j_jprime[j,jprime])),
- # name="Eq(4 v2)")
- # # (5 v3)
- # for j in range(image_count):
- # for jprime in range(j+1,image_count):
- # model.addConstr((Tf_j[jprime] <= Ts_j[j] + tfU_j * (1 + Y_j_jprime[j,jprime])),
- # name="Eq(5 v3)")
+ # (5)
+ # model.addConstrs((Tf_j[jprime] * Y_j_jprime[j,jprime] <= Ts_j[j] * Y_j_jprime[j,jprime]
+ # for j in range(image_count)
+ # for jprime in range(image_count)),
+ # name="Eq(5)")
+
+ """
+ penalty:
+
+ For all images:
+ eindtijd <- {begintijd whitbox} + {size of all images in whitebox}
+ """
+
+ """
+ penalty:
+
+ For all images:
+ eindtijd Tf_j <- {PV_T van whitebox waar die in zit}
+ """
+
# (9)
- model.addConstrs((ms >= Tf_j[j]
- for j in range(image_count)),
- name="Eq(9)")
- # (11)
- model.addConstrs((Ts_t[t+1] >= Tf_t[t]
- for t in range(whitebox_count - 1)),
- name="Eq(11)")
- # (13)
- model.addConstrs((Tf_t[t] - Ts_t[t] == PV_t[t]
+ # model.addConstrs((ms >= Tf_j[j]
+ # for j in range(image_count)),
+ # name="Eq(9)")
+
+ # (9 V2)
+ model.addConstrs((ms >= (PV_t[t] + white_boxes[t][0]) * (1-Xfree_t[t])
+ for t in range(whitebox_count)),
+ name="Eq(9 V2)")
+
+ # # (11)
+ # model.addConstrs((white_boxes[t+1][0] >= Tf_t[t]
+ # for t in range(whitebox_count - 1)),
+ # name="Eq(11)")
+
+ # (13) set the PV_T
+ # model.addConstrs((Tf_t[t] - white_boxes[t][0] >= PV_t[t]
+ # for t in range(whitebox_count)),
+ # name="Eq(13)")
+
+ # (13) set the PV_T
+ model.addConstrs((white_boxes[t][1] >= PV_t[t]
for t in range(whitebox_count)),
name="Eq(13)")
+
# (17)
+ # model.addConstrs((gp.quicksum(X_j_t[j,t] for j in range(image_count))
+ # + Xfree_t[t]
+ # == 1
+ # for t in range(whitebox_count)),
+ # name="Eq(17)")
+
+ # model.addConstrs((bool(gp.quicksum(X_j_t[j,t] for j in range(image_count)))
+ # + Xfree_t[t]
+ # == 1
+ # for t in range(whitebox_count)),
+ # name="Eq(17)")
+
+ # (17 v2) SET Xfree_t
model.addConstrs((gp.quicksum(X_j_t[j,t] for j in range(image_count))
+ Xfree_t[t]
- == 1
+ >= 1 # don't limit 1 image per whitebox t
+ for t in range(whitebox_count)),
+ name="Eq(17)")
+
+ # Xfree_t <= 1 to make it binary
+ model.addConstrs((Xfree_t[t] <= 1
+ for t in range(whitebox_count)),
+ name="Eq(17)")
+
+ # Set Xfree to 0 if whitebox is not empty
+ model.addConstrs((gp.quicksum(X_j_t[j,t] for j in range(image_count))
+ * Xfree_t[t]
+ == 0
for t in range(whitebox_count)),
name="Eq(17)")
- # (19)
+
+ """
+ Als som > 0 is
+
+ >>> iets * 0 = 0 <<<
+
+ 0 == som * Xfree_t
+
+ 0 == 123 * X --> X = 1
+ 0 == 0 * X --> X kan van alles worden
+ X <= 1
+
+ Xfree_t -> 0
+ """
+
+
+ """
+
+ for whiteboxes:
+ Sommeer dit:
+ PV_T + starttijd whitebox
+ """
+
+
+ """
+ V Xfree_t -> 1 als whitebox leeg is
+
+ X Xfree_t -> 0 als whitebox niet leeg is ==> som over j van X_j_t >= 1 voor alle T
+
+ 1. test_t <= 1
+ 2. test_t >= som over j van X_j_t
+ 3. Xfree_t == 1 - test_t
+
+
+ (som + 1) * Xfree_t === som * Xfree_t
+
+ * (1 - Xfree_t)
+
+ gp.quicksum(X_j_t[j,t]) -> aantal images in whitebox
+
+ """
+
+ # model.addConstrs((gp.quicksum(X_j_t[j,t] for j in range(image_count))
+ # + Xfree_t[t]
+ # <= 1
+ # for t in range(whitebox_count)),
+ # name="Eq(17)")
+
+ # (19) makes sure each image is send once
model.addConstrs((gp.quicksum(X_j_t[j,t]
for t in range (whitebox_count)) == 1
for j in range (image_count)),
name="Eq(19)")
- # (20)
+ # # (20)
model.addConstrs((PV_t[t] == gp.quicksum(js[j] * X_j_t[j,t]
for j in range(image_count))
for t in range(whitebox_count)),
name="Eq(20)")
+ # # (20.2)
+ model.addConstrs((PV_t[t] <= white_boxes[t][1]
+ for t in range(whitebox_count)),
+ name="Eq(20.2)")
# (32)
- # model.addConstrs((YB_j_br[j,br_index] + YA_j_br[j,br_index] == X_j_t[j,t]
+ # model.addConstrs((YB_j_br[j,br_index] + YA_j_br[j,br_index] == X_j_t[j,t]
# for j in range(image_count)
# for t in range (whitebox_count)
# for br_index in range(blackout_count)),
# name="Eq(32)")
# (33)
- # model.addConstrs((P_j_br[j,br_index] == 0 for j in range(image_count)
+ # model.addConstrs((P_j_br[j,br_index] == 0 for j in range(image_count)
# for br_index in range(blackout_count)),
# name="Eq(33)")
# (34)
- model.addConstrs((br[br_index][1] * YA_j_br[j,br_index] <= Ts_j[j]
- for br_index in range(blackout_count)
- for j in range(image_count)),
- name="Eq(34)")
- # (35)
- model.addConstrs((Ts_j[j] <= br[br_index][0] * YB_j_br[j, br_index] + YA_j_br[j, br_index] * GRB.INFINITY
- for j in range(image_count)
- for br_index in range(blackout_count)),
- name="Eq(35)")
- # (36)
- model.addConstrs((br[br_index][1] * YA_j_br[j,br_index] <= Tf_j[j]
- for br_index in range(blackout_count)
- for j in range(image_count)),
- name="Eq(36)")
- # (37)
- model.addConstrs((Tf_j[j] <= br[br_index][0] * YB_j_br[j, br_index]
- for j in range(image_count)
- for br_index in range(blackout_count)),
- name="Eq(37)")
+ # model.addConstrs((br[br_index][1] * YA_j_br[j,br_index] <= Ts_j[j]
+ # for br_index in range(blackout_count)
+ # for j in range(image_count)),
+ # name="Eq(34)")
+ # # (35)
+ # model.addConstrs((Ts_j[j] <= br[br_index][0] * YB_j_br[j, br_index] + YA_j_br[j, br_index] * GRB.INFINITY
+ # for j in range(image_count)
+ # for br_index in range(blackout_count)),
+ # name="Eq(35)")
+ # # (36)
+ # model.addConstrs((br[br_index][1] * YA_j_br[j,br_index] <= Tf_j[j]
+ # for br_index in range(blackout_count)
+ # for j in range(image_count)),
+ # name="Eq(36)")
+ # # (37)
+ # model.addConstrs((Tf_j[j] <= br[br_index][0] * YB_j_br[j, br_index]
+ # for j in range(image_count)
+ # for br_index in range(blackout_count)),
+ # name="Eq(37)")
# SOLVE AND PRINT THE RESULTS
model.optimize()
@@ -150,36 +245,46 @@ def Solve(images, blackouts):
if model.status == GRB.OPTIMAL:
deletus = starts.pop()
time = model.ObjVal
- print('\nFinish time: %g' % time)
+
+ # print('\nWhitebox times:')
+ # for t in range(whitebox_count):
+ # wbtimestart = white_boxes[t][0]
+ # wbtimefinish = Tf_t[t].X
+ # print(f"Wb {t} starts t={wbtimestart} finishes t={wbtimefinish}")
+ # starts.append(t)
- print("White box decision variables:")
+ print("\nWhite box decision variables:")
for (j,t) in X_j_t:
print(f"(im{j},wb{t}) = {X_j_t[j,t].X}")
- print('\nTimes:')
- for im in Ts_j:
- ts = Ts_j[im].X
- tf = Tf_j[im].X
- print(f"Image {im} starts t={ts} finishes t={tf}")
- starts.append(t)
-
- print('\nOrder:')
- for im in Ts_j:
- for im2 in Ts_j:
- print(f"{im} before {im2}: {Y_j_jprime[im, im2].X}")
+ # print('\nOrder:')
+ # for im in Ts_j:
+ # for im2 in Ts_j:
+ # print(f"{im} before {im2}: {Y_j_jprime[im, im2].X}")
- print('\nWhitebox contains:')
- for t in PV_t:
- print(f"wb{t} is {Xfree_t[t].X} empty and holds length {PV_t[t].X} of images")
-
- print('\nBlackboxes before/after:')
+ print('\nImage before/after blackbox:')
for (j,br_index) in YA_j_br:
print(f"YA_{j}_{br_index}: image {j} after blackbox {br_index} = {YA_j_br[j,br_index].X}")
print(f"YB_{j}_{br_index}: image {j} before blackbox {br_index} = {YB_j_br[j,br_index].X}")
+ print(f"(34) {br[br_index][1]} * {YA_j_br[j,br_index].X} <= {Ts_j[j].X}")
+ print(f"(35) {Ts_j[j].X} <= {br[br_index][0]} * {YB_j_br[j, br_index].X} + {YA_j_br[j, br_index].X} * infinity")
+ print(f"(36) {br[br_index][1]} * {YA_j_br[j,br_index].X} <= {Tf_j[j].X}")
+ print(f"(37) {Tf_j[j].X} <= {br[br_index][0]} * {YB_j_br[j, br_index].X}\n")
+
+ print('\nFinish time: %g' % time)
+ print('Whitebox contains:')
+ for t in PV_t:
+ print(f"wb{t} is {Xfree_t[t].X} empty and holds length {PV_t[t].X} of images")
+ # print('\nImage times:')
+ # for im in Ts_j:
+ # jtimestart = Ts_j[im].X
+ # jtimefinish = Tf_j[im].X
+ # print(f"Image {im} starts t={jtimestart} finishes t={jtimefinish}")
+ # starts.append(t)
else:
- print('\nNo solution, reason:')
+ print('\nNo solution, Check input or constraints! Reason:')
iis = model.computeIIS() # Irreducible Infeasible Subsystem, https://support.gurobi.com/hc/en-us/articles/360029969391-How-do-I-determine-why-my-model-is-infeasible-
print(iis)
@@ -194,7 +299,7 @@ def calculate_whiteboxes(blackouts):
if (len(blackouts) == 0): # no black boxes, so whitebox length is infinite
return [(0, GRB.INFINITY)]
- current_blackout = blackouts.pop()
+ current_blackout = blackouts[0]
begin = 0
end = current_blackout[0]
wb.append((begin, end - begin))
@@ -202,7 +307,7 @@ def calculate_whiteboxes(blackouts):
for i in range(1, len(blackouts) + 2):
begin = current_blackout[1]
if (i < length):
- current_blackout = blackouts.pop()
+ current_blackout = blackouts[i]
end = current_blackout[0]
wb.append((begin, end - begin))
else:
diff --git a/t4_in.txt b/t4_in.txt
index cf65d86d9abe2d0915a0b0a3ed67f4b02fc1a9af..657f0aaa6a50c77c715ae57a5da82256c70a5efb 100644
--- a/t4_in.txt
+++ b/t4_in.txt
@@ -1,5 +1,5 @@
2
-10
15
+10
1
-25, 5
\ No newline at end of file
+100, 25
\ No newline at end of file
diff --git a/t4_out.txt b/t4_out.txt
index c006f6e306eeba32ae49910dc6aa351c5980224f..c210f24f5ad9c942ff9a94b0d5b034be0b2182c7 100644
--- a/t4_out.txt
+++ b/t4_out.txt
@@ -1,3 +1 @@
-15.0
-1
-1
\ No newline at end of file
+50.0
\ No newline at end of file