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,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])
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, 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)
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, 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, 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,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): 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 __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 __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 SolveStoModel(self) -> Model: StoModel = Model('StoModel') StoModel.setParam('OutputFlag', 0) StoModel.modelSense = GRB.MINIMIZE m, n = self.m, self.n h, f = self.h, self.f d_rs = self.d_rs d_rs_length = len(d_rs) I = StoModel.addVars(m, vtype=GRB.CONTINUOUS, name='I') Z = StoModel.addVars(m, vtype=GRB.BINARY, name='Z') Transshipment_X = StoModel.addVars(self.roads, d_rs_length, vtype=GRB.CONTINUOUS, name='Transshipment_X') objFunc_holding = quicksum(I[i] * h[i] for i in range(m)) objFunc_fixed = quicksum(Z[i] * f[i] for i in range(m)) objFunc_penalty = quicksum(d_r[j] - Transshipment_X.sum('*', j, k) for k, d_r in d_rs.items() for j in range(n)) objFunc = objFunc_holding + objFunc_fixed + (objFunc_penalty / d_rs_length) StoModel.setObjective(objFunc) # 约束1 for k in range(d_rs_length): StoModel.addConstrs( Transshipment_X.sum(i, '*', k) <= I[i] for i in range(m)) # 约束2 for k, d_r in d_rs.items(): StoModel.addConstrs( Transshipment_X.sum('*', j, k) <= d_r[j] for j in range(n)) # 约束3 I_i<=M*Z_i StoModel.addConstrs(I[i] <= 20000 * Z[i] for i in range(m)) # 求解评估模型 StoModel.optimize() self.model = StoModel return StoModel
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, 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): 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])
def _balancing(self, flow_graph, sinks, frontier, demands): configure_gurobi() model = Model() xij = {i: {} for i in frontier} for node in frontier: congestion = sum(flow_graph[node][neighbor] for neighbor in flow_graph[node]) for neighbor in flow_graph[node]: assert neighbor in sinks xij[node][neighbor] = model.addVar(vtype=GRB.CONTINUOUS, name=f"x_{node}_{neighbor}") model.addConstr(xij[node][neighbor] >= 0) model.addConstr(quicksum(xij[node][neighbor] for neighbor in flow_graph[node]) == congestion) sink_predecessors = {i: [] for i in sinks} for node in frontier: for neighbor in flow_graph[node]: sink_predecessors[neighbor].append(node) bj = {} for node in sinks: bj[node] = model.addVar(vtype=GRB.CONTINUOUS, name=f"b_{node}") model.addConstr(bj[node] == quicksum(xij[pred][node] for pred in sink_predecessors[node]) + demands[node]) model.setObjective(quicksum(bj[node] * bj[node] for node in sinks), GRB.MINIMIZE) model.optimize() any_edge_deleted = False for node in frontier: to_delete = [] for neighbor in flow_graph[node]: flow = xij[node][neighbor].X if flow < EPS: to_delete.append(neighbor) any_edge_deleted = True else: flow_graph[node][neighbor] = flow for neighbor in to_delete: del flow_graph[node][neighbor] return any_edge_deleted
def __Simulate(self, d_r): # define the model model = Model('evaluation_problem') model.setParam('OutputFlag', 0) model.modelSense = GRB.MINIMIZE # decision variables X = model.addVars(tuplelist(self.roads_Z), vtype=GRB.CONTINUOUS, lb=0.0, name='X') # objective function objFunc_penal = sum(d_r) - X.sum() model.setObjective(objFunc_penal) # constraints model.addConstrs(X.sum('*', j) <= d_r[j] for j in range(self.n)) model.addConstrs(X.sum(i, '*') <= self.I[i] for i in range(self.m)) # solve model.optimize() # record return {'d_r': d_r, 'X': {f'{r}': X[r].X for r in self.roads_Z}}
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)
def SolveDetModel(self) -> Model: DetModel = Model('StoModel') DetModel.setParam('OutputFlag', 0) DetModel.modelSense = GRB.MINIMIZE m, n = self.m, self.n h, f = self.h, self.f mu = self.det_param['mu'] I = DetModel.addVars(m, vtype=GRB.CONTINUOUS, name='I') Z = DetModel.addVars(m, vtype=GRB.BINARY, name='Z') Transshipment_X = DetModel.addVars(self.roads, vtype=GRB.CONTINUOUS, name='Transshipment_X') objFunc_holding = quicksum(I[i] * h[i] for i in range(m)) objFunc_fixed = quicksum(Z[i] * f[i] for i in range(m)) objFunc_penalty = quicksum(mu[j] - Transshipment_X.sum('*', j) for j in range(n)) objFunc = objFunc_holding + objFunc_fixed + objFunc_penalty DetModel.setObjective(objFunc) # 约束1 DetModel.addConstrs( Transshipment_X.sum(i, '*') <= I[i] for i in range(m)) # 约束2 DetModel.addConstrs( Transshipment_X.sum('*', j) <= mu[j] for j in range(n)) # 约束3 I_i<=M*Z_i DetModel.addConstrs(I[i] <= 20000 * Z[i] for i in range(m)) # 求解评估模型 DetModel.optimize() self.model = DetModel return DetModel
from gurobipy.gurobipy import Model, GRB # Model m = Model('textile') # Decision variables xa = m.addVar(0, GRB.INFINITY, vtype=GRB.CONTINUOUS, name="xa") xb = m.addVar(0, GRB.INFINITY, vtype=GRB.CONTINUOUS, name="xb") yw = m.addVar(0, GRB.INFINITY, vtype=GRB.CONTINUOUS, name="yw") yl = m.addVar(0, GRB.INFINITY, vtype=GRB.CONTINUOUS, name="yl") yh = m.addVar(0, GRB.INFINITY, vtype=GRB.CONTINUOUS, name="yh") # Objective function m.setObjective(60 * xa + 65 * xb - 3 * yw - 3 * yl - 10 * yh, sense=GRB.MAXIMIZE) # Constraints m.addConstr(0.3 * xa + 0.5 * xb - yw, sense=GRB.LESS_EQUAL, rhs=0) m.addConstr(6 * xa + 5 * xb <= yl) m.addConstr(3 * xa + 5 * xb <= yh) m.addConstr(yw <= 20) m.addConstr(yl <= 300) m.addConstr(yh <= 200) m.optimize() print('Objective value: %g' % m.objVal) print('%s %g' % (xa.varName, xa.x)) print('%s %g' % (xb.varName, xb.x)) print('%s %g' % (yw.varName, yw.x)) print('%s %g' % (yl.varName, yl.x))
from gurobipy.gurobipy import GRB, Model # Data months = [8, 9, 10] cost = {8: 60, 9: 65, 10: 68} price = {8: 90, 9: 110, 10: 105} max_buy = 65 max_sell = 100 storage_capacity = 45 storage_cost = 7 current_stock = 25 # Model m = Model('ref') # Decision variables b = m.addVars(months, lb=0, ub=max_buy, vtype=GRB.CONTINUOUS, name="b") s = m.addVars(months, lb=0, ub=max_sell, vtype=GRB.CONTINUOUS, name="s") k = m.addVars(months, lb=0, ub=storage_capacity, vtype=GRB.CONTINUOUS, name="k") print(s) # Objective function expr = 0 for i in months: expr = expr + price[i] * s[i] - cost[i] * b[i] - storage_cost * k[i] m.setObjective(expr, sense=GRB.MAXIMIZE)
from gurobipy.gurobipy import Model, GRB # Create the model object m = Model('diet_problem') # Create the variables xa = m.addVar(0, GRB.INFINITY, vtype=GRB.CONTINUOUS, name="xa") xb = m.addVar(0, GRB.INFINITY, vtype=GRB.CONTINUOUS, name="xb") # a different way to create a non-negative continuous variable xc = m.addVar(name="xc") xd = m.addVar(0, GRB.INFINITY, name="xd") xe = m.addVar(name="xe") # Create the objective function expr = 8 * xa + 10 * xb + 3 * xc + 20 * xd + 15 * xe m.setObjective(expr, sense=GRB.MINIMIZE) # Create the constraints. We will use different ways of adding a constraint expr = 0.4 * xa + 1.2 * xb + 0.6 * xc + 0.6 * xd + 12.2 * xe m.addConstr(lhs=expr, sense=GRB.GREATER_EQUAL, rhs=70) m.addConstr(6 * xa + 10 * xb + 3 * xc + 1 * xd + 0 * xe >= 50) m.addConstr(0.4 * xa + 0.6 * xb + 0.4 * xc + 0.2 * xd + 2.6 * xe, GRB.GREATER_EQUAL, 12) m.optimize() print('Objective value: %g' % m.objVal) print('%s %g' % (xa.varName, xa.x)) print('%s %g' % (xb.varName, xb.x)) print('%s %g' % (xc.varName, xc.x)) print('%s %g' % (xd.varName, xd.x))
def Build_LDR_Model(self): """ LDR for location-inventpry problem is only feasible when all affine coefficients equal to 0, which violates from what we want. For more info about how to design a reasonable prepositioning network, see: http://web.hec.ca/pages/erick.delage/LRC_TRO.pdf The above paper assume support set is a convex polyhedron characterized by linear constraints. """ m, n = self.m, self.n f, h = self.f, self.h mu, sigma = self.mu, self.sigma roads = self.roads INF = float('inf') f_ks, K = self.ldr_params['f_k'], len(self.ldr_params['f_k']) # declare model ldr_model = Model() # decision variables I = ldr_model.addVars(m, vtype=GRB.CONTINUOUS, lb=0.0, name='I') Z = ldr_model.addVars(m, vtype=GRB.BINARY, lb=0.0, name='Z') t = ldr_model.addVars(n, vtype=GRB.CONTINUOUS, lb=-INF, name='t') gamma = ldr_model.addVar(lb=-INF, vtype=GRB.CONTINUOUS, name='gamma') s = ldr_model.addVars(K, vtype=GRB.CONTINUOUS, lb=0.0, name='s') phi = ldr_model.addVars(K, vtype=GRB.CONTINUOUS, lb=0.0, name='phi') psi = ldr_model.addVars(K, vtype=GRB.CONTINUOUS, lb=-INF, name='psi') xi = ldr_model.addVars(K, vtype=GRB.CONTINUOUS, lb=-INF, name='xi') eta = ldr_model.addVars(n, K, vtype=GRB.CONTINUOUS, lb=0.0, name='eta') tau = ldr_model.addVars(n, K, vtype=GRB.CONTINUOUS, lb=-INF, name='tau') theta = ldr_model.addVars(n, K, vtype=GRB.CONTINUOUS, lb=-INF, name='theta') w = ldr_model.addVars(m, K, vtype=GRB.CONTINUOUS, lb=0.0, name='w') lambd = ldr_model.addVars(m, K, vtype=GRB.CONTINUOUS, lb=-INF, name='lambda') delta = ldr_model.addVars(m, K, vtype=GRB.CONTINUOUS, lb=-INF, name='delta') alpha_0 = ldr_model.addVars(roads, vtype=GRB.CONTINUOUS, lb=-INF, name='alpha_0') alpha = ldr_model.addVars(roads, n, vtype=GRB.CONTINUOUS, lb=-INF, name='alpha') beta = ldr_model.addVars(roads, K, vtype=GRB.CONTINUOUS, lb=-INF, name='beta') # objective function obj1 = quicksum([f[i]*Z[i] for i in range(m)]) obj2 = quicksum([h[i]*I[i] for i in range(m)]) obj3 = quicksum([mu[i]*t[i] for i in range(m)]) obj4 = quicksum(s[k]*matmul(matmul(f_k, sigma), f_k) for k, f_k in enumerate(f_ks)) obj5 = gamma ldr_model.setObjective(obj1 + obj2 + obj3 + obj4 + obj5) ldr_model.modelSense = GRB.MINIMIZE # constraint # c1 ldr_model.addConstr(gamma + alpha_0.sum() >= 1/2*(phi.sum() - psi.sum()), name='c1') # c2 ldr_model.addConstrs((1/2*(phi[k]+psi[k]) == beta.sum('*', '*', k) + s[k]*len(roads) for k in range(K)), name='c2') # c3 a_star_star = [alpha.sum('*', '*', l) for l in range(n)] ldr_model.addConstrs((xi[k]*f_ks[k][l] <= t[l]+a_star_star[l]-1 for k in range(K) for l in range(n)), name='c3') # c4 ldr_model.addConstrs((-alpha_0.sum('*', j) >= 1/2*(eta.sum(j, '*')-tau.sum(j, '*')) for j in range(n)), name='c4') # c5 ldr_model.addConstrs((-1/2*(eta[j, k]+tau[j, k]) == beta.sum('*', j, k) for k in range(K) for j in range(n)), name='c5') # c6 for j in range(n): a_star_j = [alpha.sum('*', j, l) if l != j else alpha.sum('*', j, l)-1 for l in range(n)] for k, f_k in enumerate(f_ks): ldr_model.addConstrs(-theta[j, k]*f_k[l] >= a_star_j[l] for l in range(n)) # c7 ldr_model.addConstrs((I[i]-alpha_0.sum(i, '*') >= 1/2*(w.sum(i, '*')-lambd.sum(i, '*')) for i in range(m)), name='c7') # c8 ldr_model.addConstrs((-1/2*(w[i, k]+lambd[i, k]) == beta.sum(i, '*', k) for i in range(m) for k in range(K)), name='c8') # c9 for i in range(m): a_i_star = [alpha.sum(i, '*', l) for l in range(n)] for k, f_k in enumerate(f_ks): ldr_model.addConstrs(-delta[i, k]*f_k[l] >= a_i_star[l] for l in range(n)) # c10 I,Z ldr_model.addConstrs(I[i] <= 10000*Z[i] for i in range(m)) # c11 ldr_model.addConstrs(phi[k]*phi[k] >= psi[k]*psi[k] + xi[k]*xi[k] for k in range(K)) ldr_model.addConstrs(eta[i, k]*eta[i, k] >= tau[i, k]*tau[i, k] + theta[i, k]*theta[i, k] for k in range(K) for i in range(m)) ldr_model.addConstrs(w[i, k]*w[i, k] >= lambd[i, k]*lambd[i, k] + delta[i, k]*delta[i, k] for k in range(K) for i in range(m)) # update ldr_model.update() ldr_model.optimize() # print(I) # print(Z) # print(alpha_0) # print(alpha) # print(beta) # print(ldr_model.ObjVal) self.model = ldr_model