def add_constraints(opt_model, const_df): const_count = 0 for index, row in const_df.iterrows(): const_count += 1 if row['SIGN'] == '': continue elif row['SIGN'] == '<=': const_sign = plp.LpConstraintLE else: const_sign = plp.LpConstraintGE if row['LEFT HAND SIDE'] == '# OF POKEMON': new_const = plp.LpConstraint( e=plp.lpSum(x_vars[p] for p in pokes), sense=const_sign, rhs=int(row['RIGHT HAND SIDE']), name="constraint_{0}".format(const_count)) elif 'TOTAL' in row['LEFT HAND SIDE']: my_const_stat = list(compress(poke_stats, [s in row['LEFT HAND SIDE'] for s in poke_stats]))[0] new_const = plp.LpConstraint( e=plp.lpSum(x_vars[p] * param_stats.get((p, my_const_stat)) for p in pokes), sense=const_sign, rhs=int(row['RIGHT HAND SIDE']), name="constraint_{0}".format(const_count)) elif 'TYPE' in row['LEFT HAND SIDE']: my_type = list(compress(poke_types, [t in row['LEFT HAND SIDE'] for t in poke_types]))[0] new_const = plp.LpConstraint( e=plp.lpSum(x_vars[p] * param_types.get((p, my_type)) for p in pokes), sense=const_sign, rhs=int(row['RIGHT HAND SIDE']), name="constraint_{0}".format(const_count)) opt_model += new_const return(opt_model)
def _create_constraints(self, variables, nutrients, food_items, expressions): """Create LP problem constraints Args: variables: Dictionary with problem variables nutrients: Nutrients to use in the problem formulation food_items: Food items to use in the problem formulation Returns: List of constraints to apply to the problem """ constraints = [] # Iterate all nutrients to create constraints for nutrient_id, nutrient_data in nutrients.items(): max_nutrient_amount_constraint = pulp.LpConstraint( e=expressions[ self.NUTRIENTS_QTY_EXPRESSIONS_CATEGORY][nutrient_id], sense=pulp.LpConstraintLE, rhs=nutrient_data["constraints"]["max"], name='_'.join([nutrient_id, "max"])) constraints.append(max_nutrient_amount_constraint) min_nutrient_amount_constraint = pulp.LpConstraint( e=expressions[ self.NUTRIENTS_QTY_EXPRESSIONS_CATEGORY][nutrient_id], sense=pulp.LpConstraintGE, rhs=nutrient_data["constraints"]["min"], name='_'.join([nutrient_id, "min"])) constraints.append(min_nutrient_amount_constraint) # Demerits constrain => use max(of deviation) if self.use_demerits: # Nutrient variation nutrient_demerits_variable = variables['nutrient_demerit'][ nutrient_id] nutrient_deviation_constraint = pulp.LpConstraint( e=nutrient_demerits_variable - (expressions[self.NUTRIENTS_VARIATION_EXPRESSIONS_CATEGORY] [nutrient_id] * nutrient_data["weights"]["overconsumption"]), sense=pulp.LpConstraintGE, rhs=0., name='_'.join([nutrient_id, "dev"])) constraints.append(nutrient_deviation_constraint) nutrient_deviation_ve_constraint = pulp.LpConstraint( e=nutrient_demerits_variable - (-expressions[self.NUTRIENTS_VARIATION_EXPRESSIONS_CATEGORY] [nutrient_id] * nutrient_data["weights"]["overconsumption"]), sense=pulp.LpConstraintGE, rhs=0., name='_'.join([nutrient_id, "dev_ve"])) constraints.append(nutrient_deviation_ve_constraint) return constraints
def general_constr(self): # Making sure if you enter a node, you leave the same node (flow continuity) for k in range(self.drone_amount): for h in range(0, self.i): self.pm.addConstraint( plp.LpConstraint( plp.lpSum(self.x_vars[i, h, k] for i in self.value_list[h]) - plp.lpSum(self.x_vars[h, j, k] for j in self.value_list[h]) == 0)) # Making sure all the nodes are visited for i in range(0, self.i): if i not in self.charge_nodes: self.pm.addConstraint( plp.LpConstraint( plp.lpSum(self.x_vars[i, j, k] for j in self.value_list[i] for k in range(self.drone_amount)) >= 1)) # Making sure all the drones leave the home station for k in range(self.drone_amount): self.pm.addConstraint( plp.LpConstraint( plp.lpSum(self.x_vars[0, j, k] for j in self.value_list[0]) == 1))
def get_optimal_quantities( y: {'coin name': 'amount_held'}, x: ['coin names'], c: {'coin name': 'cost'}, p: {'coin name': 'current price'}, B: 'Int: budget', f: {'coin name': 'max fraction in portfolio'}) -> { 'coin name': 'quantity' }: problem = plp.LpProblem("Crypto-currency porfolio", sense=plp.LpMaximize) x_var = {(i): plp.LpVariable(cat=plp.LpContinuous, name="x{0}".format(i)) for i in x} problem += plp.LpConstraint(e=plp.lpSum(x_var[i] * c[i] for i in x), sense=plp.LpConstraintLE, rhs=B, name="budget") for i in x: problem += plp.LpConstraint(e=x_var[i], sense=plp.LpConstraintLE, rhs=f[i] - y[i], name="limit_{0}".format(i)) problem += plp.LpConstraint(e=x_var[i], sense=plp.LpConstraintGE, rhs=-y[i], name="amount_constraint{0}".format(i)) print(problem) objective = plp.lpSum(x_var[i] * (p[i] - c[i]) for i in x) problem.setObjective(objective) problem.solve() # opt_df = pd.DataFrame.from_dict(x, orient="index", columns = ["variable_object"]) # opt_df["solution_value"] = opt_df["variable_object"].apply(lambda item: item.varValue) results = {i: x_var[i].varValue for i in x_var} return results
def charge_constr(self): # Set charge at a charging station equal to 100 for k in range(self.drone_amount): for i in self.charge_nodes: # Charging station charge equals 100 self.pm.addConstraint(plp.LpConstraint(self.q[i, k] == 100)) # Never go below a certain battery level for k in range(self.drone_amount): for i in range(0, self.i): self.pm.addConstraint( plp.LpConstraint(self.q[i, k] >= self.min_charge)) # Decrease the charge when moving from one node to another for k in range(self.drone_amount): for i in range(0, self.i): for j in self.value_list[i]: if j not in self.charge_nodes: self.pm.addConstraint( plp.LpConstraint( self.q[i, k] - self.q[j, k] - self.charge_constant * self.link(i, j) * self.x_vars[i, j, k] - self.charge_scan + (1 - self.x_vars[i, j, k]) * self.M >= 0)) if j in self.charge_nodes: self.pm.addConstraint( plp.LpConstraint( self.q[i, k] - self.charge_constant * self.link(i, j) * self.x_vars[i, j, k] + (1 - self.x_vars[i, j, k]) * self.M >= 0))
def time_constr(self): # Start at time equal to 0 for k in range(self.drone_amount): self.pm.addConstraint(plp.LpConstraint(self.time[0, k] == 0)) # Decrease the time when moving from one node to another for k in range(self.drone_amount): for i in range(0, self.i): for j in self.value_list[i]: if j not in self.charge_nodes: self.pm.addConstraint( plp.LpConstraint( self.time[i, k] - self.time[j, k] + self.time_constant * self.link(i, j) * self.x_vars[i, j, k] + self.scan_time - (1 - self.x_vars[i, j, k]) * self.M <= 0)) if j != 0: self.pm.addConstraint( plp.LpConstraint( self.time[i, k] - self.time[j, k] + self.time_constant * self.link(i, j) * self.x_vars[i, j, k] + self.charge_time * (100 - self.q[i, k]) + self.landing_takeoff_penalty - (1 - self.x_vars[i, j, k]) * self.M <= 0))
def _create_main_constraints(self): # Depending on what you need, you may want to consider creating any of # the expressions (constraints or objective terms) as an attribute of # the OptimizationModel class (e.g. self.inv_balance_constraints). # That way if, for example, at the end of the optimization you need to check # the slack variables of certain constraints, you know they already exists in your model # ================== Inventory balance constraints ================== self.inv_balance_constraints = { period: add_constr(self.model, pulp.LpConstraint( e=self.inventory_variables[period - 1] + self.production_variables[period] - self.inventory_variables[period], sense=pulp.LpConstraintEQ, name='inv_balance' + str(period), rhs=value.demand)) for period, value in self.input_data.iloc[1:].iterrows()} # inv balance for first period self.first_period_inv_balance_constraints = add_constr(self.model, pulp.LpConstraint( e=self.production_variables[0] - self.inventory_variables[0], sense=pulp.LpConstraintEQ, name='inv_balance0', rhs=self.input_data.iloc[0].demand - self.input_params['initial_inventory'])) # ================== Production capacity constraints ================== self.production_capacity_constraints = { index: add_constr(self.model, pulp.LpConstraint( e=value, sense=pulp.LpConstraintLE, name='prod_cap_month_' + str(index), rhs=self.input_data.iloc[index].production_capacity)) for index, value in self.production_variables.items()}
def solve_problem(obj, tolerance=0.01, threads=1, timeLimit=120): material_model = pulp.LpProblem("MaterialProductionModel", pulp.LpMinimize) # Create Equality Constraints that produce the Price and Volume as independent variables. price_coefficients = [(mineral, obj.price_per_ore[mineral]) for mineral in obj.variable_ore_dict.values()] price_coefficients.append((obj.price, -1)) price_constraint = pulp.LpConstraint( pulp.LpAffineExpression(price_coefficients), sense=pulp.LpConstraintEQ, name='PriceConstraint', rhs=0) volume_coefficients = [(mineral, obj.volume_per_ore[mineral]) for mineral in obj.variable_ore_dict.values()] volume_coefficients.append((obj.volume, -1)) volume_constraint = pulp.LpConstraint( pulp.LpAffineExpression(volume_coefficients), sense=pulp.LpConstraintEQ, name='VolumeConstraint', rhs=0) material_model += price_constraint material_model += volume_constraint # Create Cost Function in terms of variables # I'll be lazy for now and just minimize price in ISK. material_model += (obj.weight_of_price * obj.price + obj.weight_of_volume * obj.volume) # Now go through the required materials and impose constraints that ensure we produce the right amount of stuff for material, amount in obj.required_materials.items(): production_expr = pulp.LpAffineExpression( obj.yield_per_mineral[material].items()) production_constraint = pulp.LpConstraint( production_expr, sense=pulp.LpConstraintGE, name='Produce{}'.format(material), rhs=amount) # Add Constraint to Model material_model += production_constraint solver = pulp.PULP_CBC_CMD(timeLimit=timeLimit, gapRel=tolerance, threads=threads) print(material_model) material_model.solve(solver) # The status of the solution is printed to the screen print("Status:", pulp.LpStatus[material_model.status]) result = dict() for v in material_model.variables(): result[v.name] = v.varValue return result
def solve(self): self.X = [] for i in range(self.left): self.X.append([]) for j in range(self.right): self.X[i].append( pulp.LpVariable(cat=pulp.LpBinary, name="x" + str(i) + str(j))) for i in range(self.left): self.m += pulp.LpConstraint(sum( [self.X[i][j] for j in range(self.right)]), sense=pulp.LpConstraintLE, rhs=1) for j in range(self.right): self.m += pulp.LpConstraint(sum( [self.X[i][j] for i in range(self.left)]), sense=pulp.LpConstraintLE, rhs=1) for i in range(self.left): for j in range(self.right): self.m += pulp.LpConstraint(self.X[i][j], sense=pulp.LpConstraintLE, rhs=self.A[i, j]) self.m.setObjective( sum([ self.X[i][j] for i in range(self.left) for j in range(self.right) ])) self.m.solve()
def add_default_sudoku_constraints(prob, grid_vars, rows, cols, grids, values): # Constraint to ensure only one value is filled for a cell for row in rows: for col in cols: prob.addConstraint(plp.LpConstraint(e=plp.lpSum([grid_vars[row][col][value] for value in values]), sense=plp.LpConstraintEQ, rhs=1, name=f"constraint_sum_{row}_{col}")) # Constraint to ensure that values from 1 to 9 is filled only once in a row for row in rows: for value in values: prob.addConstraint(plp.LpConstraint(e=plp.lpSum([grid_vars[row][col][value]*value for col in cols]), sense=plp.LpConstraintEQ, rhs=value, name=f"constraint_uniq_row_{row}_{value}")) # Constraint to ensure that values from 1 to 9 is filled only once in a column for col in cols: for value in values: prob.addConstraint(plp.LpConstraint(e=plp.lpSum([grid_vars[row][col][value]*value for row in rows]), sense=plp.LpConstraintEQ, rhs=value, name=f"constraint_uniq_col_{col}_{value}")) # Constraint to ensure that values from 1 to 9 is filled only once in the 3x3 grid for grid in grids: grid_row = int(grid/3) grid_col = int(grid%3) for value in values: prob.addConstraint(plp.LpConstraint(e=plp.lpSum([grid_vars[grid_row*3+row][grid_col*3+col][value]*value for col in range(0,3) for row in range(0,3)]), sense=plp.LpConstraintEQ, rhs=value, name=f"constraint_uniq_grid_{grid}_{value}"))
def TSP(T, k, names): # initialize ILP as a min problem model = pl.LpProblem(name='Optimizacion_Labiales', sense=pl.LpMinimize) # number of lipsticks n = len(T) N = {x for x in range(1, n + 1)} print('\nNúmero de productos a optimizar sus tiempos de producción: ', (n - 1)) # variables x = pl.LpVariable.dicts('cambio_labial', ((i, j) for i in N for j in N), cat='Binary') # objective function z = pl.LpAffineExpression(e=[(x[i, j], T[i - 1, j - 1]) for i, j in x], constant=k, name='Funcion_Objetivo') model += z # constraints # constraint 1: all are visited but only once for i in N: N_update = N - {i} model += pl.LpConstraint( [(x[i, j], 1) for j in N_update], sense=pl.LpConstraintEQ, rhs=1 # right side of the equality ) # constraint 2: all are leaved and only once for j in N: N_update = N - {j} model += pl.LpConstraint( [(x[i, j], 1) for i in N_update], sense=pl.LpConstraintEQ, rhs=1 # right side of the equality ) # subtour elimination # aux vars definied by Miller, Tucker and Zemlin u = pl.LpVariable.dict('aux_var', (i for i in N), cat='Continuous') N0 = N - {1} for (i, j) in product(N0, N0): if i != j: model += pl.LpConstraint(u[i] - u[j] + n * x[i, j], sense=pl.LpConstraintLE, rhs=n - 1) # solve model # solve model.solve() # print answer print_TSP(model, names, k, n) return ()
def add_diagonal_sudoku_constraints(prob, grid_vars, rows, cols, values): # Constraint from top-left to bottom-right - numbers 1 - 9 should not repeat for value in values: prob.addConstraint(plp.LpConstraint(e=plp.lpSum([grid_vars[row][row][value]*value for row in rows]), sense=plp.LpConstraintEQ, rhs=value, name=f"constraint_uniq_diag1_{value}")) # Constraint from top-right to bottom-left - numbers 1 - 9 should not repeat for value in values: prob.addConstraint(plp.LpConstraint(e=plp.lpSum([grid_vars[row][len(rows)-row-1][value]*value for row in rows]), sense=plp.LpConstraintEQ, rhs=value, name=f"constraint_uniq_diag2_{value}"))
def solve(dat): """ core solving routine :param dat: a good ticdat for the input_schema :return: a good ticdat for the solution_schema, or None """ assert input_schema.good_tic_dat_object(dat) assert not input_schema.find_foreign_key_failures(dat) assert not input_schema.find_data_type_failures(dat) model = pulp.LpProblem(name="netflow", sense=pulp.LpMinimize) flow = {(h, i, j): pulp.LpVariable(name=f"flow_{h}_{i}_{j}", cat=pulp.LpContinuous, lowBound=0) for h, i, j in dat.cost if (i,j) in dat.arcs} flowslice = Slicer(flow) # Arc Capacity constraints for i,j in dat.arcs: model.addConstraint(pulp.LpConstraint( e=pulp.lpSum(flow[_h, _i, _j] * dat.commodities[_h]["Volume"] for _h, _i, _j in flowslice.slice('*', i, j)), rhs=dat.arcs[i,j]["Capacity"], name=f'cap_{i}_{j}', sense=pulp.LpConstraintLE)) # Flow conservation constraints. Constraints are generated only for relevant pairs. # So we generate a conservation of flow constraint if there is negative or positive inflow # quantity, or at least one inbound flow variable, or at least one outbound flow variable. for h,j in set((h,i) for (h,i), v in dat.inflow.items() if abs(v["Quantity"]) > 0)\ .union({(h,i) for h,i,j in flow}, {(h,j) for h,i,j in flow}): model.addConstraint(pulp.LpConstraint( e=pulp.lpSum(flow[h_i_j] for h_i_j in flowslice.slice(h,'*',j)) + dat.inflow.get((h, j), {"Quantity": 0})["Quantity"] - pulp.lpSum(flow[h_j_i] for h_j_i in flowslice.slice(h, j, '*')), rhs=0, # pulp isn't quite as nice as gurobipy, the rhs cannot have expressions sense=pulp.LpConstraintEQ, name=f'node_{h}_{j}')) model.setObjective(pulp.lpSum(flow * dat.cost[h, i, j]["Cost"] for (h, i, j), flow in flow.items())) model.solve() if pulp.LpStatus[model.status] == 'Optimal': rtn = solution_schema.TicDat() for (h, i, j), var in flow.items(): if var.varValue > 0: rtn.flow[h, i, j] = var.varValue rtn.parameters["Total Cost"] = sum(dat.cost[h, i, j]["Cost"] * r["Quantity"] for (h, i, j), r in rtn.flow.items()) return rtn
def constrain( self, grid: GridProblem[GP], right_grid: GridProblem[GPx], mode: Literal["right_excludes", "right_implies", "same_as"], **kwargs: Any, ) -> None: assert ( grid.prob is right_grid.prob ), "Passed grids have separate problems!" for left, rights in self.cross_map.items(): left_elem = grid.lpa[..., left.value] right_expr = right_grid.lpa[ ..., [right.value for right in rights] ].sum(axis=-1) if mode == "right_excludes": mode = pulp.LpConstraintLE elif mode == "right_implies": mode = pulp.LpConstraintGE else: mode = pulp.LpConstraintEQ grid.prob += pulp.LpConstraint( left_elem, rhs=right_expr, sense=mode, name=self.name )
def _add_constraints(self): max_node = self.nodes.max() for node in self.nodes: node_mask = np.zeros(max_node + 1).astype(bool) node_mask[node] = True in_flow_mask = node_mask[self.graph.edge_index[1]] in_flow_edges = self.graph.edge_index.T[in_flow_mask] inc_flow = plp.lpSum((self.model_vars[tuple(edge)] for edge in in_flow_edges)) self.m.addConstraint(plp.LpConstraint(e=inc_flow, sense=plp.LpConstraintLE, rhs=1)) out_flow_mask = node_mask[self.graph.edge_index[0]] out_flow_edges = self.graph.edge_index.T[out_flow_mask] out_flow = plp.lpSum((self.model_vars[tuple(edge)] for edge in out_flow_edges)) self.m.addConstraint(plp.LpConstraint(e=out_flow, sense=plp.LpConstraintLE, rhs=1))
def addConstr(self, exp1, op=None, exp2=None): if op is None: assert isinstance(exp1, pulp.LpConstraint) the_constr = exp1 elif isinstance(exp2, float): #print("addC/3: exp1 =", exp1, ", op =", op, ", exp2 =", exp2) the_constr = pulp.LpConstraint(exp1, op, rhs=exp2) #print("constr =", the_constr) else: #print("addC/3: exp1 =", exp1, ", op =", op, ", exp2 =", exp2) #new_exp = exp1 - exp2 #print(new_exp, type(new_exp)) the_constr = pulp.LpConstraint(exp1 - exp2, op, rhs=0) #print("constr =", the_constr) self.constraints.append(the_constr) return the_constr
def pulp_solve(self): problem = pulp.LpProblem(pulp.LpMinimize) vs = self.get_vars() our_vars = dict() v = [] for i in range(len(vs)): v.append(pulp.LpVariable('%d' %vs[i][0], vs[i][1], vs[i][2])) our_vars[vs[i][0]] = v[i] ob = self.get_objective() problem.objective = pulp.LpAffineExpression([(our_vars[ob[i][0]], ob[i][1]) for i in range(len(ob))]) css = self.get_linear_cons() for i in range(len(css)): ids, coefs, cnst = css[i] c = pulp.LpConstraint( pulp.LpAffineExpression([(our_vars[ids[j]], coefs[j]) for j in range(len(coefs))], constant=cnst) , sense=-1) problem.constraints[i] = c problem.solve() self.solutions.clear() for variable in problem.variables(): self.solutions[int(variable.name)] = variable.varValue self.obj_val = pulp.value(problem.objective)
def update_for_next_period(mdl, trend_dict, today, target_day): # ----------------------------------------------------------------------- # # Update number of cases for next period # ----------------------------------------------------------------------- # for d in mdl.deps: for t in mdl.transfer_periods: # Calculate existing cases and reallocations existing_cases = mdl.o_vars[d, t] cases_in = plp.lpSum(mdl.y_vars[dx, d, t] for dx in mdl.deps) cases_out = plp.lpSum(mdl.y_vars[d, dx, t] for dx in mdl.deps) # Get prognosis for organic growth prognosis = trend_dict[d][trend_dict[d]["Date"] == target_day].IVA.values[0] current = trend_dict[d][trend_dict[d]["Date"] == today].IVA.values[0] organic_growth = prognosis - current #Prediction for organic growth goes here #Summarize new cases new_cases = existing_cases + cases_in - cases_out + organic_growth # Add constraint mdl.addConstraint( plp.LpConstraint(e=mdl.o_vars[d, t + 1] - new_cases, sense=plp.LpConstraintEQ, rhs=0, name="new_cases_{0}_{1}".format(d, t))) return mdl
def con(self, affine, sense=0, rhs=0): affine = self._compress_affine(affine) con = pl.LpConstraint(pl.LpAffineExpression(affine), sense=sense, rhs=rhs) self.mip += con return con
def max_char_constraint(prob, d_vars, groups, file, elastic, sheet="Constraint - Maximum"): """ Add rigid or elastic maximum characterstic constraint based on elastic parameter. Constraint ensures or encourages no more than the maximum number of people with specified characteristic assigned to each group. With elastic constraint, allow maximum number to relax to zero to ensure the feasibility of the problem. """ person_df = import_from_template(file, "Person Setup") max_df = import_from_template(file, sheet) for idx, max_row in max_df.iterrows(): person_with_char_df = person_df.loc[person_df[ max_row["characteristic"]] == max_row["value"]] names_with_char = person_with_char_df["name"].to_list() for group in groups: if elastic: constraint_lhs = sum(d_vars[(name, group)] for name in names_with_char) constraint_rhs = max_row["maximum"] # sense value -1 means less than or equal to (<=) constraint = pulp.LpConstraint(constraint_lhs, sense=-1, name=int(1000000 * random.random()), rhs=constraint_rhs) # penalty-free target interval of 100% on left and 0% on right side of the rhs value ==> [0, constraint_rhs] e_constraint = constraint.makeElasticSubProblem( penalty=1, proportionFreeBoundList=[1, 0]) prob.extend(e_constraint) else: prob += sum(d_vars[(name, group)] for name in names_with_char) <= max_row["maximum"] return prob
def solve(AA, bb, ff, lb, ub, nn): vs1 = pulp.LpVariable.dicts('v', range(nn)) vs2 = pulp.LpVariable.dicts('v', range(nn, 2 * nn)) vs3 = pulp.LpVariable.dicts('v', range(2 * nn, 3 * nn), None, None, pulp.LpInteger) vs4 = pulp.LpVariable.dicts('v', range(3 * nn, 4 * nn), None, None, pulp.LpInteger) vs = {} vs.update(vs1) vs.update(vs2) vs.update(vs3) vs.update(vs4) for i in vs: vs[i].bounds(lb[i], ub[i]) prob = pulp.LpProblem("New Problem", pulp.LpMinimize) obj = pulp.LpAffineExpression([(vs[i], v) for i, v in enumerate(ff) if v]) prob += obj for i, rr in enumerate(AA): constraint = pulp.LpConstraint([(vs[i], v) for i, v in enumerate(rr) if v], pulp.LpConstraintLE, None, bb[i]) prob += constraint solver = pulp.solvers.PULP_CBC_CMD() solver.maxSeconds = 120 prob.setSolver(solver) prob.solve() xx = [0] * 4 * nn for v in prob.variables(): s, n = v.name.split('_') xx[int(n)] = v.varValue xx = numpy.array(xx) solution = xx[:nn] - xx[nn:2 * nn] solution = numpy.round(solution * 1e9) / 1e9 return pulp.LpStatus[prob.status], solution
def create_problem(market): lp_vars = {} problem = pulp.LpProblem(market.name, pulp.LpMaximize) profit = pulp.LpVariable('profit', lowBound=0, cat='Continuous') problem += profit for c in market.contracts: lp_vars[market.contracts[c].name] = pulp.LpVariable( market.contracts[c].name, lowBound=0, cat='Integer') #print(lp_vars) for v in lp_vars: if v is not "profit": expr = pulp.LpAffineExpression( [(lp_vars[x], market.contracts[x].profit) if x != v else (lp_vars[x], -1 * market.contracts[x].cost) for x in lp_vars] + [(profit, -1)]) c = pulp.LpConstraint( expr, 1) #1 indicates the expression should be >= 0 problem += c problem += lp_vars[v] * market.contracts[v].cost <= 850 #max_profit = pulp.LpAffineExpression([(lp_vars[x], market.contracts[x].profit) for x in lp_vars]) #max_profit += -850 #c = pulp.LpConstraint(max_profit, -1) #problem += c return problem
def mclp(candidates=None, K=None, radius=None, points=None): K = int(K) J = candidates.shape[0] I = points.shape[0] D = distance_matrix(points, candidates) mask = D <= radius D[mask] = 1 D[~mask] = 0 y_vars = {(i): plp.LpVariable(cat=plp.LpBinary, name="y_%d" % i) for i in range(I)} x_vars = {(j): plp.LpVariable(cat=plp.LpBinary, name="x_%d" % j) for j in range(J)} opt_model = plp.LpProblem() opt_model.addConstraint( plp.LpConstraint(e=plp.lpSum(x_vars[j] for j in range(J)), sense=plp.LpConstraintEQ, rhs=K, name="constraint_%d" % 0)) for i in range(I): mask = np.where(D[i] == 1)[0] if len(mask) > 0: newConstraint = plp.LpConstraint( e=plp.lpSum(x_vars[j] - y_vars[i] for j in mask), sense=plp.LpConstraintGE, rhs=0, name="constraint_%d" % len(opt_model.constraints)) opt_model.addConstraint(newConstraint) objective = plp.lpSum(y_vars[i] for i in range(I)) opt_model.sense = plp.LpMaximize opt_model.setObjective(objective) opt_model.solve(plp.PULP_CBC_CMD(msg=0)) # opt_model.solve() solution = [] if opt_model.status == 1: for v in opt_model._variables: if v.varValue == 1 and v.name[0] == 'x': solution.append(int(v.name[2:])) opt_candidates = candidates[solution] return opt_candidates
def add_prefilled_constraints(prob, input_sudoku, grid_vars, rows, cols, values): for row in rows: for col in cols: if(input_sudoku[row][col] != 0): prob.addConstraint(plp.LpConstraint(e=plp.lpSum([grid_vars[row][col][value]*value for value in values]), sense=plp.LpConstraintEQ, rhs=input_sudoku[row][col], name=f"constraint_prefilled_{row}_{col}"))
def get_constraints(self): if len(self.get_input_totals()) != self.size: raise DimensionMismatchException(len(self.get_input_totals()), self.size) return (pulp.LpConstraint(self.get_input_totals()[i], sense=1, rhs=cons, name=self.name + str(i + 1)) for i, cons in enumerate(self.constraints))
def get_link_constraints(self): if self.fixed_locs: return None return [ pulp.LpConstraint( self.get_output_totals()[i] - max(self.constraints[i], 10000000000000000) * self.ys[i], sense=-1, rhs=0, name=self.name + '_link' + str(i)) for i in range(self.size) ]
def get_constraints(self): if len(self.get_input_totals()) != len(self.get_output_totals()): raise DimensionMismatchException(len(self.get_input_totals()), len(self.get_output_totals())) if len(self.get_input_totals()) != self.size: raise DimensionMismatchException(len(self.get_input_totals()), self.size) for i in range(self.size): yield pulp.LpConstraint(self.get_input_totals()[i] - self.get_output_totals()[i], sense=0, rhs=0, name=self.name + str(i + 1) + '_Clear') for i, cons in enumerate(self.constraints): if cons: yield pulp.LpConstraint(self.get_input_totals()[i], sense=-1, rhs=cons, name=self.name + str(i + 1))
def solveModel(capacity, timeVect, revenueVect): """Linear Optimization Model for NYC taxi rides selection. Params: @capacity: number of taxis the company owns @timeVect: binary 2D matrix with row representing each ride and column being time @revenueVect: Vector on revenue on each ride, ordering same as timeVect """ print("Solving model for " + str(capacity)) timeSectionNum = timeVect.shape[1] model = pulp.LpProblem("Profit maximizing problem", pulp.LpMaximize) tripNum = numpy.size(revenueVect) RANGE = range(tripNum) assignment = pulp.LpVariable.dicts('assignment', RANGE, cat='Binary') #Maximize revenue, set objective totalRev = 0 for j in range(tripNum): totalRev += assignment[j] * revenueVect[j][0] model += totalRev time = [] #print "Time Vect: ", timeVect for i in xrange(timeSectionNum): time.append( pulp.LpAffineExpression([(assignment[j], timeVect[j][i]) for j in range(tripNum)])) print('time') print(time) #Setting time constraint for temp in xrange(timeSectionNum): timeVal = time[temp] # print('timeVal') # print(timeVal) # print('capacity') # print(capacity) print(timeVal <= capacity) model += pulp.LpConstraint(e=timeVal, sense=-1, name=str(temp) + "time_constraint", rhs=capacity) print "Objective was: ", model optimization_result = model.solve() # print('Objective becomes') # print pulp.value(model.objective) # print('optimization_result') # print(optimization_result) # print(time) with open("result.csv", "wb") as out: writer = csv.writer(out) for i in xrange(tripNum): print(assignment[i].value()) writer.writerow(assignment[i].value())
def set_initial_state(mdl, current_df): # ----------------------------------------------------------------------- # # Set initial state # ----------------------------------------------------------------------- # for d in mdl.deps: mdl.addConstraint( plp.LpConstraint(e=mdl.o_vars[d, 0], sense=plp.LpConstraintEQ, rhs=current_df.at[d, "IVA"], name="initial_state_{0}".format(d))) return mdl
def con(self, affine, sense=0, rhs=0): # sum up (pulp doesnt do this) affine_ = {a: 0 for a, b in affine} for a, b in affine: affine_[a] += b affine = [(a, affine_[a]) for a in affine_] con = pl.LpConstraint(pl.LpAffineExpression(affine), sense=sense, rhs=rhs) self.mip += con return con