def __init__(self, flp: FacilityLocationProblem, x: list):
self.flp = flp
self.m = Model()
# Creates the variables
y = self.m.addVars(flp.n_facilities, flp.n_customers, name="y")
v1 = self.m.addVars(flp.n_facilities, name="v+")
v2 = self.m.addVars(flp.n_customers, name="v-")
# Creates the objective
expr = 0
for i in range(flp.n_facilities):
expr += v1[i]
for j in range(flp.n_customers):
expr += v2[j]
self.m.setObjective(expr, GRB.MINIMIZE)
# Constraints
self.dc = []
self.cc = []
for i in range(flp.n_facilities):
print(x[i])
self.cc.append(
self.m.addConstr(
y.sum(i, '*') - v1[i] <= flp.capacity[i] * x[i]))
for j in range(flp.n_customers):
self.dc.append(
self.m.addConstr(y.sum('*', j) + v2[j] >= flp.demands[j]))
def __init__(self, p: CuttingStockProblem):
self.p = p
self.m = Model('CS1')
# Decision variables
n_large_rolls = self.p.get_max_number_of_large_rolls()
n_small_roll_types = len(self.p.demand)
print(n_large_rolls, n_small_roll_types)
y = self.m.addVars([i for i in range(n_large_rolls)],
lb=0,
ub=1,
vtype=GRB.CONTINUOUS,
name="y")
z = self.m.addVars([j for j in range(n_small_roll_types)],
[i for i in range(n_large_rolls)],
lb=0,
ub=GRB.INFINITY,
vtype=GRB.CONTINUOUS,
name="x")
# Objective function
self.m.setObjective(y.sum('*'))
# Constraints
# Note that the argument passed to quicksum is a list, and the list is built using comprehension
self.m.addConstrs(
quicksum([
self.p.width_small_rolls[i] * z[i, j]
for i in range(n_small_roll_types)
]) <= self.p.width_large_rolls * y[j]
for j in range(n_large_rolls))
self.m.addConstrs(
z.sum(i, '*') >= self.p.demand[i]
for i in range(n_small_roll_types))
def __init__(self,pp:ProcurementProblem,material:int,pi:float):
"""
Creates an instance of the DW's subproblem
for a given material and given pi, the dual
variable value corresponding to the complicating constraints
in the RMP.
:param pp:
:param product:
:param pi:
"""
self.pp = pp
self.m = Model()
self.material = material
# The subproblem has only one decision variable
self.x = self.m.addVar()
# The objective function will be
# (c_j - pi A_j)*x, where j = material
expr = (self.pp.costs[material] - pi*self.pp.consumption[material]) * self.x
self.m.setObjective(expr, GRB.MINIMIZE)
# The constraints bind the value of x to a min and max production quantity
self.m.addConstr(self.x <= self.pp.max_production[material])
self.m.addConstr(self.x >= self.pp.min_production[material])
class FullModel:
def __init__(self, flp: FacilityLocationProblem):
self.flp = flp
self.m = Model()
# Creates the variables
self.y = self.m.addVars(flp.n_facilities, flp.n_customers, name="y")
self.x = self.m.addVars(flp.n_facilities, vtype=GRB.BINARY, name="x")
# Creates the objective
expr = 0
for i in range(flp.n_facilities):
expr += flp.fixed_costs[i] * self.x[i]
for j in range(flp.n_customers):
expr += flp.delivery_costs[i][j] * self.y[i, j]
self.m.setObjective(expr, GRB.MINIMIZE)
# Constraints
for i in range(flp.n_facilities):
self.m.addConstr(self.y.sum(i, '*') <= flp.capacity[i] * self.x[i])
for j in range(flp.n_customers):
self.m.addConstr(self.y.sum('*', j) >= flp.demands[j])
def solve(self):
self.m.optimize()
def print_solution(self):
for i in range(self.flp.n_facilities):
print('%s %g' % (self.x[i].varName, self.x[i].x))
print('Obj: %g' % self.m.objVal)
def __init__(self, pp: ProcurementProblem):
"""
Builds an instance of the DW's RMP for the
Procurement Problem.
:param pp:
"""
# Builds an instance of the model
self.m = Model()
self.pp = pp
# In the following list it will store all columns added to RMP during the DW algorithm
self.columns = []
# Initially there is no variable,
# but we will add them here
# as we generate them
self.u = []
# Creates an empty objective
self.m.setObjective(0, GRB.MINIMIZE)
# Creates the complicating constraints
self.compc = self.m.addConstr(0, GRB.GREATER_EQUAL, self.pp.demand,
"cc")
# Creates the convexity constraints
self.convc = self.m.addConstr(0, GRB.EQUAL, 1)
class KnapsackProblemModel:
def __init__(self,p:KnapsackProblem):
self.p = p
self.m = Model('knapsack')
# Creates the decision variables
self.x = self.m.addVars(len(p.rewards),vtype = GRB.BINARY,name = "x")
# Creates the objective
self.m.setObjective(quicksum([self.p.rewards[i] * self.x[i] for i in range(len(self.p.rewards))]),sense=GRB.MAXIMIZE)
# Creates the constraint
self.m.addConstr(quicksum([self.p.weights[i] * self.x[i] for i in range(len(self.p.weights))]) <= self.p.capacity)
def addCover(self,indices:list,rhs:int):
self.m.addConstr(quicksum([self.x[indices[i]] for i in range(len(indices))]) <= rhs)
def solve(self):
self.m.optimize()
def printSolution(self):
print("Objective ", self.m.objVal)
for v in self.m.getVars():
print('%s %g' % (v.varName, v.x))
def __init__(self, p: AlloyProductionProblem):
self.p = p
self.m = Model('APP')
# Creates the decision variables
self.materials = list(p.availability.keys())
chemicals = list(p.max_grade.keys())
self.x = self.m.addVars(self.materials, name='x')
# Creates the objective function
expr = self.x.prod(p.cost)
self.m.setObjective(expr, sense=GRB.MINIMIZE)
# Creates the constraints
# Min content
self.m.addConstrs(
quicksum([p.content[(k, m)] * self.x[m]
for m in self.materials]) >= p.min_grade[k] *
self.x.sum('*') for k in chemicals)
# Max content
self.m.addConstrs(
quicksum([p.content[(k, m)] * self.x[m]
for m in self.materials]) <= p.max_grade[k] *
self.x.sum('*') for k in chemicals)
# Availability
self.m.addConstrs(self.x[m] <= p.availability[m]
for m in self.materials)
# Demand
self.m.addConstr(self.x.sum('*') >= p.demand)
def __init__(self):
self.m = Model()
self.x = self.m.addVar(name="x")
self.phi = self.m.addVar(name="phi")
# Objective function
self.m.setObjective(2 * self.x + self.phi, sense=GRB.MINIMIZE)
def __init__(self,p:KnapsackProblem):
self.p = p
self.m = Model('knapsack')
# Creates the decision variables
self.x = self.m.addVars(len(p.rewards),vtype = GRB.BINARY,name = "x")
# Creates the objective
self.m.setObjective(quicksum([self.p.rewards[i] * self.x[i] for i in range(len(self.p.rewards))]),sense=GRB.MAXIMIZE)
# Creates the constraint
self.m.addConstr(quicksum([self.p.weights[i] * self.x[i] for i in range(len(self.p.weights))]) <= self.p.capacity)
def __init__(self,p: UraniumMineProblem):
self.p = p
self.m = Model('uranium')
# Decision variables
self.x = self.m.addVars(self.p.blocks,vtype=GRB.BINARY,name="x")
# Objective function
expr = quicksum([(p.values[b] - p.costs[b]) * self.x[b] for b in p.blocks])
self.m.setObjective(expr,sense=GRB.MAXIMIZE)
# Constraints
self.m.addConstrs(self.x[a] - self.x[b] <= 0 for (a,b) in p.precedences)
def __init__(self, x: float):
self.m = Model()
self.y1 = self.m.addVar(name = "y1")
self.y2 = self.m.addVar(name = "y2")
# Objective function
self.m.setObjective(self.y1 + 3*self.y2, sense=GRB.MINIMIZE)
# Constraints
self.c1 = self.m.addConstr(2 * self.y1 + self.y2 == 1 - x)
self.c2 = self.m.addConstr(-self.y1 + self.y2 == 2 - 4 * x)
def __init__(self):
self.m = Model()
self.x = self.m.addVar(name="x")
self.y1 = self.m.addVar(name="y1")
self.y2 = self.m.addVar(name="y2")
# Objective function
self.m.setObjective(2 * self.x + self.y1 + 3 * self.y2,
sense=GRB.MINIMIZE)
# Constraints
self.m.addConstr(2 * self.y1 + self.y2 + self.x == 1)
self.m.addConstr(-self.y1 + self.y2 + 4 * self.x == 2)
class CuttingStockModel2:
def __init__(self, p: CuttingStockProblem):
self.p = p
self.m = Model('CS1')
# Decision variables
n_patterns = len(self.p.get_feasible_patterns())
x = self.m.addVars(n_patterns,
lb=0,
ub=GRB.INFINITY,
vtype=GRB.INTEGER,
name="x")
# Objective function
self.m.setObjective(x.sum('*'))
# Constraints
# Note that the argument passed to quicksum is a list, and the list is built using comprehension
self.m.addConstrs(
quicksum([
self.p.get_feasible_patterns()[q][i] * x[q]
for q in range(n_patterns)
]) >= self.p.demand[i] for i in range(len(p.demand)))
def solve(self):
self.m.optimize()
def print_solution(self):
print("Objective ", self.m.objVal)
for v in self.m.getVars():
print("%s %g" % (v.varName, v.x))
def __init__(self, p:CuttingStockProblem):
self.p = p
self.m = Model('CS1')
# Decision variables
n_patterns = len(self.p.get_feasible_patterns())
x = self.m.addVars(n_patterns,lb= 0, ub= GRB.INFINITY, vtype=GRB.CONTINUOUS,name="x")
# Objective function
self.m.setObjective(x.sum('*'))
# Constraints
# Note that the argument passed to quicksum is a list, and the list is built using comprehension
self.m.addConstrs(quicksum([self.p.get_feasible_patterns()[q][i] * x[q] for q in range(n_patterns)]) >= self.p.demand[i] for i in range(len(p.demand)))
def defineVars(data: DataInstance):
model = Model("GLayout")
L = define1DIntVarArray(model, data.element_count, "L")
R = define1DIntVarArray(model, data.element_count, "R")
T = define1DIntVarArray(model, data.element_count, "T")
B = define1DIntVarArray(model, data.element_count, "B")
H = define1DIntVarArray(model, data.element_count, "H")
W = define1DIntVarArray(model, data.element_count, "W")
ABOVE = define2DBoolVarArrayArray(model, data.element_count, data.element_count, "ABOVE")
LEFT = define2DBoolVarArrayArray(model, data.element_count, data.element_count, "LEFT")
N = data.element_count
LAG = define1DBoolVarArray(model, data.element_count, "LAG")
RAG = define1DBoolVarArray(model, data.element_count, "RAG")
TAG = define1DBoolVarArray(model, data.element_count, "TAG")
BAG = define1DBoolVarArray(model, data.element_count, "BAG")
vLAG = define1DIntVarArray(model, data.element_count, "vLAG")
vRAG = define1DIntVarArray(model, data.element_count, "vRAG")
vTAG = define1DIntVarArray(model, data.element_count, "vTAG")
vBAG = define1DIntVarArray(model, data.element_count, "vBAG")
elemAtLAG = define2DBoolVarArrayArray(model, data.element_count, data.element_count, "zLAG")
elemAtRAG = define2DBoolVarArrayArray(model, data.element_count, data.element_count, "zRAG")
elemAtTAG = define2DBoolVarArrayArray(model, data.element_count, data.element_count, "zTAG")
elemAtBAG = define2DBoolVarArrayArray(model, data.element_count, data.element_count, "zBAG")
return model, N, (L, R, T, B, H, W), (ABOVE, LEFT), (LAG, RAG, TAG, BAG), (vLAG, vRAG, vTAG, vBAG), \
(elemAtLAG, elemAtRAG, elemAtTAG, elemAtBAG)
def __init__(self, p: StadiumConstructionProblem):
self.p = p
self.m = Model('stadium')
# Decision variables
self.x = self.m.addVars(self.p.tasks, name="x")
self.q = self.m.addVar(name="maxtime")
# Objective function
self.m.setObjective(self.q, sense=GRB.MINIMIZE)
# Constraints
self.m.addConstrs(self.q - self.x[t] >= 0 for t in p.tasks)
self.m.addConstrs(self.x[t1] - self.x[t2] >= p.durations[t1]
for (t1, t2) in p.precedences)
self.m.addConstrs(self.x[t] >= p.durations[t] for t in p.tasks)
def defineObjectives(data: DataInstance, model: Model, boolVars, N, posVars):
LAG, RAG, TAG, BAG = boolVars
L, R, T, B, H, W = posVars
maxX = model.addVar(vtype=GRB.INTEGER, name="maxX")
maxY = model.addVar(vtype=GRB.INTEGER, name="maxY")
for element in range(data.element_count):
model.addConstr(maxX >= R[element])
model.addConstr(maxY >= B[element])
OBJECTIVE_GRIDCOUNT = LinExpr(0.0)
for element in range(data.element_count):
OBJECTIVE_GRIDCOUNT.addTerms([1.0, 1.0], [LAG[element], TAG[element]])
OBJECTIVE_GRIDCOUNT.addTerms([1.0, 1.0], [BAG[element], RAG[element]])
OBJECTIVE_LT = LinExpr(0)
for element in range(data.element_count):
OBJECTIVE_LT.addTerms([1, 1, 2, 2, -1, -1],
[T[element], L[element], B[element], R[element], W[element], H[element]])
Objective = LinExpr(0)
Objective.add(OBJECTIVE_GRIDCOUNT, 1)
Objective.add(OBJECTIVE_LT, 0.001)
# Objective.add(maxX, 10)
# Objective.add(maxY, 10)
model.addConstr(OBJECTIVE_GRIDCOUNT >= (calculateLowerBound(N)))
model.setObjective(Objective, GRB.MINIMIZE)
return OBJECTIVE_GRIDCOUNT, OBJECTIVE_LT
class UraniumMineModel:
"""
This class represents the model for the uranium mine problem.
"""
def __init__(self,p: UraniumMineProblem):
self.p = p
self.m = Model('uranium')
# Decision variables
self.x = self.m.addVars(self.p.blocks,vtype=GRB.BINARY,name="x")
# Objective function
expr = quicksum([(p.values[b] - p.costs[b]) * self.x[b] for b in p.blocks])
self.m.setObjective(expr,sense=GRB.MAXIMIZE)
# Constraints
self.m.addConstrs(self.x[a] - self.x[b] <= 0 for (a,b) in p.precedences)
# Alternatively
#self.m.addConstrs(self.x[a] - self.x[b] <= 0 for a, b in p.precedences)
def solve(self):
self.m.optimize()
def printSolution(self):
print("Total profit ", self.m.ObjVal)
for b in self.p.blocks:
print("%s %g"%(self.x[b].varName,self.x[b].x))
class OSP:
def __init__(self, x: float):
self.m = Model()
self.y1 = self.m.addVar(name = "y1")
self.y2 = self.m.addVar(name = "y2")
# Objective function
self.m.setObjective(self.y1 + 3*self.y2, sense=GRB.MINIMIZE)
# Constraints
self.c1 = self.m.addConstr(2 * self.y1 + self.y2 == 1 - x)
self.c2 = self.m.addConstr(-self.y1 + self.y2 == 2 - 4 * x)
def solve(self):
self.m.optimize()
def get_results(self):
return self.m.objVal, self.c1.Pi, self.c2.Pi
def print_solution(self):
print('%s %g' % (self.y1.varName, self.y1.x))
print('%s %g' % (self.y2.varName, self.y2.x))
print('Obj: %g' % self.m.objVal)
def __init__(self, x):
self.m = Model()
self.y1 = self.m.addVar(name="y1")
self.y2 = self.m.addVar(name="y2")
self.v1 = self.m.addVar(name="v1")
self.v2 = self.m.addVar(name="v2")
self.v3 = self.m.addVar(name="v3")
self.v4 = self.m.addVar(name="v4")
# Objective function
self.m.setObjective(self.v1 + self.v2 + self.v3 + self.v4,
sense=GRB.MINIMIZE)
# Constraints
self.c1 = self.m.addConstr(2 * self.y1 + self.y2 + self.v1 -
self.v2 == (1 - x))
self.c2 = self.m.addConstr(-self.y1 + self.y2 + self.v3 -
self.v4 == (2 - 4 * x))
def __init__(self, fsp: FacilitySizingProblem, x: list):
self.fsp = fsp
self.m = Model()
# Creates the variables
y = self.m.addVars(fsp.n_facilities, fsp.n_customers, name="y")
# Creates the objective
expr = 0
for i in range(fsp.n_facilities):
for j in range(fsp.n_customers):
expr += fsp.delivery_costs[i][j] * y[i, j]
self.m.setObjective(expr, GRB.MINIMIZE)
# Constraints
self.capacity_constr = self.m.addConstrs(
y.sum(i, '*') <= x[i] for i in range(self.fsp.n_facilities))
self.demand_constr = self.m.addConstrs(
y.sum('*', j) >= fsp.demands[j] for j in range(fsp.n_customers))
def __init__(self, fsp: FacilitySizingProblem, x: list):
self.fsp = fsp
self.m = Model()
# Creates the variables
y = self.m.addVars(fsp.n_facilities, fsp.n_customers, name="y")
v1 = self.m.addVars(fsp.n_facilities, name="v+")
v2 = self.m.addVars(fsp.n_customers, name="v-")
# Creates the objective
expr = v1.sum() + v2.sum()
self.m.setObjective(expr, GRB.MINIMIZE)
# Constraints
self.demand_c = self.m.addConstrs(
y.sum('*', j) + v1[j] >= fsp.demands[j]
for j in range(fsp.n_customers))
self.capacity_c = self.m.addConstrs(
y.sum(i, '*') - v2[i] <= x[i] for i in range(fsp.n_facilities))
def __init__(self, fsp: FacilitySizingProblem):
self.fsp = fsp
self.m = Model()
# Creates the variables
self.x = self.m.addVars(fsp.n_facilities,
vtype=GRB.CONTINUOUS,
name="x")
self.phi = self.m.addVar(name="phi")
# Creates the objective
expr = self.phi + quicksum([
self.fsp.fixed_costs[i] * self.x[i]
for i in range(self.fsp.n_facilities)
])
self.m.setObjective(expr, GRB.MINIMIZE)
# Creates the constraints
self.m.addConstrs(self.x[i] <= self.fsp.capacity[i]
for i in range(fsp.n_facilities))
def __init__(self, flp: FacilityLocationProblem):
self.flp = flp
self.m = Model()
# Creates the variables
self.y = self.m.addVars(flp.n_facilities, flp.n_customers, name="y")
self.x = self.m.addVars(flp.n_facilities, vtype=GRB.BINARY, name="x")
# Creates the objective
expr = 0
for i in range(flp.n_facilities):
expr += flp.fixed_costs[i] * self.x[i]
for j in range(flp.n_customers):
expr += flp.delivery_costs[i][j] * self.y[i, j]
self.m.setObjective(expr, GRB.MINIMIZE)
# Constraints
for i in range(flp.n_facilities):
self.m.addConstr(self.y.sum(i, '*') <= flp.capacity[i] * self.x[i])
for j in range(flp.n_customers):
self.m.addConstr(self.y.sum('*', j) >= flp.demands[j])
class FSP:
def __init__(self, flp: FacilityLocationProblem, x: list):
self.flp = flp
self.m = Model()
# Creates the variables
y = self.m.addVars(flp.n_facilities, flp.n_customers, name="y")
v1 = self.m.addVars(flp.n_facilities, name="v+")
v2 = self.m.addVars(flp.n_customers, name="v-")
# Creates the objective
expr = 0
for i in range(flp.n_facilities):
expr += v1[i]
for j in range(flp.n_customers):
expr += v2[j]
self.m.setObjective(expr, GRB.MINIMIZE)
# Constraints
self.dc = []
self.cc = []
for i in range(flp.n_facilities):
print(x[i])
self.cc.append(
self.m.addConstr(
y.sum(i, '*') - v1[i] <= flp.capacity[i] * x[i]))
for j in range(flp.n_customers):
self.dc.append(
self.m.addConstr(y.sum('*', j) + v2[j] >= flp.demands[j]))
def solve(self):
self.m.optimize()
def getDuals(self):
dualsCC = self.m.getAttr(GRB.Attr.Pi, self.cc)
dualsDC = self.m.getAttr(GRB.Attr.Pi, self.dc)
return self.m.objVal, dualsCC, dualsDC
def __init__(self, pp: ProcurementProblem):
self.m = Model()
self.pp = pp
# Creates the variables
self.x = self.m.addVars(self.pp.n_materials, name="x")
# Creates the objective
# The expression is obtained by multiplying x to the costs dictionary.
# See the Gurobi docs for tupledic product here
# https://www.gurobi.com/documentation/8.1/refman/py_tupledict_prod.html
expr = self.x.prod(self.pp.costs)
self.m.setObjective(expr, GRB.MINIMIZE)
# Creates the constraints
self.m.addConstrs((self.x[i] <= self.pp.max_production[i]
for i in range(self.pp.n_materials)),
name='max_p')
self.m.addConstrs((self.x[i] >= self.pp.min_production[i]
for i in range(self.pp.n_materials)),
name='min_p')
self.m.addConstr(self.x.prod(self.pp.consumption) >= self.pp.demand)
class OSP:
def __init__(self, flp: FacilityLocationProblem, x: list):
self.flp = flp
self.m = Model()
# Creates the variables
y = self.m.addVars(flp.n_facilities, flp.n_customers, name="y")
# Creates the objective
expr = 0
for i in range(flp.n_facilities):
for j in range(flp.n_customers):
expr += flp.delivery_costs[i][j] * y[i, j]
self.m.setObjective(expr, GRB.MINIMIZE)
# Constraints
self.dc = []
self.cc = []
for i in range(flp.n_facilities):
self.cc.append(
self.m.addConstr(y.sum(i, '*') <= flp.capacity[i] * x[i]))
for j in range(flp.n_customers):
self.dc.append(self.m.addConstr(y.sum('*', j) >= flp.demands[j]))
def solve(self):
self.m.optimize()
def getResults(self):
dualsCC = self.m.getAttr(GRB.Attr.Pi, self.cc)
dualsDC = self.m.getAttr(GRB.Attr.Pi, self.dc)
return self.m.objVal, dualsCC, dualsDC
def write(self):
self.m.write("subproblem.lp")
class FullModel:
def __init__(self):
self.m = Model()
self.x = self.m.addVar(name="x")
self.y1 = self.m.addVar(name="y1")
self.y2 = self.m.addVar(name="y2")
# Objective function
self.m.setObjective(2 * self.x + self.y1 + 3 * self.y2,
sense=GRB.MINIMIZE)
# Constraints
self.m.addConstr(2 * self.y1 + self.y2 + self.x == 1)
self.m.addConstr(-self.y1 + self.y2 + 4 * self.x == 2)
def solve(self):
self.m.optimize()
def print_solution(self):
print('%s %g' % (self.x.varName, self.x.x))
print('%s %g' % (self.y1.varName, self.y1.x))
print('%s %g' % (self.y2.varName, self.y2.x))
print('Obj: %g' % self.m.objVal)
class OSP:
def __init__(self, fsp: FacilitySizingProblem, x: list):
self.fsp = fsp
self.m = Model()
# Creates the variables
y = self.m.addVars(fsp.n_facilities, fsp.n_customers, name="y")
# Creates the objective
expr = 0
for i in range(fsp.n_facilities):
for j in range(fsp.n_customers):
expr += fsp.delivery_costs[i][j] * y[i, j]
self.m.setObjective(expr, GRB.MINIMIZE)
# Constraints
self.capacity_constr = self.m.addConstrs(
y.sum(i, '*') <= x[i] for i in range(self.fsp.n_facilities))
self.demand_constr = self.m.addConstrs(
y.sum('*', j) >= fsp.demands[j] for j in range(fsp.n_customers))
def solve(self):
self.m.optimize()
def getResults(self):
'''
Returns, in this order,
1) the objective value,
2) the vector of optimal duals for the capacity constraints
3) the vector of optimal duals for the demand constraints
:return:
'''
print(self.capacity_constr)
dualsCC = self.m.getAttr(GRB.Attr.Pi, self.capacity_constr)
dualsDC = self.m.getAttr(GRB.Attr.Pi, self.demand_constr)
return self.m.objVal, dualsCC, dualsDC
class FSP:
def __init__(self, x):
self.m = Model()
self.y1 = self.m.addVar(name="y1")
self.y2 = self.m.addVar(name="y2")
self.v1 = self.m.addVar(name="v1")
self.v2 = self.m.addVar(name="v2")
self.v3 = self.m.addVar(name="v3")
self.v4 = self.m.addVar(name="v4")
# Objective function
self.m.setObjective(self.v1 + self.v2 + self.v3 + self.v4,
sense=GRB.MINIMIZE)
# Constraints
self.c1 = self.m.addConstr(2 * self.y1 + self.y2 + self.v1 -
self.v2 == (1 - x))
self.c2 = self.m.addConstr(-self.y1 + self.y2 + self.v3 -
self.v4 == (2 - 4 * x))
def solve(self):
self.m.optimize()
def get_results(self):
print(self.m.objVal, self.c1.Pi, self.c2.Pi)
return self.m.objVal, self.c1.Pi, self.c2.Pi
def print_solution(self):
print('%s %g' % (self.y1.varName, self.y1.x))
print('%s %g' % (self.y2.varName, self.y2.x))
print('%s %g' % (self.v1.varName, self.v1.x))
print('%s %g' % (self.v2.varName, self.v2.x))
print('%s %g' % (self.v3.varName, self.v3.x))
print('%s %g' % (self.v4.varName, self.v4.x))
print('Obj: %g' % self.m.objVal)
def __init__(self, supply, agents, approximator, log):
"""
:param b: b of LP. If n=len(agents) then the first n values are 1./alpha and n+1 value is supply/alpha.
:param agents: List of agents.
"""
# Setting up master problem
self.m = Model("master-problem")
self.m.params.LogToConsole = 0
# noinspection PyArgumentList,PyArgumentList,PyArgumentList
self.z = self.m.addVar(lb=-GRB.INFINITY, ub=GRB.INFINITY, name="z")
self.approximator = approximator
self.agents = agents
self.log = log
self.allocations = {'X0': Allocation()}
self.b = [(1. / self.approximator.gap) for i in range(0, len(self.agents))]
self.b.append(supply / self.approximator.gap)
# noinspection PyArgumentList,PyArgumentList,PyArgumentList
self.price_var = self.m.addVar(lb=-GRB.INFINITY, ub=0, name="price")
self.utility_vars = dict()
for agent in self.agents:
# noinspection PyArgumentList,PyArgumentList,PyArgumentList
self.utility_vars[agent.id] = self.m.addVar(lb=-GRB.INFINITY, ub=0, name="u_%s" % agent.id)
self.m.update()
# Initial constraints for empty allocation
self.add_benders_cut(Allocation(), "X0")
self.old_price_constraint = 0.
self.add_price_constraint(0.)
self.m.setObjective(self.z, GRB.MAXIMIZE)
self.price_changed = False
self.give_second_chance = True
self.old_z = 0.
self.old_utilities = dict()
def solve_restricted_primal(self, demands, demands_next, p):
self.obj = 0.
m = Model("multi-unit-auction")
# self.m.params.LogToConsole = 0
self.allocation_vars = dict()
for agent in self.agents:
for i in range(1, self.supply + 1):
self.allocation_vars[agent.id, i] = m.addVar(lb=0., ub=1., vtype=GRB.CONTINUOUS,
name='x_%s_%s' % (agent.id, i))
m.update()
for agent in self.agents:
if len(demands[agent.id]) > 0 and len(demands_next[agent.id]) > 0:
m.addConstr(quicksum(self.allocation_vars[agent.id, i] for i in range(1, self.supply + 1)),
GRB.EQUAL, 1, name="u_%s_strict" % agent.id)
else:
m.addConstr(quicksum(self.allocation_vars[agent.id, i] for i in range(1, self.supply + 1)),
GRB.LESS_EQUAL, 1, name="u_%s" % agent.id)
for j in range(1, self.supply + 1):
if j not in [demand.quantity for demand in demands[agent.id]]:
m.addConstr(self.allocation_vars[agent.id, j], GRB.EQUAL, 0, name='x_%s_%s_undemanded' % (agent.id, j))
if p > 0:
m.addConstr(
quicksum(self.allocation_vars[agent.id, i] * i for i in range(1, self.supply + 1) for agent in self.agents),
GRB.EQUAL, self.supply, name="price_strict")
else:
m.addConstr(
quicksum(self.allocation_vars[agent.id, i] * i for i in range(1, self.supply + 1) for agent in self.agents),
GRB.LESS_EQUAL, self.supply, name="price")
obj_expr = LinExpr()
for agent in self.agents:
for valuation in agent.valuations:
obj_expr.addTerms(valuation.quantity, self.allocation_vars[agent.id, valuation.quantity])
m.setObjective(obj_expr, GRB.MAXIMIZE)
m.update()
m.optimize()
m.write('optimal-lp.lp')
if m.status == GRB.OPTIMAL:
m.write('optimal-lp.sol')
for v in [v for v in m.getVars() if v.x != 0.]:
print('%s %g' % (v.varName, v.x))
print ''
print 'CONSTRAINTS:'
for l in m.getConstrs():
if l.Pi > 0:
print('%s %g' % (l.constrName, l.Pi))
print m.getObjective().getValue()
return m
from gurobipy.gurobipy import Model, GRB
__author__ = 'Usiel'
m = Model("play")
x11 = m.addVar(vtype=GRB.CONTINUOUS, name="x11", lb=0)
x12 = m.addVar(vtype=GRB.CONTINUOUS, name="x12")
x13 = m.addVar(vtype=GRB.CONTINUOUS, name="x13")
x14 = m.addVar(vtype=GRB.CONTINUOUS, name="x14")
x21 = m.addVar(vtype=GRB.CONTINUOUS, name="x21")
x22 = m.addVar(vtype=GRB.CONTINUOUS, name="x22")
x23 = m.addVar(vtype=GRB.CONTINUOUS, name="x23")
x24 = m.addVar(vtype=GRB.CONTINUOUS, name="x24")
m.update()
m.addConstr(x11 + x12 + x13 + x14 + x21 + x22 + x23 + x24, GRB.LESS_EQUAL, 2, name="all")
m.addConstr(x12, GRB.LESS_EQUAL, x11, name="c11")
m.addConstr(x13, GRB.LESS_EQUAL, x12, name="c12")
m.addConstr(x14, GRB.LESS_EQUAL, x13, name="c13")
m.addConstr(x22, GRB.LESS_EQUAL, x21, name="c21")
m.addConstr(x23, GRB.LESS_EQUAL, x22, name="c22")
m.addConstr(x24, GRB.LESS_EQUAL, x23, name="c23")
m.addConstr(x14, GRB.GREATER_EQUAL, 0, name="11")
m.addConstr(x24, GRB.GREATER_EQUAL, 0, name="12")
m.addConstr(x11, GRB.LESS_EQUAL, .5, name="u1")
m.addConstr(x21, GRB.LESS_EQUAL, .5, name="u2")
#m.addConstr(x11 + 2*x12 + 3*x13 + 4*x14 + x21 + 2*x22 + 3*x23 + 4*x24, GRB.LESS_EQUAL, 4, name="p_an")
m.setObjective(x11 * 6 + x12 * 0 + x13 * 0 + x14 * 3 + x21 * 1 + x22 * 3 + x23 * 0 + x24 * 2, GRB.MAXIMIZE)
def __init__(self, supply, agents, gap, restriced=False):
print ''
print 'Optimal Solver:'
self.m = Model("multi-unit-auction")
self.m.params.LogToConsole = 0
self.allocation_vars = dict()
for agent in agents:
for i in range(1, supply + 1):
self.allocation_vars[agent.id, i] = self.m.addVar(lb=0., ub=1., vtype=GRB.CONTINUOUS, name='x_%s_%s' % (agent.id, i))
self.m.update()
for agent in agents:
self.m.addConstr(quicksum(self.allocation_vars[agent.id, i] for i in range(1, supply + 1)), GRB.LESS_EQUAL, 1, name="u_%s" % agent.id)
if restriced:
for valuation in agent.valuations:
if valuation.valuation > 0:
self.m.addConstr(self.allocation_vars[agent.id, valuation.quantity] >= epsilon, name="not_zero_%s_%s" % (agent.id, valuation.quantity))
self.m.addConstr(quicksum(self.allocation_vars[agent.id, i]*i for i in range(1, supply + 1) for agent in agents), GRB.LESS_EQUAL, supply, name="price")
obj_expr = LinExpr()
for agent in agents:
for valuation in agent.valuations:
obj_expr.addTerms(valuation.valuation, self.allocation_vars[agent.id, valuation.quantity])
self.m.setObjective(obj_expr, GRB.MAXIMIZE)
self.m.update()
self.m.optimize()
#
# for agent in agents:
# for i in range(1, supply + 1):
# self.allocation_vars[agent.id, i] = self.m.addVar(vtype=GRB.CONTINUOUS, lb=0,
# name='x_%s_%s' % (agent.id, i))
#
# self.m.update()
#
# self.m.addConstr(quicksum(self.allocation_vars[agent.id, i] for i in range(1, supply + 1) for agent in agents),
# GRB.LESS_EQUAL, supply / gap, name="price")
# for agent in agents:
# for i in range(1, supply):
# self.m.addConstr(self.allocation_vars[agent.id, i + 1] - self.allocation_vars[agent.id, i],
# GRB.LESS_EQUAL, 0, name="chain_%s_%s" % (agent.id, i))
# self.m.addConstr(self.allocation_vars[agent.id, i], GRB.LESS_EQUAL, 1. / gap,
# name="p_%s_%s" % (agent.id, i))
# self.m.addConstr(self.allocation_vars[agent.id, supply], GRB.GREATER_EQUAL, 0, name="greater_%s" % agent.id)
# self.m.addConstr(self.allocation_vars[agent.id, 1], GRB.LESS_EQUAL, 1. / gap, name="u_%s" % agent.id)
#
# # m.addConstr(x11 + 2*x12 + 3*x13 + 4*x14 + x21 + 2*x22 + 3*x23 + 4*x24, GRB.LESS_EQUAL, 4, name="p_an")
#
# obj_expr = LinExpr()
# for agent in agents:
# prev_val = None
# for valuation in agent.valuations:
# try:
# prev_val = next(val for val in agent.valuations if val.quantity == valuation.quantity - 1)
# except StopIteration:
# pass
# marginal_value = valuation.valuation - (prev_val.valuation if prev_val else 0)
# obj_expr.addTerms(marginal_value, self.allocation_vars[agent.id, valuation.quantity])
# self.m.setObjective(obj_expr, GRB.MAXIMIZE)
#
# self.m.optimize()
for v in [v for v in self.m.getVars() if v.x != 0.]:
print('%s %g' % (v.varName, v.x))
print ''
print 'CONSTRAINTS:'
for l in self.m.getConstrs():
if l.Pi > 0:
print('%s %g' % (l.constrName, l.Pi))
print self.m.getObjective().getValue()
# print 'Optimal solution:'
# for v in self.m.getVars():
# print('%s %g' % (v.varName, v.x))
# for l in self.m.getConstrs():
# if l.Pi > 0:
# print('%s %g' % (l.constrName, l.Pi))
print 'OPT social welfare %s | %s/%s=%s' % (
self.m.getObjective().getValue(), self.m.getObjective().getValue(), gap,
self.m.getObjective().getValue() / gap)
self.m.write('optimal-lp.lp')
self.m.write('optimal-lp.sol')
class SolverGurobi(Solver):
def __init__(self):
Solver.__init__(self, GRB.BINARY, GRB.CONTINUOUS, GRB.INTEGER, GRB.OPTIMAL, GRB.INFEASIBLE, GRB.UNBOUNDED, GRB.INTERRUPTED, GRB.SUBOPTIMAL, GRB.EQUAL, GRB.LESS_EQUAL, GRB.GREATER_EQUAL, GRB.MAXIMIZE, GRB.MINIMIZE, GRB.INFINITY)
setParam('OutputFlag', 0)
setParam('IntFeasTol', 1e-9)
self.problem = Model('gurobi_problem')
def _add_variable(self, var):
if var.var_type == self.BINARY:
self.problem.addVar(name=var.name, vtype=var.var_type)
else:
self.problem.addVar(name=var.name, lb=var.lower_bound, ub=var.upper_bound, vtype=var.var_type)
def _del_variable(self, name):
self.problem.remove(self.problem.getVarByName(name))
def _add_constraint(self, const):
lhs = LinExpr()
for elem in const.lhs:
var = self.problem.getVarByName(elem.name)
lhs.add(var, elem.coefficient)
self.problem.addConstr(lhs, const.sense, const.rhs, const.name)
def _del_constraint(self, name):
self.problem.remove(self.problem.getConstrByName(name))
def update(self):
self.problem.update()
def _set_objective(self, objective):
expr = LinExpr()
for elem in objective.expr:
var = self.problem.getVarByName(elem.name)
expr.add(var, elem.coefficient)
self.problem.setObjective(expr, objective.sense)
def get_variable_value(self, name):
return self.problem.getVarByName(name).x
def get_objective_value(self):
return self.problem.objVal
def get_solution_status(self):
return self.problem.status
def _optimize(self):
self.problem.optimize()
def __init__(self):
Solver.__init__(self, GRB.BINARY, GRB.CONTINUOUS, GRB.INTEGER, GRB.OPTIMAL, GRB.INFEASIBLE, GRB.UNBOUNDED, GRB.INTERRUPTED, GRB.SUBOPTIMAL, GRB.EQUAL, GRB.LESS_EQUAL, GRB.GREATER_EQUAL, GRB.MAXIMIZE, GRB.MINIMIZE, GRB.INFINITY)
setParam('OutputFlag', 0)
setParam('IntFeasTol', 1e-9)
self.problem = Model('gurobi_problem')
('A', 'C', 'C_S1'),
('A', 'C', 'C_S2'),
('B', 'C', 'C_S2'),
('B', 'D', 'D_S2'),
('C', 'E', 'E_S2'),
('C', 'F', 'F_S1')
], columns=['kinase', 'substrate', 'site'])
sites, kinases, substrates = set(ks_network['site']), set(ks_network['kinase']), set(ks_network['substrate'])
in_edges, out_edges = set(ks_network['kinase'] + '_' + ks_network['site']), set(ks_network['site'] + '_' + ks_network['substrate'])
in_edges_costs = {edge: 1 / es for kinase, es in kinases_es.items() for edge in in_edges if edge.startswith(kinase)}
out_edges_costs = {edge: 1 / fc for site, fc in sites_fc.items() for edge in out_edges if edge.startswith(site)}
# Create problem
lp = Model('KS')
# Initialise nodes variables
for v in sites:
lp.addVar(vtype=GRB.BINARY, name=v)
for v in kinases:
lp.addVar(vtype=GRB.BINARY, name=v)
for v in substrates.difference(kinases):
lp.addVar(vtype=GRB.BINARY, name=v)
# Initialise edges variables
for edge in in_edges:
lp.addVar(vtype=GRB.BINARY, name=edge)
class BendersSolver:
def __init__(self, supply, agents, approximator, log):
"""
:param b: b of LP. If n=len(agents) then the first n values are 1./alpha and n+1 value is supply/alpha.
:param agents: List of agents.
"""
# Setting up master problem
self.m = Model("master-problem")
self.m.params.LogToConsole = 0
# noinspection PyArgumentList,PyArgumentList,PyArgumentList
self.z = self.m.addVar(lb=-GRB.INFINITY, ub=GRB.INFINITY, name="z")
self.approximator = approximator
self.agents = agents
self.log = log
self.allocations = {'X0': Allocation()}
self.b = [(1. / self.approximator.gap) for i in range(0, len(self.agents))]
self.b.append(supply / self.approximator.gap)
# noinspection PyArgumentList,PyArgumentList,PyArgumentList
self.price_var = self.m.addVar(lb=-GRB.INFINITY, ub=0, name="price")
self.utility_vars = dict()
for agent in self.agents:
# noinspection PyArgumentList,PyArgumentList,PyArgumentList
self.utility_vars[agent.id] = self.m.addVar(lb=-GRB.INFINITY, ub=0, name="u_%s" % agent.id)
self.m.update()
# Initial constraints for empty allocation
self.add_benders_cut(Allocation(), "X0")
self.old_price_constraint = 0.
self.add_price_constraint(0.)
self.m.setObjective(self.z, GRB.MAXIMIZE)
self.price_changed = False
self.give_second_chance = True
self.old_z = 0.
self.old_utilities = dict()
@property
def price(self):
"""
:return: Returns current price (positive).
"""
try:
return math.fabs(self.price_var.x)
except GurobiError:
return None
@property
def utilities(self):
"""
:return: Returns current utilities (positive): dict(agent_id: utility)
"""
return dict((v[0], math.fabs(v[1].x)) for v in self.utility_vars.iteritems())
@property
def objective(self):
try:
return self.z.x
except GurobiError:
return 0.
def solve(self):
while self.iterate():
pass
return self.allocations
def iterate(self):
"""
Performs one iteration of the Bender Auction. Optimizes current master problem, requests an approximate \
allocation based on current prices and utilities, calculates phi with current optimal values of master problem \
and then compares this with current z value.
:return: False if auction is done and True if a Bender's cut has been added and the auction continues.
"""
iteration = len(self.allocations)
self.log.log('')
self.log.log('######## ITERATION %s ########' % iteration)
self.optimize()
no_change = self.old_z == self.objective and all(
[any(old_utility == utility for old_utility in self.old_utilities) for utility in self.utilities])
self.log.log("no change ... %s" % no_change)
self.old_z = self.objective
self.old_utilities = self.utilities
# allocation := X
allocation = self.approximator.approximate(self.price, self.utilities)
# first_term - second_term = w*b - (c + wA) * X
# first_term is w*b
first_term = sum([-w * b for w, b in zip(self.utilities.values() + [self.price], self.b)])
# second_term is (c + wA) * X
second_term = 0
for assignment in allocation.assignments:
# for each x_ij which is 1 we generate c + wA which is (for MUA): v_i(j) + price * j + u_i
second_term += self.price * assignment.quantity
second_term += -self.utilities[assignment.agent_id]
second_term += assignment.valuation
phi = first_term - second_term
self.log.log('phi = %s - %s = %s' % (first_term, second_term, phi))
# check if phi with current result of master-problem is z (with tolerance)
if math.fabs(phi - self.z.x) < epsilon or iteration > iteration_abort_threshold:
self.remove_bad_cuts()
self.set_allocation_probabilities()
self.print_results()
return False
else:
self.give_second_chance = True
# otherwise continue and add cut based on this iteration's allocation
allocation_name = 'X%s' % iteration
self.allocations[allocation_name] = allocation
self.add_benders_cut(allocation, allocation_name)
self.set_allocation_probabilities()
return True
def add_price_constraint(self, new_price=None):
if True:
return None
try:
self.m.remove(self.m.getConstrByName("price_constraint"))
except GurobiError:
pass
if new_price != None:
self.old_price_constraint = new_price
else:
self.old_price_constraint -= .5
self.log.log(self.old_price_constraint)
self.m.addConstr(self.price_var, GRB.EQUAL, self.old_price_constraint, name="price_constraint")
def print_results(self):
"""
Prints results in console.
"""
self.log.log('')
self.log.log('####### SUMMARY #######')
self.log.log('')
self.m.write("master-program.lp")
for item in self.allocations.iteritems():
if item[1].probability > 0:
# noinspection PyArgumentList
self.log.log('%s (%s)' % (item[0], item[1].probability))
item[1].print_me(self.log)
self.log.log('')
if self.price_changed:
self.log.log('Price has decreased at some point.')
self.log.log('%s iterations needed' % len(self.allocations))
self.log.log('E[Social welfare] is %s' % -self.z.x)
def optimize(self):
"""
Optimizes current master-problem and outputs optimal values and dual variables
"""
# for observation we save the current price
current_price = self.price if self.price else 0.
self.m.optimize()
if current_price > self.price:
self.price_changed = True
for v in [v for v in self.m.getVars() if v.x != 0.]:
self.log.log('%s %g' % (v.varName, v.x))
for l in self.m.getConstrs():
if l.Pi > 0:
self.log.log('%s %g' % (l.constrName, l.Pi))
def remove_bad_cuts(self):
for l in self.m.getConstrs():
if l.Pi == 0:
self.m.remove(l)
def add_benders_cut(self, allocation, name):
"""
Adds another cut z <= wb - (c + wA) * X.
:param allocation: Allocation as list of Assignment.
:param name: Name for new constraint.
"""
# wb part of cut
expr = LinExpr(self.b, self.utility_vars.values() + [self.price_var])
for assignment in allocation.assignments:
# c
expr.addConstant(-assignment.valuation)
# if w=(u, p) then this is the uA part (for columns where X is 1)
expr.addTerms(-1, self.utility_vars[assignment.agent_id])
# if w=(u, p) then this is the pA part (for columns where X is 1)
expr.addTerms(-assignment.quantity, self.price_var)
# we get v_i(j) + u_i + j * price summed over all i,j where x_ij = 1
self.m.addConstr(self.z, GRB.LESS_EQUAL, expr, name=name)
def set_allocation_probabilities(self):
for item in self.allocations.iteritems():
# noinspection PyArgumentList
constraint = self.m.getConstrByName(item[0])
item[1].probability = constraint.pi if constraint else 0
def __init__(self, network):
self.lp = Model('PCST')
self.network = network
class PCST:
def __init__(self, network):
self.lp = Model('PCST')
self.network = network
def initialise(self):
# Initialise variables
for n in self.network.nodes.values():
n.var = self.lp.addVar(vtype=GRB.BINARY, name=n.id)
for e in self.network.edges.values():
e.var = self.lp.addVar(vtype=GRB.BINARY, name=e.id)
# Update variables
self.lp.update()
# Root restriction
lhs = LinExpr()
for root_out in self.network.out_edges(self.network.root.id):
lhs.addTerms(1, root_out.var)
self.lp.addConstr(lhs, GRB.EQUAL, 1)
# Income constraints
for n in self.network.nodes.values():
lhs = LinExpr()
for e in self.network.in_edges(n.id):
lhs.addTerms(1, e.var)
self.lp.addConstr(lhs, GRB.EQUAL, LinExpr(n.var))
# Reversibility constraint
for e in self.network.edges.values():
if e.inverse is not None:
lhs = LinExpr([1, 1], [e.var, self.network.get_edge(e.inverse).var])
self.lp.addConstr(lhs, GRB.LESS_EQUAL, self.network.get_node(e.source).var)
self.lp.addConstr(lhs, GRB.LESS_EQUAL, self.network.get_node(e.target).var)
for n in self.network.nodes.values():
if n.type == Type.LEAF or n.type == Type.LEAF_TERMINAL:
for in_edge in self.network.in_edges(n.id):
source = self.network.get_node(in_edge.source)
if source.type != Type.ROOT:
print n.id, in_edge.source
self.lp.addConstr(source.var, GRB.LESS_EQUAL, n.var)
def objective_function(self, beta=1):
# Set objective function
obj = LinExpr()
for e in self.network.edges.values():
obj.addTerms(e.value, e.var)
for n in self.network.nodes.values():
if n.type == Type.NORMAL:
obj.addTerms(-n.value * beta, n.var)
self.lp.setObjective(obj, GRB.MINIMIZE)
def optimise(self):
self.lp.optimize()
return self.get_solution()
def edge_sensitivity_analysis(self, solution):
scores = {}
for e in solution.edges.values():
edge_constraint = self.lp.addConstr(self.network.get_edge(e.id).var, GRB.EQUAL, 0)
scores[e.id] = self.optimise()
self.lp.remove(edge_constraint)
print '\n[INFO] Edge sensivity analysis done! ' + str(len(solution.edges)) + ' edges analysed.'
return scores
def get_solution(self):
edges = dict((e.id, Edge(e.source, e.target, self.lp.getVarByName(e.id).x)) for e in self.network.edges.values() if self.lp.getVarByName(e.id).x > 0.9999)
obj_val = self.lp.objVal
return Solution(edges, obj_val)
def get_obj_value(self):
return self.lp.objVal
def print_solution(self):
for v in self.lp.getVars():
print v.varName, v.x
print 'Obj:', self.lp.objVal
__author__ = 'emanuel'
from gurobipy.gurobipy import GRB, Model, GurobiError
try:
# Create model
m = Model('test')
# Create variables
x = m.addVar(vtype=GRB.BINARY, name='x')
y = m.addVar(vtype=GRB.BINARY, name='y')
z = m.addVar(vtype=GRB.BINARY, name='z')
# Integrate new variables
m.update()
# Set objective function
m.setObjective(x + y + 2 * z, GRB.MAXIMIZE)
# Add constraints
m.addConstr(x + 2 * y + 3 * z <= 4, 'c0')
m.addConstr(x + y >= 1, 'c1')
m.optimize()
for v in m.getVars():
print v.varName, v.x
print 'Obj:', m.objVal
except GurobiError:
