def _initialize_model(self):
problem = Model()
problem.setParam('OutputFlag', False)
# edges from source to reviewers, capacity controls maximum reviewer load
self._source_vars = problem.addVars(self.numrev, vtype=GRB.CONTINUOUS, lb=0.0,
ub=self.ability, name='reviewers')
# edges from papers to sink, capacity controls a number of reviewers per paper
self._sink_vars = problem.addVars(self.numpapers, vtype=GRB.CONTINUOUS, lb=0.0,
ub=self.demand, name='papers')
# edges between reviewers and papers. Initially capacities are set to 0 (no edge is added in the network)
self._mix_vars = problem.addVars(self.numrev, self.numpapers, vtype=GRB.CONTINUOUS,
lb=0.0, ub=0.0, name='assignment')
problem.update()
# flow balance equations for reviewers' nodes
self._balance_reviewers = problem.addConstrs((self._source_vars[i] == self._mix_vars.sum(i, '*')
for i in range(self.numrev)))
# flow balance equations for papers' nodes
self._balance_papers = problem.addConstrs((self._sink_vars[i] == self._mix_vars.sum('*', i)
for i in range(self.numpapers)))
problem.update()
self._problem = problem
def _create_model(self, city_ids, map_points):
depot_id = city_ids[0]
city_num = len(city_ids)
## prepare the index for decision variables
# index of network flow
cities = tuple(city_ids)
# index of MTZ constraint
MTZ_u = tuple(city_ids[1:])
# connecting arcs of the cities
cityArcs = [(i,j) for i in cities for j in cities if i != j]
## parameters model (dictionary)
# 1. distance map
distances_map = self.calculate_distances(city_ids, map_points)
## create model
m = Model('TSP')
## create decision variables
# 1. choice of arcs between cities
x = m.addVars(cityArcs, vtype=GRB.BINARY, name='route')
# 2. for expression of non-subtour: [2,N]
u = m.addVars(MTZ_u, name='MTZ_u')
## create objective: minimum route distance
m.setObjective(quicksum([x[i,j]*distances_map[(i,j)] for (i,j) in cityArcs]), GRB.MINIMIZE) # TOTRY
## create constraints
# 1. MTZ formulation
m.addConstrs((u[i]-u[j]+city_num*x[i,j] <= city_num-1 for (i,j) in cityArcs if (i>depot_id and j>depot_id)),'MTZ formulation')
m.addConstrs((u[i]>=0 and u[i]<=city_num-1 for i in MTZ_u), 'MTZ compensation')
# 2. Network flow
m.addConstrs((quicksum([x[i,j] for j in cities if i!=j])==1 for i in cities), 'Network flow1')
m.addConstrs((quicksum([x[i,j] for i in cities if i!=j])==1 for j in cities), 'Network flow2')
return m, x
def generate_row_model(row_matrix, b, v, c):
"""
rows_matrix: The matrix, represented as a list of rows
b: List of variables in b
v: The target vector
c: The weights of each column
"""
# Initializes a model
mdl = Model('persistenthomologylocalization')
# Add matrix variables
x = mdl.addVars(list(b), vtype=GRB.BINARY)
# Add the dummy variable needed to do arithmetics mod 2
y = mdl.addVars(list(range(len(row_matrix))), vtype=GRB.INTEGER)
# Set model to minimization
mdl.modelSense = GRB.MINIMIZE
# Set objective function to minimize
mdl.setObjective(quicksum(x[j] * c[j] for j in b))
# Set the constrains
for i in list(range(len(row_matrix))):
mdl.addConstr(quicksum(x[j] for j in row_matrix[i]) + v[i] == y[i] * 2)
return mdl, x, y
def TWTgurobi():
jobs = tuple(range(1,5))
jobPairs = [(i,j) for i in jobs for j in jobs if i < j]
# job_id as keys and weight as content
weight = dict(zip(jobs, (4,3,4,5)))
duration = dict(zip(jobs, (12,8,15,9)))
deadline = dict(zip(jobs, (16,26,25,27)))
# Big M for modeling
M = sum(duration.values())
try:
m = Model('TWTexample')
x = m.addVars(jobPairs, vtype=GRB.BINARY, name='x')
startTime = m.addVars(jobs, name='startTime')
tardiness = m.addVars(jobs, name='tardiness')
m.setObjective(quicksum([weight[j]*tardiness[j] for j in jobs]), GRB.MINIMIZE)
m.addConstrs((startTime[j] >= startTime[i]+duration[i]-M*(1-x[i,j]) for(i,j) in jobPairs), 'NoOverplap1')
m.addConstrs((startTime[i] >= startTime[j]+duration[j]-M*x[i,j] for(i,j) in jobPairs), 'NoOverplap2')
m.addConstrs((tardiness[j] >= startTime[j]+duration[j]-deadline[j] for j in jobs), 'Deadline')
m.optimize()
if m.status == GRB.Status.INF_OR_UNBD:
m.setParam(GRB.Param.DualReductions, 0)
m.optimize()
if m.status == GRB.Status.OPTIMAL:
for v in m.getVars():
print('%s:\t%g' %(v.varName, v.x))
print('Objective:\t%g' % m.objVal)
else:
statstr = StatusDict[m.status]
print('Optimization was stopped with status %s' %statstr)
except GurobiError as e:
print('Error code '+str(e.errno)+': '+str(e))
def max_return(r, risk_threshold, cvar_alpha=0.95):
r_bar = np.mean(r, axis=0)
cov = np.cov(r, rowvar=False)
n = len(r)
k = len(r[0])
m = Model('opt_profolio')
m.params.OutputFlag = 0
m.params.NumericFocus = 3
x = m.addVars(k, lb=0, ub=1, vtype=GRB.CONTINUOUS, name='x')
z = m.addVars(n, lb=0, vtype=GRB.CONTINUOUS, name='z')
eta = m.addVar(lb=-GRB.INFINITY, vtype=GRB.CONTINUOUS, name='eta')
m.update()
#Portfolio contraint
m.addConstr((x.sum() == 1), 'portfolio_ctr')
#Risk constraint
m.addConstr(
(eta + (1.0 / (n * (1 - cvar_alpha))) * z.sum() <= risk_threshold),
'cvar_ctr')
#CVaR linearlization
m.addConstrs((z[i] >= quicksum(-r[i, j] * x[j] for j in range(k)) - eta
for i in range(n)), 'cvar_linear')
m.setObjective(quicksum(r_bar[j] * x[j] for j in range(k)), GRB.MAXIMIZE)
m.update()
m.optimize()
x_sol = np.array([x[j].X for j in range(k)])
p_mean = r_bar.dot(x_sol)
p_var = x_sol.dot(cov.dot(x_sol))
cvar_loss = (eta + (1.0 / (n * (1 - cvar_alpha))) * z.sum()).getValue()
#print(m.status, eta.X, (-1+(1+eta.X)**365), cvar_loss , (-1+(1+cvar_loss)**365))
return x_sol, p_mean, p_var
def solve():
model = Model("Enigma Riddle")
letters = {"E", "N", "I", "G", "M", "A"}
digits = range(1, 10)
x = model.addVars(letters, digits, vtype=GRB.BINARY)
y = model.addVars(letters, vtype=GRB.INTEGER)
# Stay in digit range
for i in letters:
model.addRange(y[i], 1, 9, f"digitRange{i}")
# Final value for first word
b = model.addVar(vtype=GRB.INTEGER)
first_word = "ENIGMA"
second_word = "IGMAEN"
# Constraint for the enigma-igmaen numbers
model.addConstr(quicksum(10 ** (len(first_word) - 1 - i) * y[first_word[i]] for i in range(len(first_word))) == b)
model.addConstr(
quicksum(10 ** (len(second_word) - 1 - i) * y[second_word[i]] for i in range(len(second_word))) == b * 1.2)
# Conflict constraint
model.addConstrs(x[i_1, j] + x[i_2, j] <= 1 for i_1 in letters for i_2 in letters for j in digits if i_1 != i_2)
# Linking constraint
model.addConstrs(j * x[i, j] <= y[i] for i in letters for j in digits)
# Exactly one digit has to be packed
model.addConstrs(quicksum(x[i, j] for j in digits) == 1 for i in letters)
model.optimize()
return model
def rocket():
from gurobipy import Model, GRB
# Set up data
Mass = [
70, 90, 100, 110, 120, 130, 150, 180, 210, 220, 250, 280, 340, 350, 400
]
P = range(len(Mass))
# A, B, C, D
Sections = ["A", "B", "C", "D"]
S = range(len(Sections))
m = Model('Rocket Payload')
X = m.addVars(P, S, vtype=GRB.BINARY, name='X')
Y = m.addVars(P, S, name='Y', obj=1)
m.addConstrs(Y[p, s] == X[p, s] * Mass[p] for p, s in X.keys())
m.addConstrs(Y.sum('*', s) <= 1000 for s in S)
m.addConstrs(X.sum('*', s) >= 3 for s in S)
m.addConstr(Y.sum('*', 0) == Y.sum('*', 3))
m.addConstr(Y.sum('*', 1) == Y.sum('*', 2))
m.setAttr(GRB.Attr.ModelSense, GRB.MAXIMIZE)
m.optimize()
def stage_prob_builder(t):
model = Model('CapExp%i' % t) # Create a model
x = model.addVars(data.I, vtype=GRB.CONTINUOUS, lb=0, ub=data.b, obj=1, name='x')
x0 = model.addVars(data.I, vtype=GRB.CONTINUOUS, lb=0, ub=data.b, obj=0, name='x0')
d = model.addVars(data.J, vtype=GRB.CONTINUOUS, lb=0, ub=0, obj=0, name='d')
model.update()
if t == 0:
# y = model.addVars(data.I, lb=0, ub=1, obj=5, vtype=GRB.BINARY, name='y')
# model.addConstrs((x[i] <= data.b * y[i] for i in data.I), 'logic_open')
model.addConstr(sum(x[i] for i in data.I), GRB.LESS_EQUAL, data.b, 'globalCap')
model.update()
else:
y = model.addVars(data.I, data.J, lb=0, obj=data.c, vtype=GRB.CONTINUOUS, name='y')
s = model.addVars(data.J, lb=0, obj=data.rho, vtype=GRB.CONTINUOUS, name='s')
model.update()
'''Capacity constraints'''
model.addConstrs((sum(y[i, j] for j in data.J) <= x0[i] for i in data.I), 'CapCtr')
'''Recourse constraint, subcontracting '''
model.addConstrs((sum(y[i, j] for i in data.I) + s[j] >= d[j] for j in data.J), 'RecCtr')
model.update()
in_states = [var.VarName for var in x0.values()]
out_states = [var.VarName for var in x.values()]
rhs_vars = [var.VarName for var in d.values()]
return model, in_states, out_states, rhs_vars
def polytopic_trajectory_given_modes(x0,list_of_cells,goal,eps=0,order=1):
"""
Description:
Polytopic Trajectory Optimization with the ordered list of polytopes given
This is a convex program as mode sequence is already given
list_of_cells: each cell has the following attributes: A,B,c, and polytope(H,h)
"""
model=Model("Fixed Mode Polytopic Trajectory")
T=len(list_of_cells)
n,m=list_of_cells[0].B.shape
q=int(order*n)
x=model.addVars(range(T+1),range(n),lb=-GRB.INFINITY,ub=GRB.INFINITY,name="x")
u=model.addVars(range(T),range(m),lb=-GRB.INFINITY,ub=GRB.INFINITY,name="u")
G=model.addVars(range(T+1),range(n),range(q),lb=-GRB.INFINITY,ub=GRB.INFINITY,name="G")
theta=model.addVars(range(T),range(m),range(q),lb=-GRB.INFINITY,ub=GRB.INFINITY,name="theta")
model.update()
for j in range(n):
model.addConstr(x[0,j]<=x0[j,0]+eps)
model.addConstr(x[0,j]>=x0[j,0]-eps)
for t in range(T):
print "adding constraints of t",t
cell=list_of_cells[t]
A,B,c,p=cell.A,cell.B,cell.c,cell.p
for j in range(n):
expr_x=LinExpr([(A[j,k],x[t,k]) for k in range(n)])
expr_u=LinExpr([(B[j,k],u[t,k]) for k in range(m)])
model.addConstr(x[t+1,j]==expr_x+expr_u+c[j,0])
for i in range(n):
for j in range(q):
expr_x=LinExpr([(A[i,k],G[t,k,j]) for k in range(n)])
expr_u=LinExpr([(B[i,k],theta[t,k,j]) for k in range(m)])
model.addConstr(G[t+1,i,j]==expr_x+expr_u)
x_t=np.array([x[t,j] for j in range(n)]).reshape(n,1)
u_t=np.array([u[t,j] for j in range(m)]).reshape(m,1)
G_t=np.array([G[t,i,j] for i in range(n) for j in range(q)]).reshape(n,q)
theta_t=np.array([theta[t,i,j] for i in range(m) for j in range(q)]).reshape(m,q)
GT=sp.linalg.block_diag(G_t,theta_t)
xu=np.vstack((x_t,u_t))
subset_LP(model,xu,GT,Ball(2*q),p)
x_T=np.array([x[T,j] for j in range(n)]).reshape(n,1)
G_T=np.array([G[T,i,j] for i in range(n) for j in range(q)]).reshape(n,q)
z=zonotope(x_T,G_T)
subset_zonotopes(model,z,goal)
J=LinExpr([(1/(t+1.0),G[t,i,i]) for t in range(T+1) for i in range(n)])
model.setObjective(J)
model.write("sadra.lp")
model.setParam('TimeLimit', 150)
model.optimize()
x_num,G_num={},{}
for t in range(T+1):
x_num[t]=np.array([[x[t,j].X] for j in range(n)]).reshape(n,1)
G_num[t]=np.array([[G[t,i,j].X] for i in range(n) for j in range(q)]).reshape(n,q)
return (x_num,G_num)
class mip_model(object):
def __init__(self, samples, delta=1.0):
self.n_nodes = samples.n_nodes
self.n_samples = samples.n_samples
self.delta = delta
self.B = samples.B
self.T = samples.T
self.F = samples.F
self.model = Model('DPSL')
self.create_model()
def create_model(self):
self.U = self.model.addVars(self.n_nodes,
self.n_samples,
name='U', lb=0, ub=1,
vtype=GRB.CONTINUOUS)
self.M = self.model.addVars(self.n_nodes,
name='M', lb=0, ub=1,
vtype=GRB.CONTINUOUS)
self.y = self.model.addVars(self.n_nodes,
self.n_samples,
name='y', lb=0, ub=1,
vtype=GRB.CONTINUOUS)
self.z = self.model.addVars(self.n_nodes,
self.n_nodes,
self.n_samples,
name='z', lb=0, ub=1,
vtype=GRB.CONTINUOUS)
self.model.addConstrs((self.y[i, n] >= -1 + self.M[i]
+ self.B[i, n]
- self.U[i, n])
for i in range(self.n_nodes)
for n in range(self.n_samples))
self.model.addConstrs((self.z[i, j, n] >= -2 + self.T[i, j, n]
+ self.F[i, j, n]
+ self.U[j, n]
- self.U[i, n])
for i in range(self.n_nodes)
for j in range(self.n_nodes)
for n in range(self.n_samples)
if i != j)
cost_expr = 2 * self.M.sum() - (5 / self.n_samples) * self.U.sum()
dist_expr = self.y.sum() + self.z.sum() + self.U.sum()
self.model.setObjective(cost_expr + self.delta * dist_expr,
GRB.MINIMIZE)
def solve(self):
self.model.optimize()
for i in range(self.n_nodes):
print(self.M[i].x)
class optimization_model:
def __init__(self, scenario):
self.scenario = scenario
self.model = Model('network_optimization')
def create_start_time_variables(self):
self.S = self.model.addVars(self.scenario.settings.number_of_tasks,
vtype = GRB.INTEGER,
lb = 0,
ub = self.scenario.settings.number_of_time_periods,
name = 'S')
def create_end_time_variables(self):
self.C = self.model.addVars(self.scenario.settings.number_of_tasks,
vtype = GRB.INTEGER,
lb = 0,
ub = self.scenario.settings.number_of_time_periods,
name = 'C')
def create_work_time_variables(self):
self.X = self.model.addVars(self.scenario.settings.number_of_tasks,self.scenario.settings.number_of_modes,self.scenario.settings.number_of_time_periods,
vtype = GRB.BINARY,
name = 'X')
def create_tech_assignment_variables(self):
self.V = self.model.addVars(self.scenario.settings.number_of_techs,self.scenario.settings.number_of_tasks,self.scenario.settings.number_of_time_periods,
vtype = GRB.BINARY,
name = 'V')
def add_precedence_constraints(self):
for task in self.scenario.task_list:
for successor in task.successor_list:
self.model.addConstr(self.S[successor] - self.C[task.task_index],
GRB.GREATER_EQUAL,
1,
name = "Precedence.%d.%d" % (successor,task.task_index))
def set_objective_makespan(self):
self.model.setObjective(self.C[self.scenario.task_list[-1].task_index],
sense = GRB.MINIMIZE)
def create_model_variables(self):
self.create_start_time_variables()
self.create_end_time_variables()
self.create_work_time_variables()
self.create_tech_assignment_variables()
def add_model_constraints(self):
self.add_precedence_constraints()
def set_model_objective(self):
self.set_objective_makespan()
def write_model(self):
self.model.write("/Users/yashpatil/Desktop/Personal Github Projects/Multimode_Network_Assignment/model_optimizationFiles/model_formulation.lp")
def TWTgurobi():
# TWT Problem Data
jobs = tuple([i + 1 for i in range(4)])
jobPairs = [(i, j) for i in jobs for j in jobs if i < j]
weight = dict(zip(jobs, (4, 5, 3, 5)))
duration = dict(zip(jobs, (12, 8, 15, 9)))
deadline = dict(zip(jobs, (16, 26, 25, 27)))
M = sum(duration.values())
try:
# Create a new model
m = Model('TWTexample')
# Create variables
# x[(i,j)] = 1 if i << j, else j >> i
x = m.addVars(jobPairs, vtype=GRB.BINARY, name='x')
startTime = m.addVars(jobs, name='startTime')
tardiness = m.addVars(jobs, name='tardiness')
# Set objective function
m.setObjective(quicksum([weight[j] * tardiness[j] for j in jobs]),
GRB.MINIMIZE)
# Add constraints
m.addConstrs(
(startTime[j] >= startTime[i] + duration[i] - M * (1 - x[(i, j)])
for (i, j) in jobPairs), 'NoOverlap1')
m.addConstrs(
(startTime[i] >= startTime[j] + duration[j] - M * x[(i, j)]
for (i, j) in jobPairs), 'NoOverlap2')
m.addConstrs((tardiness[j] >= startTime[j] + duration[j] - deadline[j]
for j in jobs), 'Deadline')
# Solve model
m.optimize()
if m.status == GRB.Status.INF_OR_UNBD:
# Disable dual reductions to determine solve status
m.setParam(GRB.Param.DualReductions, 0)
m.optimize()
# Display solution
if m.status == GRB.Status.OPTIMAL:
for v in m.getVars():
print('%s:\t%g' % (v.varName, v.x))
print('Objective:\t%g' % m.objVal)
else:
statstr = StatusDict[m.status]
print('Optimization was stopped with status %s' % statstr)
except GurobiError as e:
print('Error code ' + str(e.errno) + ": " + str(e))
def point_trajectory_given_modes_and_central_traj(x_traj,list_of_cells,goal,eps=0,scale=[]):
"""
Description:
Point Trajectory Optimization with the ordered list of polytopes given
This is a convex program as mode sequence is already given
list_of_cells: each cell has the following attributes: A,B,c, and polytope(H,h)
"""
model=Model("Fixed Mode Polytopic Trajectory")
T=len(list_of_cells)
n,m=list_of_cells[0].B.shape
x=model.addVars(range(T+1),range(n),lb=-GRB.INFINITY,ub=GRB.INFINITY,name="x")
u=model.addVars(range(T),range(m),lb=-GRB.INFINITY,ub=GRB.INFINITY,name="u")
model.update()
if len(scale)==0:
scale=np.ones(x_traj[0].shape[0])
print "inside function epsilon is",eps
for j in range(n):
model.addConstr(x[0,j]<=x_traj[0][j]+eps*scale[j])
model.addConstr(x[0,j]>=x_traj[0][j]-eps*scale[j])
for t in range(T):
cell=list_of_cells[t]
A,B,c,_p=cell.A,cell.B,cell.c,cell.p
for j in range(n):
expr_x=LinExpr([(A[j,k],x[t,k]) for k in range(n)])
expr_u=LinExpr([(B[j,k],u[t,k]) for k in range(m)])
model.addConstr(x[t+1,j]==expr_x+expr_u+c[j,0])
x_t=np.array([x[t,j] for j in range(n)]).reshape(n,1)
u_t=np.array([u[t,j] for j in range(m)]).reshape(m,1)
xu=np.vstack((x_t,u_t))
subset_LP(model,xu,np.zeros((n+m,1)),Ball(1),_p)
x_T=np.array([x[T,j] for j in range(n)]).reshape(n,1)
z=zonotope(x_T,np.zeros((n,1)))
subset_generic(model,z,goal)
# Cost function
J=QuadExpr()
for t in range(T):
for i in range(n):
J.add(x[t,i]*x[t,i]-x[t,i]*x_traj[t][i])
model.setObjective(J)
model.write("polytopic_trajectory.lp")
model.setParam('TimeLimit', 150)
model.optimize()
x_num,u_num={},{}
for t in range(T+1):
x_num[t]=np.array([[x[t,j].X] for j in range(n)])
for t in range(T):
u_num[t]=np.array([[u[t,i].X] for i in range(m) ])
return (x_num,u_num)
def RCI(sys, q=0, alpha=0, K=5):
"""
Computes a Robust Control Invariant (RCI) set for LTI system sys
"""
q = K * sys.n if q == 0 else q
model = Model("RCI")
phi = tupledict_to_array(
model.addVars(range(sys.n),
range(q),
lb=-GRB.INFINITY,
ub=GRB.INFINITY,
name="phi"))
theta = tupledict_to_array(
model.addVars(range(sys.m),
range(q),
lb=-GRB.INFINITY,
ub=GRB.INFINITY,
name="theta"))
psi = tupledict_to_array(
model.addVars(range(sys.n),
range(sys.w),
lb=-GRB.INFINITY,
ub=GRB.INFINITY,
name="psi"))
model.update()
_fat_matrix = np.hstack((psi, phi))
constraints_list_of_tuples(model, [(sys.A, phi), (sys.B, theta),
(-np.eye(sys.n), _fat_matrix[:, 0:q])],
"=")
constraints_list_of_tuples(model,
[(np.eye(sys.n), sys.W),
(-np.eye(sys.n), _fat_matrix[:, q:q + sys.w])],
"=")
_outer = zonotope(np.zeros((sys.n, 1)), sys.W * alpha)
_inner = zonotope(np.zeros((sys.n, 1)), psi)
subset_generic(model, _inner, _outer)
if sys.X != None:
sys.X.G *= (1 - alpha)
subset_generic(model, zonotope(np.zeros((sys.n, 1)), phi), sys.X)
if sys.U != None:
sys.U.G *= (1 - alpha)
subset_generic(model, zonotope(np.zeros((sys.m, 1)), theta), sys.U)
model.optimize()
phi_n = np.array([[phi[i, j].X for i in range(phi.shape[0])]
for j in range(phi.shape[1])]).T
theta_n = np.array([[theta[i, j].X for i in range(theta.shape[0])]
for j in range(theta.shape[1])]).T
# psi_n=np.array([[psi[i,j].X for i in range(psi.shape[0])] for j in range(psi.shape[1])]).T
sys.phi = phi_n * 1.0 / (1 - alpha)
sys.theta = theta_n * 1.0 / (1 - alpha)
return phi_n, theta_n
def solve():
model = Model("Enigma Riddle Binary Program")
letters = {"E", "N", "I", "G", "M", "A"}
digits = range(1, 10)
# x[i, j] == 1 => Letter i uses digit j
x = model.addVars(letters,
digits,
vtype=GRB.BINARY,
name=(f"x[{l},{d}]" for l in letters for d in digits))
# Final value for first word
first_word = "ENIGMA"
second_word = "IGMAEN"
factor = 1.2
# Constraint for the enigma-igmaen numbers
model.addConstr(factor * quicksum(
quicksum(10**(len(first_word) - 1 - i) * j * x[first_word[i], j]
for j in digits)
for i in range(len(first_word))) - quicksum(
quicksum(10**(len(second_word) - 1 - i) * j * x[second_word[i], j]
for j in digits) for i in range(len(second_word))) == 0)
# Conflict constraint, different letters have different digits
model.addConstrs(quicksum(x[i, j] for i in letters) <= 1 for j in digits)
# Exactly one digit has to be used per letter
model.addConstrs(quicksum(x[i, j] for j in digits) == 1 for i in letters)
model.optimize()
return model
def _construct_max_flow_lp(self, G, edge_to_paths, num_total_paths):
m = Model('max-flow')
# Create variables: one for each path
path_vars = m.addVars(num_total_paths,
vtype=GRB.CONTINUOUS,
lb=0.0,
name='f')
obj = quicksum(path_vars)
m.setObjective(obj, GRB.MAXIMIZE)
# Add demand constraints
commod_id_to_path_inds = {}
for k, d_k, path_inds in self.commodities:
commod_id_to_path_inds[k] = path_inds
m.addConstr(quicksum(path_vars[p] for p in path_inds) <= d_k)
# Add edge capacity constraints
for u, v, c_e in G.edges.data('capacity'):
paths = edge_to_paths[(u, v)]
constr_vars = [path_vars[p] for p in paths]
m.addConstr(quicksum(constr_vars) <= c_e)
return LpSolver(m, None, self.DEBUG, self.VERBOSE, self.out)
def initialize_model(cost_matrix, cutoff, model=None):
#Add dummy detection
cost_matrix = np.insert(cost_matrix,
0,
np.ones(cost_matrix.shape[0]) * cutoff,
axis=1)
M, N = cost_matrix.shape
if model is None:
model = Model()
else:
model.remove(model.getVars())
model.remove(model.getConstrs())
model.setParam('OutputFlag', False)
# y = []
# for i in range(M):
# y.append([])
# for j in range(N):
# y[i].append(m.addVar(vtype=GRB.BINARY, name = 'y_%d%d'%(i,j)))
y = model.addVars(M, N, vtype=GRB.BINARY, name='y')
model.setObjective(
quicksum(
quicksum([y[i, j] * cost_matrix[i][j] for j in range(N)])
for i in range(M)), GRB.MINIMIZE)
# for i in range(M):
model.addConstrs(
(quicksum(y[i, j] for j in range(N)) == 1 for i in range(M)),
name='constraint for track')
# for j in range(1,N):
model.addConstrs(
(quicksum(y[i, j] for i in range(M)) <= 1 for j in range(1, N)),
name='constraint for detection')
y = list(y.values())
return model, M, N, y
def optimize_pareto(Bw, h, ju_s, ju_l, jn_s, jn_l):
# create a model
m = Model('Pareto')
# create decision variables
x = m.addVars(an, an, vtype=GRB.BINARY, name='x')
y = m.addVars(an, dc, vtype=GRB.BINARY, name='y')
######### add constraints ##########
m.addConstrs((x[i, j] == x[j, i] for i in an for j in an),
'symmetric constraint')
# Two service areas cant use the same stateful functions when x[i,j] = 0
m.addConstrs((y[i, t] + y[j, t] <= x[i, j] + 1 for i in an for j in an
for t in dc), 'x = 0 constraint')
# Two service areas use the same stateful functions when x[i,j] = 1
m.addConstrs(((y[i, t] - y[j, t] <= 1 - x[i, j]) for i in an for j in an
for t in dc), 'x = 1 constraint')
# Each should be at least managed by one dc
m.addConstrs((sum(y[i, t] for t in dc) == 1 for i in an),
'one dc for access node')
# high availability constraint
m.addConstr(
sum((1 - x[i, j]) for i in an for j in an if i != j) >= 1, 'ha')
# maximum state transfer frequency
m.addConstr(
sum(h * (1 - x[i, j]) for i in an for j in an if i != j) <= jn_s - 1,
'max state transfer constraint')
# maximum latency constraint
m.addConstr(
sum(y[i, t] * C[i, t] * (Sd / Bw + Lw + Wg) for i in an
for t in dc) <= jn_l, 'latency maximum constraint')
######## Objective function #########
m.setObjective((sum(y[i, t] * C[i, t] * (Sd / Bw + Lw + Wg) for i in an
for t in dc) - ju_l) / (jn_l - ju_l) +
(sum(h * (1 - x[i, j]) for i in an
for j in an if i != j) - ju_s) / (jn_s - ju_s),
GRB.MINIMIZE)
m.optimize()
######## Calculate performance metrics #########
# latency
latency = sum(C[i, t] * getattr(y[i, t], 'X') * (Sd / Bw + Lw + Wg)
for i in an for t in dc)
# state transfer frequency
state_transfer = sum(h * (1 - getattr(x[i, j], 'X')) for i in an
for j in an if i != j)
# total cost
cost = latency + state_transfer
# number of functions
num_func = M_dc - sum(
prod(1 - getattr(y[i, t], 'X') for i in an) for t in dc)
# total metrics
total_metrics = [Bw, h, state_transfer, latency, num_func, cost]
return total_metrics
def optimize_latency(Bw, h):
# create a model
m = Model('latency')
# create decision variables
x = m.addVars(an, an, vtype=GRB.BINARY, name='x')
y = m.addVars(an, dc, vtype=GRB.BINARY, name='y')
######### add constraints ##########
# x is symmetric
m.addConstrs((x[i, j] == x[j, i] for i in an for j in an),
'symmetric constraint')
# Two service areas cant use the same stateful functions when x[i,j] = 0
m.addConstrs((y[i, t] + y[j, t] <= x[i, j] + 1 for i in an for j in an
for t in dc), 'x = 0 constraint')
# Two service areas use the same stateful functions when x[i,j] = 1
m.addConstrs(((y[i, t] - y[j, t] <= 1 - x[i, j]) for i in an for j in an
for t in dc), 'x = 1 constraint')
# One access node connects to only one dc
m.addConstrs((sum(y[i, t] for t in dc) == 1 for i in an),
'one dc for access node')
# high availability constraint
m.addConstr(
sum((1 - x[i, j]) for i in an for j in an if i != j) >= 1, 'ha')
# maximum state transfer frequency
m.addConstr(
sum(h * (1 - x[i, j]) for i in an for j in an if i != j) <= State_max,
'max state transfer constraint')
######## Objective function #########
# Optimize latency budget
m.setObjective(
sum(y[i, t] * C[i, t] * (Sd / Bw + Lw + Wg) for i in an for t in dc),
GRB.MINIMIZE)
m.optimize()
######## Calculate performance metrics #########
# latency
latency = sum(C[i, t] * (Sd / Bw + Lw + Wg) * getattr(y[i, t], 'X')
for i in an for t in dc)
# state transfer frequency
state_transfer = sum(h * (1 - getattr(x[i, j], 'X')) for i in an
for j in an if i != j)
# number of function
num_func = M_dc - sum(
prod(1 - getattr(y[i, t], 'X') for i in an) for t in dc)
# total cost
cost = latency + state_transfer
# total metrics
total_metrics = [Bw, h, state_transfer, latency, num_func, cost]
# utopia point, nadir point
worst_state = state_transfer
best_latency = latency
return total_metrics, worst_state, best_latency
def _construct_smore_lp(self, G, edge_to_paths, num_total_paths):
m = Model('min-edge-util')
# Create variables: one for each path
path_vars = m.addVars(num_total_paths,
vtype=GRB.CONTINUOUS,
lb=0.0,
ub=1.0,
name='f')
max_link_util_var = m.addVar(vtype=GRB.CONTINUOUS, lb=0.0, name='z')
m.update()
m.setObjective(max_link_util_var, GRB.MINIMIZE)
# Add demand constraints
for k, d_k, path_ids in self.commodities:
m.addConstr(quicksum(path_vars[p] for p in path_ids) == 1)
# Add edge util constraints
for u, v, c_e in G.edges.data('capacity'):
paths = edge_to_paths[(u, v)]
constr_vars = [
path_vars[p] * self.commodities[self._path_to_commod[p]][-2]
for p in paths
]
m.addConstr(quicksum(constr_vars) / c_e <= max_link_util_var)
return LpSolver(m, None, self.DEBUG, self.VERBOSE, self.out)
def _cut_half(c, P):
"""
Given polytopen and direction c, cut it into half
"""
n = c.shape[0]
assert n == P.H.shape[1]
model = Model("n")
x = tupledict_to_array(
model.addVars(range(n), [0],
lb=-GRB.INFINITY,
ub=GRB.INFINITY,
name="x"))
model.update()
constraints_list_of_tuples(model, [(P.H, x), (-np.eye(P.h.shape[0]), P.h)],
sign="<")
J = LinExpr([(c[i, 0], x[i, 0]) for i in range(n)])
model.setParam('OutputFlag', False)
model.setObjective(J, GRB.MINIMIZE)
model.optimize()
g_min = model.ObjVal
model.setObjective(J, GRB.MAXIMIZE)
# Max
model.reset()
model.optimize()
g_max = model.ObjVal
g = np.array([(g_max + g_min) / 2.0]).reshape(1, 1)
P1 = polytope(np.vstack((P.H, c.T)), np.vstack((P.h, g)))
P2 = polytope(np.vstack((P.H, -c.T)), np.vstack((P.h, -g)))
return P1, P2, (c, g)
def solve():
model = Model("Enigma Riddle Binary Program")
letters = {"E", "N", "I", "G", "M", "A"}
digits = range(1, 10)
# x[i, j] == 1 => Letter i uses digit j
x = model.addVars(letters, digits, vtype=GRB.BINARY)
# Final value for first word
b = model.addVar(vtype=GRB.INTEGER)
first_word = "ENIGMA"
second_word = "IGMAEN"
# Constraints for the enigma-igmaen numbers
model.addConstr(
quicksum(
quicksum(10**(len(first_word) - 1 - i) * j * x[first_word[i], j]
for j in digits) for i in range(len(first_word))) == b)
model.addConstr(
quicksum(
quicksum(10**(len(second_word) - 1 - i) * j * x[second_word[i], j]
for j in digits)
for i in range(len(second_word))) == b * 1.2)
# Conflict constraint, different letters have different digits
model.addConstrs(x[i_1, j] + x[i_2, j] <= 1 for i_1 in letters
for i_2 in letters for j in digits if i_1 != i_2)
# Exactly one digit has to be used per letter
model.addConstrs(quicksum(x[i, j] for j in digits) == 1 for i in letters)
model.optimize()
return model
def optimize(inputFile, outputFile):
'''Function which takes in two input arguments:
- inputFile: the path to the input data. (.xlsx format)
- outputFile: the path to the output data. (.xlsx format)
The outputFile gives the optimal set of books to carry as well as
the minimum number of books needed.'''
genres = pd.read_excel(inputFile, sheet_name='genres',
index_col=0).fillna(0)
requirements = pd.read_excel(inputFile,
sheet_name='requirements',
index_col=0)
mod = Model()
I = genres.index
J = genres.columns
x = mod.addVars(I, vtype=GRB.BINARY)
mod.setObjective(sum(x[i] for i in I))
for j in J:
mod.addConstr(
sum(genres.loc[i, j] * x[i] for i in I) >= requirements.loc[j])
mod.setParam('outputflag', False)
mod.optimize()
writer = pd.ExcelWriter(outputFile)
carry = []
for i in I:
if x[i].x:
carry.append(i)
pd.DataFrame(carry,columns=['books'])\
.to_excel(writer,sheet_name='optimal_decision')
pd.DataFrame([mod.objVal],columns=['books_needed'])\
.to_excel(writer,sheet_name='objective',index=False)
writer.save()
def Distribution_Matching(D):
mean = np.mean(D)
moment = [np.var(D), stats.skew(D),
stats.kurtosis(D)]
N = len(D)
T1 = range(N)
K = range(len(moment))
#number of moments
W = np.array([0.5, 0.35, 0.15])
Omega = np.random.uniform(0, 1, (1, N))
osum = np.sum(Omega)
Omega = [i / osum for i in Omega[0]]
# Gurobi Model: Define variables
ProbModel = Model()
P = ProbModel.addVars(N, lb=0, ub=1, vtype=GRB.CONTINUOUS, name="P")
S1 = ProbModel.addVars(N, lb=0, vtype=GRB.CONTINUOUS, name="S1")
S2 = ProbModel.addVars(N, lb=0, vtype=GRB.CONTINUOUS, name="S2")
M1 = ProbModel.addVars(K, lb=0, vtype=GRB.CONTINUOUS, name="M1")
M2 = ProbModel.addVars(K, lb=0, vtype=GRB.CONTINUOUS, name="M2")
# Objective Function
Z = quicksum(W[k] * (M1[k] + M2[k])
for k in K[1:]) + quicksum(Omega[j] * (S1[j] + S2[j])
for j in T1)
ProbModel.setObjective(Z, GRB.MINIMIZE)
# Define Constraints
ProbModel.addConstr(quicksum(P[j] for j in T1) == 1)
ProbModel.addConstr(quicksum(D[j] * P[j] for j in T1) == mean)
ProbModel.addConstrs(
quicksum((D[j] - mean)**(k + 2) * P[j]
for j in T1) + M1[k] - M2[k] == moment[k] for k in K)
ProbModel.addConstrs(
stats.norm.cdf((D[j] - mean) / moment[0]) -
quicksum(P[jp] for jp in T1) == S1[j] - S2[j] for j in T1)
ProbModel.addConstrs(P[j] >= 0.1 for j in T1)
# Solve and publish
ProbModel.Params.OutputFlag = 0
ProbModel.optimize()
return ProbModel.x[:N]
def optimize(inputFile, outputFile):
import pandas as pd
from gurobipy import Model, GRB
FC = pd.read_excel(inputFile, sheet_name='Fulfilment Centers', index_col=0)
I = FC.index ### fulfilment center index
Q = FC['capacity'] ### capacity at each fulfilment center
Regions = pd.read_excel(inputFile, sheet_name='Regions', index_col=0)
J = Regions.index ### Demand region index
Distance = pd.read_excel(inputFile, sheet_name='Distances', index_col=0)
E = Distance
Items = pd.read_excel(inputFile, sheet_name='Items', index_col=0)
K = Items.index ### Items
W = Items.iloc[:, 0] ### shipping weight
S = Items.iloc[:, 1] ### storage size
D = pd.read_excel(inputFile, sheet_name='Demand', index_col=0)
cap = []
mod = Model()
x = mod.addVars(I, J, K, vtype=GRB.CONTINUOUS, lb=0, name='x')
mod.setObjective(
sum(1.38 * W.loc[k] * E.loc[j, i] * x[i, j, k] for i in I for j in J
for k in K))
for j in J:
for k in K:
mod.addConstr(sum(x[i, j, k] for i in I) == D.loc[k, j])
for i in I:
cap.append(
mod.addConstr(
sum(x[i, j, k] * S.loc[k] for j in J for k in K) <= Q.loc[i]))
mod.optimize()
mod.setParam('outputflag', False)
Summary = pd.DataFrame([mod.objVal], columns=['Objective Value'])
Solution = []
for i in I:
for j in J:
for k in K:
if x[i, j, k].x:
Solution.append([i, j, k, x[i, j, k].x])
Solution = pd.DataFrame(
Solution, columns=['FC_name', 'region_ID', 'item_ID', 'shipment'])
cap = pd.Series(cap, index=I)
cap1 = []
for i in range(len(I)):
cap1.append([I[i], cap[i].pi])
Capacity_constr = pd.DataFrame(cap1, columns=['FC_name', 'shadow_price'])
Capacity_constr = Capacity_constr.sort_values('shadow_price',
ascending=True)
writer = pd.ExcelWriter(outputFile)
pd.DataFrame([mod.objVal],
columns=['Objective Value']).to_excel(writer,
sheet_name='Summary',
index=False)
Solution.to_excel(writer, sheet_name='Solution', index=False)
Capacity_constr.to_excel(writer,
sheet_name='Capacity Constraints',
index=False)
writer.save()
def RCI_controller(sys, x):
"""
Based on zonotopes
"""
model = Model("Controller")
q = sys.phi.shape[1]
zeta = tupledict_to_array(
model.addVars(range(q), [0], lb=-1, ub=1, name="zeta"))
zeta_abs = tupledict_to_array(
model.addVars(range(q), [0], lb=0, ub=1, name="zeta_abs", obj=1))
model.update()
constraints_list_of_tuples(model, [(-np.eye(sys.n), x), (sys.phi, zeta)])
model.addConstrs(zeta_abs[i, 0] >= zeta[i, 0] for i in range(q))
model.addConstrs(zeta_abs[i, 0] >= -zeta[i, 0] for i in range(q))
model.setParam('OutputFlag', False)
model.optimize()
zeta_n = np.array([zeta[i, 0].X for i in range(q)]).reshape(q, 1)
print zeta_n.T
return np.dot(sys.theta, zeta_n)
def depOptimizer(base_schedule, allocations, dep):
df = base_schedule[base_schedule['department'] == dep].copy()
#df = df[df['level'] == 'UG']
#df = df[df['first_days'].isin(['MW', 'TH'])]
df.index = df['section']
# Defining J
J = list(allocations.columns)
# Defining F
F = pd.Series(allocations.iloc[0, :], dtype='float64').copy()
# Defining A
A = pd.Series(index=J, dtype='float64')
for j in J:
val = allocations.loc[allocations[j] == dep, j].count()
A[j] = 4 * val
# Defining I
I = list(df.index)
# Defining S
S = pd.Series(df.loc[:, 'seats_offered'], dtype='float64').copy()
# Defining L
L = pd.Series(df.loc[:, 'periods'], dtype='float64').copy()
# Gurobi Optimization
mod = Model()
X = mod.addVars(I, J, vtype=GRB.BINARY)
mod.setObjective(sum(F[j] * X[i, j] - S[i] * X[i, j] for i in I
for j in J))
# i
for j in J:
mod.addConstr(sum(L[i] * X[i, j] for i in I) <= A[j])
# ii
for i in I:
for j in J:
mod.addConstr(S[i] * X[i, j] <= F[j])
# iii
for i in I:
mod.addConstr(sum(X[i, j] for j in J) == 1)
mod.setParam('outputflag', False)
mod.optimize()
# Creating Decision vars dataframe
output = pd.DataFrame(
index=I,
columns=['Class_Section', 'Room', 'Course', 'Students', 'Capacity'])
output['Class_Section'] = output.index
for i in I:
for j in J:
if X[i, j].x:
room = j
output.loc[i, 'Room'] = room
output.loc[i, 'Course'] = df.loc[i, 'course']
output.loc[i, 'Students'] = S[i]
output.loc[i, 'Capacity'] = F[output.loc[i, 'Room']]
output['Average Empty Seats per Class'] = np.nan
output = output.reset_index(drop=True)
output.loc[0, 'Average Empty Seats per Class'] = round(
mod.objVal / len(I), 2)
return (output)
def markovitz_dro_wasserstein(data,
delta_param,
alpha_param,
wasserstein_norm=1):
'''
Model from Blanchet et al. 2017
DRO Markovitz reformulation from Wasserstein distance.
'''
r = np.mean(data, axis=0)
cov = np.cov(data, rowvar=False)
k = len(r)
n = len(data)
m = Model('opt_profolio')
m.params.OutputFlag = 0
m.params.NumericFocus = 3
x = m.addVars(k, lb=0, ub=1, vtype=GRB.CONTINUOUS, name='x')
norm_p = m.addVar(lb=0, ub=1, vtype=GRB.CONTINUOUS, name='norm')
p_SD = m.addVar(lb=0, vtype=GRB.CONTINUOUS, name='p_var')
m.update()
sqrt_delta = np.sqrt(delta_param)
m.addConstr((x.sum() == 1), 'portfolio_ctr')
m.addConstr(
(quicksum(x[j] * r[j]
for j in range(k)) >= alpha_param - sqrt_delta * norm_p),
'return_ctr')
m.addConstr((p_SD * p_SD >= quicksum(cov[i, j] * x[i] * x[j]
for i in range(k)
for j in range(k))), 'SD_def')
objfun = p_SD * p_SD + 2 * p_SD * sqrt_delta * norm_p + delta_param * norm_p * norm_p
m.setObjective(objfun, GRB.MINIMIZE)
if wasserstein_norm == 1:
regularizer_norm = 'inf'
m.addConstrs((norm_p >= x[j] for j in range(k)), 'norm_def')
elif wasserstein_norm == 2:
regularizer_norm = 2
m.addConstr((norm_p * norm_p >=
(quicksum(x[j] * x[j] for j in range(k)))), 'norm_def')
elif wasserstein_norm == 'inf':
regularizer_norm = 1
#Note: this works since x>=0
m.addConstr((norm_p == (quicksum(x[j] for j in range(k)))), 'norm_def')
else:
raise 'wasserstain norm should be 1,2, or inf'
m.optimize()
x_sol = np.array([x[j].X for j in range(k)])
p_mean = r.dot(x_sol)
p_var = x_sol.dot(cov.dot(x_sol))
#print(x_sol, p_mean, p_var)
#print('norms' , np.linalg.norm(x_sol) , norm_p.X)
return x_sol, p_mean, p_var
def create_model(self):
model = Model()
_A = [(i,t) for i in self.tasks for t in self.periods]
x = model.addVars(_A, vtype = GRB.BINARY) # create decision variables
b = model.addVars(_A, vtype = GRB.BINARY) # create decision variables
# create constraints
model.addConstrs(quicksum(self.p[i,t] * (1 - x[i,t]) for i in self.tasks) - \
self.d[t] >= 0 for t in self.periods) # 1
model.addConstrs(quicksum(b[i,t] for t in self.periods) == 1 \
for i in self.tasks) # 2
model.addConstrs(x[i,t] >= b[i,t] for i in self.tasks for t in self.periods) # 3
model.addConstrs(x[i,t] - x[i,t-1] <= b[i,t] for i in self.tasks \
for t in self.periods[1:]) # 3, t >= 2
_tmp = self.periods[1:]
# model.addConstrs(x[i,t] <= b[i,t] for t in _tmp \
# for i in self.tasks) # 4
model.addConstrs(x[i,t] + x[i,t-1] + b[i,t] <= 1+self.LP[i] for t in self.periods[1:] \
for i in self.tasks) # 4
model.addConstrs(quicksum(x[i,t] for t in self.periods) == self.LP[i] \
for i in self.tasks) # 5
model.addConstrs(quicksum(x[i,t] for i in self.tasks) <= self.LT[t] \
for t in self.periods) # 6
model.addConstrs(quicksum(b[i,k] for k in self.periods) - b[j,t] >= 0 \
for t in self.periods for i in self.tasks for j in self.tasks if j!=i) # 7
model.addConstrs(x[i,t] + x[j,t] <= 1 for t in self.periods \
for i in self.tasks for j in self.tasks if j!=i) # 8
model.addConstrs(quicksum(b[i,t] for t in self.periods[:self.L[i]-self.LP[i]+2]) == 1 \
for i in self.tasks) # 9
# model.addConstrs(quicksum(x[i,t] == 0 for t in self.U) for i in self.tasks) # 10
model.addConstrs(x[i,t] == 0 for t in self.U for i in self.tasks) # 10
model.addConstrs(quicksum((self.MV[i] + self.MH[i] + self.ML[i]) * x[i,t] \
for i in self.tasks) <= self.AM[t] for t in self.periods) # 11
model.addConstrs(quicksum(self.V[i] * x[i,t] for i in self.tasks) \
<= self.AV[t] for t in self.periods) # 12
model.addConstrs(quicksum(self.H[i] * x[i,t] for i in self.tasks) <= \
self.AH[t] for t in self.periods) # 13
# create costs
C_M, C_T = {}, {}
for i in self.tasks:
for t in self.periods:
C_M[i,t] = self.C_MV[t] * self.MV[i] + self.C_MH[t] * self.MH[i] + \
self.C_ML[t] * self.ML[i]
C_T[i,t] = (self.C_FV * self.V[i] + self.C_FH * self.H[i])/self.LP[i] + \
self.C_SV[i,t] * self.V[i] + self.C_SH[i,t] * self.H[i]
model.modelSense = GRB.MINIMIZE
# create ojective function
model.setObjective(quicksum((C_M[i,t] + self.C_EQ[i,t] + self.C_I[i,t] + \
C_T[i,t]) * x[i,t] for t in self.periods for i in self.tasks))
# model.setParam('OutputFlag', 0)
model.optimize()
return
def ilp_node_reachability(reachability_dic, max_delay=180, log_path=None):
# List of nodes ids
node_ids = sorted(list(reachability_dic.keys()))
#node_ids = node_ids[:100]
try:
# Create a new model
m = Model("region_centers")
if log_path:
m.Params.LogFile = '{}/region_centers_{}.log'.format(
log_path, max_delay)
# xi = 1, if vertex Vi is used as a region center and 0 otherwise
x = m.addVars(node_ids, vtype=GRB.BINARY, name="x")
# Ensures that every node in the road network graph is reachable
# within 'max_delay' travel time by at least one region center
# selected from the nodes in the graph.
# To extract the region centers, we select from V all vertices
# V[i] such that x[i] = 1.
for d in node_ids:
m.addConstr(
quicksum(x[o] * is_reachable(reachability_dic, o, d, max_delay)
for o in node_ids) >= 1)
# Set objective
m.setObjective(quicksum(x), GRB.MINIMIZE)
# Solve
m.optimize()
region_centers = list()
if m.status == GRB.Status.OPTIMAL:
var_x = m.getAttr('x', x)
for n in node_ids:
if var_x[n] > 0.0001:
region_centers.append(n)
return region_centers
else:
print('No solution')
return None
except GurobiError as e:
print('Error code ' + str(e.errno) + ": " + str(e))
except AttributeError as e:
print('Encountered an attribute error:' + str(e))
def run_algorithm(self):
old_M = self.M
old_items = [i.copy() for i in self.items]
map_name_to_old_item = dict()
for i in old_items:
map_name_to_old_item[i.name] = i
self.scale_items_by_cost()
from gurobipy import Model, GRB
model = Model("NP-Hard")
print("Setting Model Parameters")
# set timeout
model.setParam('TimeLimit', 1600)
model.setParam('MIPFocus', 3)
model.setParam('PrePasses', 1)
model.setParam('Heuristics', 0.01)
model.setParam('Method', 0)
map_name_to_item = dict()
map_name_to_cost = dict()
map_name_to_weight = dict()
map_name_to_profit = dict()
map_class_to_name = dict()
item_names = list()
print("Preprocessing data for model...")
for item in self.items:
item_names.append(item.name)
map_name_to_item[item.name] = item
map_name_to_cost[item.name] = item.cost
map_name_to_weight[item.name] = item.weight
map_name_to_profit[item.name] = item.profit
if item.classNumber not in map_class_to_name:
map_class_to_name[item.classNumber] = list()
map_class_to_name[item.classNumber].append(item.name)
class_numbers = list(map_class_to_name.keys())
print("Setting model variables...")
# binary variables =1, if use>0
items = model.addVars(item_names, vtype=GRB.BINARY, name="items")
classes = model.addVars(class_numbers, vtype=GRB.BINARY, name="class numbers")
print("Setting model objective...")
# maximize profit
objective = items.prod(map_name_to_profit)
model.setObjective(objective, GRB.MAXIMIZE)
# constraints
print("Setting model constraints")
model.addConstr(items.prod(map_name_to_weight) <= self.P,"weight capacity")
model.addConstr(items.prod(map_name_to_cost) <= self.M,"cost capacity")
# if any item from a class is chosen, that class variable has to be a binary of 1
for num in class_numbers:
model.addGenConstrOr(classes[num], [items[x] for x in map_class_to_name[num]] ,name="class count")
for c in self.raw_constraints:
count = model.addVar()
for n in c:
if n in classes:
count += classes[n]
model.addConstr(count <= 1, name="constraint")
print("Start optimizing...")
model.optimize()
print("Done! ")
# Status checking
status = model.Status
if status == GRB.Status.INF_OR_UNBD or \
status == GRB.Status.INFEASIBLE or \
status == GRB.Status.UNBOUNDED:
print('The model cannot be solved because it is infeasible or unbounded')
if status != GRB.Status.OPTIMAL:
print('Optimization was stopped with status ' + str(status))
Problem = True
try:
model.write("mps_model/" + self.filename + ".sol")
except Exception as e:
pass
print("Generating solution file...")
# Display solution
solution_names = list()
for i, v in enumerate(items):
try:
if items[v].X > 0.9:
solution_names.append(item_names[i])
except Exception as e:
pass
self.M = old_M
self.items = old_items
solution = [map_name_to_old_item[i] for i in solution_names]
return solution
