def get_elastic_constraints(self): """Instance method This method creates an instance of the class LinearConstraints where elastic/slack variables are added. Returns ------- E_linear_constraints : :class:`.LinearConstraints` Linear constraints with added pair of elastic (slack) variables to each constraint. """ E_linear_constraints = lc.LinearConstraints( self._linear_constraints.D_sites_modtypes, self._linear_constraints.specifications) L_econstraints = [] # initializing list of elastic constraints L_PuLP_econstraints = [] D_variables_modforms_ex = {} D_PuLP_variables_ex = {} # initializing extended dictionary # initializing extended dictionary for Modform objects D_variables_modforms_ex.update( self._linear_constraints.modform_space.D_variables_modforms) # initializing extended dictionary for LpVariable objects D_PuLP_variables_ex.update( self._linear_constraints.modform_space.D_PuLP_variables) for i in range(1, len(self._linear_constraints.L_linear_constraints) + 1): lhs = self._linear_constraints.L_linear_constraints[i - 1][0] elastic_variable1 = "e_%s" % (2 * i - 1) elastic_variable2 = "e_%s" % (2 * i) evariables_diff = " + " + elastic_variable1 + " - " + elastic_variable2 PuLP_evariable1 = pulp.LpVariable(elastic_variable1, lowBound=0) PuLP_evariable2 = pulp.LpVariable(elastic_variable2, lowBound=0) D_variables_modforms_ex[elastic_variable1] = modform.Modform( elastic_variable1) D_variables_modforms_ex[elastic_variable2] = modform.Modform( elastic_variable2) D_PuLP_variables_ex[elastic_variable1] = PuLP_evariable1 D_PuLP_variables_ex[elastic_variable2] = PuLP_evariable2 lhs_new = lhs + evariables_diff L_econstraints.append( (lhs_new, self._linear_constraints.L_linear_constraints[i - 1][1])) # lhs_PuLP = sum([ v[0] * v[1] for v in self._linear_constraints.L_PuLP_constraints[i - 1].items() ]) LHS = lhs_PuLP + PuLP_evariable1 - PuLP_evariable2 L_PuLP_econstraints.append( pulp.LpConstraint( LHS, rhs=float( self._linear_constraints.L_linear_constraints[i - 1][1]))) E_linear_constraints.L_linear_constraints = L_econstraints E_linear_constraints.L_PuLP_constraints = L_PuLP_econstraints E_linear_constraints.modform_space.D_variables_modforms = D_variables_modforms_ex E_linear_constraints.modform_space.D_PuLP_variables = D_PuLP_variables_ex return E_linear_constraints
def truncate(n, decimals=0): multiplier = 10**decimals return int(n * multiplier) / multiplier def round_up(n, decimals=0): multiplier = 10**decimals return math.ceil(n * multiplier) / multiplier # Create a LP Maximization problem Lp_copy = p.LpProblem('Problem', p.LpMaximize) # Knapsack problem x1 = p.LpVariable("x1", lowBound=0, upBound=1) x2 = p.LpVariable("x2", lowBound=0, upBound=1) x3 = p.LpVariable("x3", lowBound=0, upBound=1) x4 = p.LpVariable("x4", lowBound=0, upBound=1) x5 = p.LpVariable("x5", lowBound=0, upBound=1) x6 = p.LpVariable("x6", lowBound=0, upBound=1) x7 = p.LpVariable("x7", lowBound=0, upBound=1) x8 = p.LpVariable("x8", lowBound=0, upBound=1) x9 = p.LpVariable("x9", lowBound=0, upBound=1) x10 = p.LpVariable("x10", lowBound=0, upBound=1) x11 = p.LpVariable("x11", lowBound=0, upBound=1) x = [x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11] # Funkcja celu Lp_copy += 10 * x1 + 7 * x2 + 2 * x3 + 1 * x4 + 2 * x5 + 4 * x6 + 3 * x7 + 6 * x8 + 3 * x9 + 7 * x10 + 6 * x11
def create_thermal_plant_lp( pb,name): lp = pulp.LpProblem(name+".lp", pulp.LpMinimize) lp.setSolver() prod_vars = {} in_use_vars ={} turn_on_vars={} defaillance={} cout_proportionnel_defaillance=3000 #euros/MWh for t in pb.time_steps: prod_vars[t] = {} in_use_vars[t] = {} turn_on_vars[t] = {} defaillance[t]=pulp.LpVariable("defailance_"+str(t), 0.0,None ) for thermal_plant in pb.thermal_plants : #creation des variables ########################################################### var_name = "prod_"+str(t)+"_"+str(thermal_plant.name) prod_vars[t][thermal_plant] = pulp.LpVariable(var_name, 0.0, thermal_plant.pmax(t) ) var_name = "inUse_"+str(t)+"_"+str(thermal_plant.name) in_use_vars[t][thermal_plant] = pulp.LpVariable(var_name, cat="Binary") var_name = "turnon_"+str(t)+"_"+str(thermal_plant.name) turn_on_vars[t][thermal_plant] = pulp.LpVariable(var_name, cat="Binary") #creation des contraintes ########################################################### if thermal_plant.pmax(t)<=0.001: lp+=in_use_vars[t][thermal_plant]==0,"imposition_arret_"+str(t)+"_"+str(thermal_plant.name) constraint_name = "balance_"+ str(t) lp += pulp.lpSum([ prod_vars[t][thermal_plant] for thermal_plant in pb.thermal_plants ])+defaillance[t] == pb.demand[t], constraint_name for thermal_plant in pb.thermal_plants : constraint_name = "prod_min_" + str(thermal_plant) + "_" + str(t) lp += prod_vars[t][thermal_plant] >= in_use_vars[t][thermal_plant] * thermal_plant.pmin(t), constraint_name constraint_name = "prod_max_" + str(thermal_plant) + "_" + str(t) lp += prod_vars[t][thermal_plant] <= in_use_vars[t][thermal_plant] * thermal_plant.pmax(t), constraint_name if t != 0 : constraint_name = "demarrage_" + str(thermal_plant) + "_" + str(t) lp += in_use_vars[t][thermal_plant] - in_use_vars[t-1][thermal_plant] <= turn_on_vars[t][thermal_plant], constraint_name if t == 0 : constraint_name = "demarrage_" + str(thermal_plant) + "_" + str(t) lp += turn_on_vars[t][thermal_plant] >= in_use_vars[t][thermal_plant], constraint_name #creation de la fonction objectif ########################################################### lp.setObjective( pulp.lpSum([defaillance[t] for t in pb.time_steps])* pb.time_step_duration/60.0*cout_proportionnel_defaillance\ +pulp.lpSum([ turn_on_vars[t][thermal_plant]*thermal_plant.startup_cost+prod_vars[t][thermal_plant] * (thermal_plant.proportionnal_cost* pb.time_step_duration/60.0) for thermal_plant in pb.thermal_plants for t in pb.time_steps])) model=Model(lp,prod_vars) return model
import pulp # init linear optimization problem object LO_problem = pulp.LpProblem("knapsack_ILO", pulp.LpMaximize) # data (parameters) sizes = [5, 10, 2, 3, 5] weights = [4, 1, 2, 3, 4] rewards = [5, 8, 3, 2, 7] size_capacity = 20 weight_capacity = 10 n = len(sizes) # number of items # decision variables x = [pulp.LpVariable(f'x_{i}', cat='Binary') for i in range(n)] # objective function LO_problem += pulp.lpDot(x, rewards), "total_reward" # constraints LO_problem += pulp.lpDot(x, sizes) <= size_capacity, "size_capacity_constraint" LO_problem += pulp.lpDot( x, weights) <= weight_capacity, "weight_capacity_constraint" print(LO_problem) LO_problem.solve() print("Status:", pulp.LpStatus[LO_problem.status]) # each of the variables is printed with it's resolved optimum value for v in LO_problem.variables():
Imin = Imin * MW_H2 / density_H2 # m^3 Fmax_booster = Fmax_booster * MW_H2 / density_H2 # m^3 Fmax_prestorage = Fmax_prestorage * MW_H2 / density_H2 # m^3 ECF_booster = ECF_booster / MW_H2 * density_H2 #kWh/m^3 ECF_prestorage = ECF_prestorage / MW_H2 * density_H2 #kWh/m^3 #number of electrolyzer max N_electrolyzer_max = int(3510) # LP objective variable for transportation model LP_eps_3 = pulp.LpProblem('LP_eps_3', pulp.LpMaximize) LP_cost_3 = pulp.LpProblem('LP_cost_3', pulp.LpMinimize) N_electrolyzer_3 = pulp.LpVariable('N_electrolyzer_3', lowBound=0, cat='Integer') N_booster_3 = pulp.LpVariable('N_booster_3', lowBound=0, cat='Integer') N_prestorage_3 = pulp.LpVariable('N_prestorage_3', lowBound=0, cat='Integer') N_tank_3 = pulp.LpVariable('N_tank_3', lowBound=0, cat='Integer') alpha_3 = pulp.LpVariable.dicts( 'alpha_3', [str(i) for i in range(1, N_electrolyzer_max + 1)], cat='Binary') E_3 = pulp.LpVariable.dicts('E_3', [str(i) for i in input_df.index], lowBound=0, cat='Continuous')
Imin = Imin * MW_H2 / density_H2 # m^3 Fmax_prestorage = Fmax_prestorage * MW_H2 / density_H2 # m^3 ECF_prestorage = ECF_prestorage / MW_H2 * density_H2 #kWh/m^3 EMF_SMR = EMF_SMR * 0.001 / MW_H2 * density_H2 #tonne CO2/m^3 of H2 #number of electrolyzer max N_electrolyzer_max = int(3510) # Transportation model LP_eps_4 = pulp.LpProblem('LP_eps_4', pulp.LpMaximize) LP_cost_4 = pulp.LpProblem('LP_cost_4', pulp.LpMinimize) N_electrolyzer_4 = pulp.LpVariable('N_electrolyzer_4', lowBound=0, cat='Integer') N_prestorage_4 = pulp.LpVariable('N_prestorage_4', lowBound=0, cat='Integer') N_tank_4 = pulp.LpVariable('N_tank_4', lowBound=0, cat='Integer') alpha_4 = pulp.LpVariable.dicts( 'alpha_4', [str(i) for i in range(1, N_electrolyzer_max + 1)], cat='Binary') E_4 = pulp.LpVariable.dicts('E_4', [str(i) for i in input_df.index], lowBound=0, cat='Continuous') H2_4 = pulp.LpVariable.dicts('H2_4', [str(i) for i in input_df.index],
def runBikeShareMatchingLP(bikes, empty, valuations, tol, print_solution=False): # Get the number of stations and riders num_stations = len(bikes) num_riders = len(valuations) # Initialize LP prob = plp.LpProblem("Bike-Share Matching Problem", plp.LpMaximize) # Float variables x_ij \in [0,1] variables = [[[ plp.LpVariable("x_" + str(i) + "_" + str(s) + "_" + str(t), lowBound=0, upBound=1, cat='Integer') for t in range(0, num_stations) ] for s in range(0, num_stations)] for i in range(0, num_riders)] #variables = [[[plp.LpVariable("x_" + str(i) + "_" + str(s) + "_" + str(t), lowBound = 0 , upBound = 1, cat = 'Continuous') for t in range(0, num_stations)] for s in range(0, num_stations)] for i in range(0, num_riders)] # Welfare-maximizing objective funciton prob += sum(valuations[i][s][t] * variables[i][s][t] for t in range(0, num_stations) for s in range(0, num_stations) for i in range(0, num_riders)) # Each bidder is assigned at most one source-sink pair for i in range(0, num_riders): prob += sum(variables[i][s][t] for t in range(0, num_stations) for s in range(0, num_stations)) <= 1.0 # Each station s can only provide at most b_s bikes for k in range(0, num_riders): range_bidders = [i for i in range(0, num_riders) if i != k] for s in range(0, num_stations): for t in range(0, num_stations): prob += variables[k][s][t] + sum( variables[i][s][t_prime] for t_prime in range(0, num_stations) for i in range_bidders) <= bikes[s] # Each station t can only receive at most e_s bikes plus the number of bikes leaving the station for k in range(0, num_riders): range_bidders = [i for i in range(0, num_riders) if i != k] for s in range(0, num_stations): for t in range(0, num_stations): prob += variables[k][s][t] + sum( variables[i][s_prime][t] - variables[i][t][s_prime] for s_prime in range(0, num_stations) for i in range_bidders) <= empty[t] ''' # Each station s can only provide at most b_s bikes for s in range(0, num_stations): prob += sum(variables[i][s][t] for t in range(0, num_stations) for i in range(0, num_riders)) <= bikes[s] # Each station t can only receive at most e_s bikes plus the number of bikes leaving the station for t in range(0, num_stations): prob += sum(variables[i][s][t] - variables[i][t][s] for s in range(0, num_stations) for i in range(0, num_riders)) <= empty[t] # A constraint to avoid a user making space on its own for t in range(0, num_stations): prob += sum(variables[i][s][t] - variables[i][t][s] for s in range(0, num_stations) for i in range(0, num_riders)) <= empty[t] ''' # Save model prob.writeLP("BikeShareMatching.lp") # Solve prob.solve() print("program value", plp.value(prob.objective)) if (print_solution): printSolution(prob) return check_integer_values(plp, prob, tol)
def __init__(self, multi_circuit: MultiCircuit, verbose=False, allow_load_shedding=False, allow_generation_shedding=False): """ DC OPF problem :param multi_circuit: multi circuit instance :param verbose: verbose? :param allow_load_shedding: Allow load shedding? :param allow_generation_shedding: Allow generation shedding? """ # list of OP object islands self.opf_islands = list() # list of opf islands to solve apart (this allows to split the problem and only assign loads on a series) self.opf_islands_to_solve = list() # flags self.verbose = verbose self.allow_load_shedding = allow_load_shedding self.allow_generation_shedding = allow_generation_shedding # circuit compilation self.multi_circuit = multi_circuit self.numerical_circuit = self.multi_circuit.compile() self.islands = self.numerical_circuit.compute() # compile the indices # indices of generators that contribute to the static power vector 'S' self.gen_s_idx = np.where( (np.logical_not(self.numerical_circuit.controlled_gen_dispatchable) * self.numerical_circuit.controlled_gen_enabled) == True)[0] self.bat_s_idx = np.where( (np.logical_not(self.numerical_circuit.battery_dispatchable) * self.numerical_circuit.battery_enabled) == True)[0] # indices of generators that are to be optimized via the solution vector 'x' self.gen_x_idx = np.where( (self.numerical_circuit.controlled_gen_dispatchable * self.numerical_circuit.controlled_gen_enabled) == True)[0] self.bat_x_idx = np.where( (self.numerical_circuit.battery_dispatchable * self.numerical_circuit.battery_enabled) == True)[0] # get the devices self.controlled_generators = self.multi_circuit.get_controlled_generators( ) self.batteries = self.multi_circuit.get_batteries() self.loads = self.multi_circuit.get_loads() # shortcuts... nbus = self.numerical_circuit.nbus nbr = self.numerical_circuit.nbr ngen = len(self.controlled_generators) nbat = len(self.batteries) Sbase = self.multi_circuit.Sbase # bus angles self.theta = np.array([ pulp.LpVariable("Theta_" + str(i), -0.5, 0.5) for i in range(nbus) ]) # Generator variables (P and P shedding) self.controlled_generators_P = np.empty(ngen, dtype=object) self.controlled_generators_cost = np.zeros(ngen) self.generation_shedding = np.empty(ngen, dtype=object) for i, gen in enumerate(self.controlled_generators): name = 'GEN_' + gen.name + '_' + str(i) pmin = gen.Pmin / Sbase pmax = gen.Pmax / Sbase self.controlled_generators_P[i] = pulp.LpVariable( name + '_P', pmin, pmax) self.generation_shedding[i] = pulp.LpVariable( name + '_SHEDDING', 0.0, 1e20) self.controlled_generators_cost[i] = gen.Cost # Batteries self.battery_P = np.empty(nbat, dtype=object) self.battery_cost = np.zeros(nbat) self.battery_lower_bound = np.zeros(nbat) self.numerical_circuit.C_batt_bus = csc_matrix( self.numerical_circuit.C_batt_bus) for i, battery in enumerate(self.batteries): name = 'BAT_' + battery.name + '_' + str(i) pmin = battery.Pmin / Sbase pmax = battery.Pmax / Sbase self.battery_lower_bound[i] = pmin self.battery_P[i] = pulp.LpVariable(name + '_P', pmin, pmax) self.battery_cost[i] = battery.Cost # load shedding self.load_shedding = np.array([ pulp.LpVariable("LoadShed_" + load.name + '_' + str(i), 0.0, 1e20) for i, load in enumerate(self.loads) ]) # declare the loading slack vars self.slack_loading_ij_p = np.empty(nbr, dtype=object) self.slack_loading_ji_p = np.empty(nbr, dtype=object) self.slack_loading_ij_n = np.empty(nbr, dtype=object) self.slack_loading_ji_n = np.empty(nbr, dtype=object) for i in range(nbr): self.slack_loading_ij_p[i] = pulp.LpVariable( "LoadingSlack_ij_p_" + str(i), 0, 1e20) self.slack_loading_ji_p[i] = pulp.LpVariable( "LoadingSlack_ji_p_" + str(i), 0, 1e20) self.slack_loading_ij_n[i] = pulp.LpVariable( "LoadingSlack_ij_n_" + str(i), 0, 1e20) self.slack_loading_ji_n[i] = pulp.LpVariable( "LoadingSlack_ji_n_" + str(i), 0, 1e20) self.branch_flows_ij = np.empty(nbr, dtype=object) self.branch_flows_ji = np.empty(nbr, dtype=object) self.converged = False
def lp_solve(self, weight_of_corner=1): ''' Use linear programming to solve min cost flow problem, make it possible to define constrains. Alert: pulp will automatically transfer node's name into str and repalce some special chars into '_', and will throw a error if there are variables' name duplicated. ''' prob = pulp.LpProblem() # minimize var_dict = {} varname2tuple = {} for u, v, he_id in self.flow_network.edges: var_dict[u, v, he_id] = pulp.LpVariable( f'{u}{v}{he_id}', self.flow_network[u][v][he_id]['lowerbound'], self.flow_network[u][v][he_id]['capacity'], pulp.LpInteger) # pulp will replace ' ' with '_' automatically varname2tuple[f'{u}{v}{he_id}'.replace(' ', "_")] = (u, v, he_id) objs = [] for he in self.planar.dcel.half_edges.values(): lf, rf = he.twin.inc.id, he.inc.id objs.append(self.flow_network[lf][rf][he.id]['weight'] * var_dict[lf, rf, he.id]) # bend points' cost if weight_of_corner != 0: for v in self.planar.G: if self.planar.G.degree(v) == 2: (f1, he1_id), (f2, he2_id) = [ (f, key) for f, keys in self.flow_network.adj[v].items() for key in keys ] x = var_dict[v, f1, he1_id] y = var_dict[v, f2, he2_id] p = pulp.LpVariable(x.name + "temp", None, None, pulp.LpInteger) prob.addConstraint(x - y <= p) prob.addConstraint(y - x <= p) objs.append(weight_of_corner * p) prob += pulp.lpSum(objs) # number of bends in graph for f in self.planar.dcel.faces: prob += self.flow_network.nodes[f]['demand'] == pulp.lpSum([ var_dict[v, f, he_id] for v, _, he_id in self.flow_network.in_edges(f, keys=True) ]) for v in self.planar.G: prob += -self.flow_network.nodes[v]['demand'] == pulp.lpSum([ var_dict[v, f, he_id] for _, f, he_id in self.flow_network.out_edges(v, keys=True) ]) state = prob.solve() res = defaultdict(lambda: defaultdict(dict)) if state == 1: # update flow_dict self.flow_network.cost = pulp.value(prob.objective) for var in prob.variables(): if var.name in varname2tuple: u, v, he_id = varname2tuple[var.name] res[u][v][he_id] = int(var.varValue) else: raise Exception("Problem can't be solved by linear programming") return res
'discount': 0.04 }, { 'base': 8, 'discount': 0.07 }] banana_shopping = pulp.LpProblem('Banana Shopping', pulp.LpMaximize) banana_price = [[ round(banana_price(scheme['base'], scheme['discount'], b), 2) for b in range(total_bananas_per_vendor + 1) ] for scheme in vendor_schema] bananas = [range(total_bananas_per_vendor + 1) for i in range(total_vendors)] selected_bananas = [[ pulp.LpVariable('vendor_' + str(i) + '_' + str(j) + '_bananas', cat='Binary') for j in range(total_bananas_per_vendor + 1) ] for i in range(1, total_vendors + 1)] for i in range(total_vendors): banana_shopping += pulp.lpSum([ selected_bananas[i][j] for j in range(total_bananas_per_vendor + 1) ]) == 1, 'SOS constraint ' + str(i) total_bananas = flatten([[ selected_bananas[i][j] * bananas[i][j] for j in range(total_bananas_per_vendor + 1) ] for i in range(total_vendors)]) banana_shopping += pulp.lpSum( total_bananas ) <= total_vendors * total_bananas_per_vendor, 'Total available bananas'
#!/usr/bin/python3 # import sys !{sys.executable} -m pip install pulp # import the library pulp as p import pulp as p # Create a LP Minimization problem Lp_prob = p.LpProblem('Problem', p.LpMaximize) # Create problem Variables x1 = p.LpVariable("x1", lowBound=0) # Create a variable x1 >= 0 x2 = p.LpVariable("x2", lowBound=0) # Create a variable x2 >= 0 # Objective Function Lp_prob += 40 * x1 + 30 * x2 # Constraints: x3 = p.LpVariable("x3", lowBound=0) Lp_prob += 16 - x1 - 2 * x2 == x3 x4 = p.LpVariable("x4", lowBound=0) Lp_prob += 9 - x1 - x2 == x4 x5 = p.LpVariable("x5", lowBound=0) Lp_prob += 24 - 3 * x1 - 2 * x2 == x5 # Display the problem print(Lp_prob) status = Lp_prob.solve() # Solver print(p.LpStatus[status]) # The solution status # Printing the final solution print(p.value(x1), p.value(x2), p.value(Lp_prob.objective))
#souce https://www.geeksforgeeks.org/python-linear-programming-in-pulp/ # import the library pulp as p import pulp as p # Create problem Variables bin1 = p.LpVariable("bin1", 0, 10) bin2 = p.LpVariable("bin2",0, 10) bin3 = p.LpVariable("bin3",0, 10) bin4 = p.LpVariable("bin4",0,10) bin5 = p.LpVariable("bin5",0,10) bin6 = p.LpVariable("bin6",0,10) Y1 = p.LpVariable("Y1",0,1) Y2 = p.LpVariable("Y2",0,1) Y3 = p.LpVariable("Y3",0,1) Y4 = p.LpVariable("Y4",0,1) Y5 = p.LpVariable("Y5",0,1) Y6 = p.LpVariable("Y6",0,1) X11 = p.LpVariable("X1-1",0,1) X12 = p.LpVariable("X1-2",0,1) X13 = p.LpVariable("X1-3",0,1) X14 = p.LpVariable("X1-4",0,1) X15 = p.LpVariable("X1-5",0,1) X16 = p.LpVariable("X1-6",0,1) X21 = p.LpVariable("X2-1",0,1) X22 = p.LpVariable("X2-2",0,1) X23 = p.LpVariable("X2-3",0,1) X24 = p.LpVariable("X2-4",0,1) X25 = p.LpVariable("X2-5",0,1)
# define objective function(projected points) and constraints objectiveFunction = '' numPlayersConstraint = '' costConstraint = '' df['temp_index'] = df.index # create pulp variables for each player's row and build constraints for uniqueColumn in df[teamColumn].unique(): tempConstraint = '' for index, row in df.loc[df[teamColumn] == uniqueColumn].iterrows(): varName = 'p' + str(row['temp_index']) variable = pulp.LpVariable( varName, lowBound=0, upBound=1, cat=pulp.LpInteger ) #make binary player variable(0 for not in lineup, 1 for in lineup) #update constraints with player's projections and cost objectiveFunction += row[projectionsColumn] * variable numPlayersConstraint += variable costConstraint += row[budgetColumn] * variable tempConstraint += variable prob += (tempConstraint <= maxSameTeam) # add objective function(projected points), the number of players chosen constraint, cost constraint, position constraints, and team constraints to problem prob += objectiveFunction prob += (numPlayersConstraint == numPlayers) prob += (costConstraint <= budget)
def get_feasible_linear_constraints(self): """Instance method * This method obtains set of feasible linear constraints and populated the instance attribute, ``feasible_linear_constraints``. * Linear programming algorithm is employed with slack variables """ E_constraints = self.get_elastic_constraints() # trying something new ############################################### # additional constraints L_evariables_sorted = sorted([ k for k, v in E_constraints.modform_space.D_PuLP_variables.iteritems( ) if k[0] == 'e' ], key=natural_keys) L_PuLP_evariables_sorted = [ E_constraints.modform_space.D_PuLP_variables[k] for k in L_evariables_sorted ] L_extra_PuLP_constraints = [] # e.g., -t <= e_1-e_2 <= t t_var = pulp.LpVariable('t', lowBound=0) for ii in xrange(0, len(L_PuLP_evariables_sorted), 2): e1 = L_evariables_sorted[ii] e2 = L_evariables_sorted[ii + 1] #e1_e2 - t <= 0; sense=-1 sets LE-- less than equal to inequality LHS_1 = E_constraints.modform_space.D_PuLP_variables[ e1] - E_constraints.modform_space.D_PuLP_variables[e2] - t_var L_extra_PuLP_constraints.append( pulp.LpConstraint(LHS_1, rhs=0, sense=-1)) # e1-e2 +t >= 0; sense=1 sets GE-- greater than equal to inequality LHS_2 = E_constraints.modform_space.D_PuLP_variables[ e1] - E_constraints.modform_space.D_PuLP_variables[e2] + t_var L_extra_PuLP_constraints.append( pulp.LpConstraint(LHS_2, rhs=0, sense=1)) #end for ii in xrange(0, len(L_PuLP_evariables_sorted), 2) #L_PuLP_constraints_extended = list(E_constraints.L_PuLP_constraints) E_constraints.L_PuLP_constraints.extend(L_extra_PuLP_constraints) #objective_function_PuLP_extended = t_var + pulp.lpSum(L_PuLP_evariables_sorted) ################################################# lp_solver = lps.LinearProgrammingSolver(E_constraints) #L_variables_sorted = sorted([k for k,v in E_constraints.D_PuLP_variables.iteritems() if k[0]=='e'], key=natural_keys) #L_PuLP_evariables_sorted = [E_constraints.D_PuLP_variables[k] for k in L_variables_sorted] objective_function_PuLP = pulp.lpSum(L_PuLP_evariables_sorted) + t_var lp_minimize_solution = lp_solver.linear_programming_solver( objective_function_PuLP, pulp.LpMinimize) #print(lp_minimize_solution) #print("status: ", LpStatus[lp_minimize_solution.status]) #for v in lp_minimize_solution.variables(): # print(v, pulp.value(v)) for i in range(1, len(self._linear_constraints.L_linear_constraints) + 1): elastic_variable1 = "e_%s" % (2 * i - 1) elastic_variable2 = "e_%s" % (2 * i) value_PuLP_evariable1 = pulp.value( E_constraints.modform_space.D_PuLP_variables[elastic_variable1] ) value_PuLP_evariable2 = pulp.value( E_constraints.modform_space.D_PuLP_variables[elastic_variable2] ) diff = value_PuLP_evariable1 - value_PuLP_evariable2 adjusted_rhs = float( self._linear_constraints.L_linear_constraints[i - 1][1]) - diff self._feasible_linear_constraints.L_linear_constraints.append( (self._linear_constraints.L_linear_constraints[i - 1][0], adjusted_rhs)) lhs_PuLP = sum([ v[0] * v[1] for v in self._linear_constraints.L_PuLP_constraints[i - 1].items() ]) self._feasible_linear_constraints.L_PuLP_constraints.append( pulp.LpConstraint(lhs_PuLP, rhs=float(adjusted_rhs)))
import numpy as np # Исходные данные (прямой задачи). # Первые 2 элемента - коэффициенты в ограничениях прямой задачи. # Третий элемент - коэффициенты целевой функции. initial_data = np.array([[-2, -1, 6], [-1, 3, 9], [1, 1, 0]]) # Начинаем процесс перехода к двойственной задаче. b = initial_data.transpose() # Создаем задачу минимизации LP (т. к. для прямой задачи была максимизация). task = pl.LpProblem("problem", pl.LpMinimize) # Каждое ограничение прямой задачи становится двойственной переменной. # Первый агрумент - имя переменной, второй и третий - ограничения слева и справа соответсвенно. y1 = pl.LpVariable('y1', None, 0) y2 = pl.LpVariable('y2', 0, None) # Целевая функция двойственной задачи. task += (b[2, 0] * y1 + b[2, 1] * y2) # Каждая переменная прямой задачи становится двойственным ограничением. # Коэффициент двойственной переменной в двойственных ограничениях равен коэффициенту переменной из ограничения прямой задачи. task += (b[0, 0] * y1 + b[0, 1] * y2 >= b[0, 2]) task += (b[1, 0] * y1 + b[1, 1] * y2 >= b[1, 2]) # Решаем двойственную задачу. status = task.solve() # Вывод результатов. print("Results:")
def main(): # 変数 # タイムスロット 6*n * 教科 5 total_slot = sum(subjects.values()) v = {} for s in subjects.keys(): v[s] = {} for x in days: v[s][x] = {} for y in timeslot: v[s][x][y] = {} for r in rooms: v[s][x][y][r] = pulp.LpVariable(f'var_{s}_{x}_{y}_{r}', lowBound=0, upBound=1, cat=pulp.LpInteger) problem = pulp.LpProblem("時間割", pulp.LpMinimize) problem += pulp.lpSum([ v[s][x][y][r] * x for s in subjects.keys() for x in days for y in timeslot for r in rooms ]) # 各教科は必要コマ数実施 for s in subjects.keys(): for r in rooms: problem += pulp.lpSum( [v[s][x][y][r] for x in days for y in timeslot]) == subjects[s] # 同一教科は同一コマに先生の数未満 for s in subjects.keys(): for x in days: for y in timeslot: problem += pulp.lpSum([v[s][x][y][r] for r in rooms]) <= teachers[s] # 同一コマ+同一クラスは1教科のみ for x in days: for y in timeslot: for r in rooms: problem += pulp.lpSum([v[s][x][y][r] for s in subjects.keys()]) <= 1 # クラスの一日の同一教科は2まで for s in subjects.keys(): for x in days: for r in rooms: problem += pulp.lpSum([v[s][x][y][r] for y in timeslot]) <= 2 solver = pulp.PULP_CBC_CMD(msg=False) result = problem.solve(solver) print(pulp.LpStatus[result]) # print(pulp.value(problem.objective)) if result == pulp.LpStatusOptimal: for x in days: print(x, end=": ") for y in timeslot: print(y, end="(") for r in rooms: for s in subjects.keys(): if pulp.value(v[s][x][y][r]) == 1: print(r, s, end=",") print(")", end=', ') print()
def get_underapprox_box(activation_pattern, weights, biases, min_val, max_val, additional_constraints, epsilon): def get_w_t_x(weight_vector, pulpInputs): w_t_x = [] num_inputs = len(weight_vector) for i in range(num_inputs): coeff = weight_vector[i] if coeff >= 0: w_t_x.append(coeff * pulpInputs[i][1]) else: w_t_x.append(coeff * pulpInputs[i][0]) return w_t_x num_inputs = weights[0].shape[1] pulpInputs = [] for i in range(num_inputs): var_name = 'x' + str(i) hi = var_name + '_hi' lo = var_name + '_low' d_hi = pulp.LpVariable(hi, lowBound=min_val, upBound=max_val, cat='Continuous') d_lo = pulp.LpVariable(lo, lowBound=min_val, upBound=max_val, cat='Continuous') pulpInputs.append((d_lo, d_hi)) prob = pulp.LpProblem("Box", pulp.LpMaximize) prob += pulp.lpSum([ (pulpInputs[i][1] - pulpInputs[i][0]) for i in range(num_inputs) ]), "Total Range is Maximized" for i in range(num_inputs): prob += (pulpInputs[i][1] - pulpInputs[i][0] ) >= 0, "High > Low Constraint for x_" + str(i) for layer_id, layer in enumerate(activation_pattern): weight_matrix = weights[layer_id] bias_vector = biases[layer_id] for neuron_id, neuron in enumerate(layer): if neuron == 2: continue weight_vector = weight_matrix[neuron_id] b = bias_vector[neuron_id] constraint_name = "activation constraint for neuron" + str( layer_id) + "_" + str(neuron_id) if neuron == 0: w_t_x = get_w_t_x(weight_vector, pulpInputs) prob += pulp.lpSum(w_t_x) <= -1 * b, constraint_name elif neuron == 1: w_t_x = get_w_t_x(-1 * weight_vector, pulpInputs) prob += pulp.lpSum(w_t_x) <= (b - UPPER_THRESH), constraint_name for constraint_id, constraint in enumerate(additional_constraints): diff_weight, diff_bias = constraint w_t_x = get_w_t_x(-1 * diff_weight, pulpInputs) constraint_name = "additinal property constraint " + str(constraint_id) rhs = -1 * epsilon + diff_bias - UPPER_THRESH prob += pulp.lpSum(w_t_x) <= rhs, constraint_name # print (prob) status = prob.solve() result = pulp.LpStatus[status] print(result) under_approx_box = [] if result == 'Infeasible': for i in range(num_inputs): under_approx_box.append((0, 0)) return under_approx_box, 0, 0 assert result == 'Optimal', "The under-approximate constraint problem fails to give optimal solution" for i in range(num_inputs): under_approx_box.append( (pulp.value(pulpInputs[i][0]), pulp.value(pulpInputs[i][1]))) perimeter = 0.0 volume = 1.0 for i in range(num_inputs): volume *= (pulp.value(pulpInputs[i][1]) - pulp.value(pulpInputs[i][0])) perimeter += pulp.value(pulpInputs[i][1]) - pulp.value( pulpInputs[i][0]) return under_approx_box, volume, perimeter
return STOCK if __name__ == '__main__': file_path = '../data/truck_instance_base.data' graph, p, start, n_clientsuppr, n_depsuppr, Entity = extract_donnes(file_path) file_path = '../data/truck_instance_base.data' graph, p, start, n_clientsuppr, n_depsuppr, Entity = extract_donnes(file_path) prob,COUTSTAUXDOU = set_model_cout_net(graph, p, start, n_clientsuppr, n_depsuppr,Entity) #prob.solve(pl.PULP_CBC_CMD(logPath='./output_file/CBC_max_flow.log')) prob.solve() qr = pl.LpVariable("qr", LpInteger) gpu = pl.LpVariable("QteGPU", LpInteger) coutsTotal = pl.LpVariable("coutsTotal", LpInteger) Benefice = pl.LpVariable("Benefice", LpInteger) Route_utilises=0 #Optimal print("Status:", pl.LpStatus[prob.status]) nx.write_graphml(graph, "graph_routes.graphml") # ------------------------------------------------------------------------ # # Print the solver output # ------------------------------------------------------------------------ # print(f'Status:\n{pl.LpStatus[prob.status]}')
def optimize(self): """ Run the optimization. set solution in self.X set state STATE_SOLVED_OK if solved, otherwise STATE_SOLVED_BAD """ assert self.state != self.STATE_UNDEFINED,\ "set_data() must be called before optimize()!" self.atm = self.models['ATM'] self.lnd = self.models['LND'] self.ice = self.models['ICE'] self.ocn = self.models['OCN'] self.real_variables = [ 'TotalTime', 'T1', 'Tice', 'Tlnd', 'Tatm', 'Tocn' ] self.integer_variables = [ 'NBice', 'NBlnd', 'NBatm', 'NBocn', 'Nice', 'Nlnd', 'Natm', 'Nocn' ] self.X = {} X = self.X self.prob = pulp.LpProblem("Minimize ACME time cost", pulp.LpMinimize) for rv in self.real_variables: X[rv] = pulp.LpVariable(rv, lowBound=0) for iv in self.integer_variables: X[iv] = pulp.LpVariable(iv, lowBound=1, cat=pulp.LpInteger) # cost function self.prob += X['TotalTime'] #constraints self.constraints = [] # Layout-dependent constraints. Choosing another layout to model # will require editing these constraints self.constraints.append([X['Tice'] - X['T1'] <= 0, "Tice - T1 == 0"]) self.constraints.append([X['Tlnd'] - X['T1'] <= 0, "Tlnd - T1 == 0"]) self.constraints.append([ X['T1'] + X['Tatm'] - X['TotalTime'] <= 0, "T1 + Tatm - TotalTime <= 0" ]) self.constraints.append( [X['Tocn'] - X['TotalTime'] <= 0, "Tocn - TotalTime == 0"]) self.constraints.append([ X['Nice'] + X['Nlnd'] - X['Natm'] == 0, "Nice + Nlnd - Natm == 0" ]) self.constraints.append([ X['Natm'] + X['Nocn'] == self.maxtasks, "Natm + Nocn <= %d" % (self.maxtasks) ]) self.constraints.append([ self.atm.blocksize * X['NBatm'] - X['Natm'] == 0, "Natm = %d * NBatm" % self.atm.blocksize ]) self.constraints.append([ self.ice.blocksize * X['NBice'] - X['Nice'] == 0, "Nice = %d * NBice" % self.ice.blocksize ]) self.constraints.append([ self.lnd.blocksize * X['NBlnd'] - X['Nlnd'] == 0, "Nlnd = %d * NBlnd" % self.lnd.blocksize ]) self.constraints.append([ self.ocn.blocksize * X['NBocn'] - X['Nocn'] == 0, "Nocn = %d * NBocn" % self.ocn.blocksize ]) # These are the constraints based on the timing data. # They should be the same no matter what the layout of the components. self.add_model_constraints() for c, s in self.constraints: self.prob += c, s # Write the program to file and solve (using coin-cbc) self.prob.writeLP("IceLndAtmOcn_model.lp") self.prob.solve() self.set_state(self.prob.status) return self.state
def process(G, bound, root, kappa='tree', c=None, reduction=False, margin=8): depths = {x: float('inf') for x in G.nodes()} current_level = deque([root]) next_level = deque() parent = {} depth = 0 res = nx.DiGraph() count = 0 while True: for n in current_level: depths[n] = depth count += 1 for (u, v, d) in G.edges([n], data=True): assert (n == u) if d['weight'] <= bound: found_in_current_level = v in next_level in_current_level = v in current_level if in_current_level: # v on same level pass elif depths[v] != float('inf'): # back edge res.add_edge( v, n) # other direction to enable removing leafs else: # forward edge if not found_in_current_level: # check if weak link to lower nodes exists (current level is ok!) avoid = False for (w, y, e) in G.edges([v], data=True): assert (w == v) if e['weight'] <= bound + margin: if depths[y] < depth: # avoid nodes with weak edges to lower nodes! avoid = True break if not avoid: next_level.append(v) if reduction: parent[v] = u if len(next_level) >= kappa_fun( kappa, depth + 1): # depth for next level, so +1 current_level = next_level next_level = deque() depth += 1 else: break if reduction: K = res.to_undirected() prob = pulp.LpProblem("NodeReduction", pulp.LpMinimize) x = { n: pulp.LpVariable("Node_" + str(n), 0, 1, pulp.LpInteger) for n in K.nodes() } prob += sum(x.values()) # minimize objective function for j in range(1, depth + 1): prob += sum([v for k, v in x.items() if depths[k] == j ]) >= kappa_fun(kappa, j) for n in K.nodes(): if n == root: continue potential_parents = [ x[v] for (u, v) in K.edges([n]) if depths[u] > depths[v] ] prob += x[n] <= sum(potential_parents) prob.solve() for n in K.nodes(): if not x[n].varValue == 1: res.remove_node(n) count = len(res.nodes()) dat = [{ 'bound': bound, 'root': root, 'depth': depth, 'allnodes': len(G.nodes()), 'nodes': count }] if res is not None: if len(res.edges()) > 1: dat[0]['maxweight'] = max( [G[u][v]['weight'] for (u, v) in res.edges()]) else: dat[0]['maxweight'] = 0 return dat, res
def addVar(name): varname = 'targetVariable[' + str(len(targetVariable)) + ']' var = pulp.LpVariable(varname, lowBound=parameter.activeThreshold) weightIndex[name] = var targetVariable.append(var) return varname
def _init_var(self): self._var = pulp.LpVariable(self.name, lowBound=self.min, upBound=self.max, cat="Integer")
list_values = [] for x in range(len(a)): c.append((-2) ** x) print(c) multi_output = [v * s for v, s in zip(a, c)] total = sum(multi_output) c_val = math.ceil(total/2) b = [] for x in range(c_val): b.append((-2) ** x) x = p.LpVariable("x", dicts=b) y = p.LpVariable("y", lowBound = 0) list_values = [] for x in range(len(A)): list_values.append((-2) ** x) multi_output = [v * s for v, s in zip(A, list_values)] c_val = math.ceil(total/2) possible_vals = [] for x in range(c_val): possible_vals.append((-2) ** x) all_ones = []
path_to_cplex = r'C:/Program Files/IBM/ILOG/CPLEX_Studio_Community201/cplex/bin/x64_win64/cplex.exe' import pulp as pl model = pl.LpProblem("Example", pl.LpMinimize) solver = pl.CPLEX_CMD(path=path_to_cplex) _var = pl.LpVariable('a') _var2 = pl.LpVariable('a2') model += _var + _var2 == 1 print("test") result = model.solve(solver) """ facc58cf08ee0-pulp.sol Minimize OBJ: __dummy Subject To _C1: a + a2 = 1 Bounds __dummy = 0 a free a2 free End """ print(result)
def solve_lp(self, x, y): y = y.detach().numpy() x = x.view(-1, 28 * 28) #xp = F.relu(self.fc1(x)) #xp.sum().backward() #make sure grad is there #xp= xp.detach().numpy() #xp = self.fc1(x).detach().numpy() #print(xp.shape) # 64 x 10 w = self.fc1.weight.detach().numpy() b = self.fc1.bias.detach().numpy() xpp = np.matmul(x, w.T) + b lp_vars_w = [] for ii in range(10): lp_vars_w.append([]) for i in range(28 * 28): lp_vars_w[-1].append( pulp.LpVariable('w%d_%d' % (ii, i), lowBound=w[ii][i] - 1, upBound=w[ii][i] + 1, cat='Continuous')) lp_vars_b = [] for i in range(10): lp_vars_b.append( pulp.LpVariable('b%d' % i, lowBound=b[i] - 1, upBound=b[1] + 1, cat='Continuous')) problem = [] constraints = [] for target_idx in range(len(y)): target = y[target_idx] for idx in range(10): if xpp[target_idx][idx] < 0: #S w_i * x_i + b <= 0 #constraints.append(sum([ lp_vars_w[j] * x[target_idx][j].item() for j in range(28*28)]) <= 0) constraints.append( sum([ lp_vars_w[idx][j] * x[target_idx][j].item() for j in range(28 * 28) ] + lp_vars_b[idx]) <= 0.1) else: #S w_i * x_i + b <= 0 #constraints.append(sum([ lp_vars_w[j] * x[target_idx][j].item() for j in range(28*28)]) >= 0) constraints.append( sum([ lp_vars_w[idx][j] * x[target_idx][j].item() for j in range(28 * 28) ] + lp_vars_b[idx]) >= -0.1) if target == idx: problem.append( sum([ lp_vars_w[idx][j] * x[target_idx][j].item() for j in range(28 * 28) ] + lp_vars_b[idx])) #problem.append(sum([ lp_vars_w[j] for j in range(28*28)])) else: problem.append( sum([ -lp_vars_w[idx][j] * x[target_idx][j].item() for j in range(28 * 28) ] + lp_vars_b[idx])) #problem.append(sum([ - lp_vars_w[j] for j in range(28*28)])) lp_max = pulp.LpProblem("nn", pulp.LpMaximize) lp_max += sum(problem), "Z" for constraint in constraints: lp_max += constraint lp_max.solve() print(pulp.LpStatus[lp_max.status]) #zero the grad #self.fc1.bias.grad.data.fill_(0) #self.fc1.weight.grad.data.fill_(1) for variable in lp_max.variables(): if variable.name[0] == 'w': ii, i = map(int, variable.name[1:].split('_')) self.fc1.weight[ii][i] = float(variable.varValue) elif variable.name[0] == 'b': i = int(variable.name[1:]) self.fc1.bias[i] = float(variable.varValue)
def add_adjacent_variables_constraints_m1(self) -> None: """Method to create LP variables for each pair of adjacent geometries (using mode 1). """ logging.debug("method add_adjacent_variables_constraints_m1 called") combinations = set() for i in tqdm(range(self.gdf.shape[0]), desc="Construction LP"): for j in range(self.gdf.shape[0]): if j == i: # We don't check the adjacency with itself. continue if (i, j) in combinations or (j, i) in combinations: # If the combination already exists we skip it. continue # Create a set with all possible combinations to optimize. combinations.add((i, j)) for i, j in combinations: # Create the variables for the optimal horizontal en vertical length between p_i en p_j h = p.LpVariable(f"h_{i}_{j}") v = p.LpVariable(f"v_{i}_{j}") self.problem += h >= 0 self.problem += v >= 0 # Calculate the minimum length between i en j based on their width w = self.gdf.at[i, "geom_size"] + self.gdf.at[j, "geom_size"] # Add a gap if they are non-adjacent perimeters = [ np for np in self.gdf.iloc[i, :]["_neighbors"].split(",") ] neighbors = [ n for n in self.gdf.iloc[i, :]["_neighbors"].split(",") ] if str(j) in neighbors or True: gap = 0 # if float(perimeters[neighbors.index(str(j))]) > 0.1 or True: if True: self._distances.append(h) self._distances.append(v) else: gap = self.gap_size # Check whether the neighbors should be connected horizontally or vertically. geom_dist_x = self.gdf.at[j, "geometry"].x - self.gdf.at[i, "geometry"].x geom_dist_y = self.gdf.at[j, "geometry"].y - self.gdf.at[i, "geometry"].y # Depending on whether x_i - x_j yields a positive or negative result we decide the order # in which they are presented in the constraints. if geom_dist_x > 0: if abs(geom_dist_x) > abs(geom_dist_y): # Add constraint 1 self.problem += (self._coord_dict[j]["x"] - self._coord_dict[i]["x"] >= w + gap) # Add constraint 3 self.problem += (h >= self._coord_dict[j]["x"] - self._coord_dict[i]["x"] - w) else: if abs(geom_dist_x) > abs(geom_dist_y): # Add constraint 1 self.problem += (self._coord_dict[i]["x"] - self._coord_dict[j]["x"] >= w + gap) # Add constraint 3 self.problem += (h >= self._coord_dict[i]["x"] - self._coord_dict[j]["x"] - w) # Depending on whether y_i - y_j yields a positive or negative result we decide the order # in which they are presented in the constraints. if geom_dist_y > 0: if not abs(geom_dist_x) > abs(geom_dist_y): # Add constraint 2 self.problem += (self._coord_dict[j]["y"] - self._coord_dict[i]["y"] >= w + gap) # Add constraint 4 self.problem += (v >= self._coord_dict[j]["y"] - self._coord_dict[i]["y"] - w) else: if not abs(geom_dist_x) > abs(geom_dist_y): # Add constraint 2 self.problem += (self._coord_dict[i]["y"] - self._coord_dict[j]["y"] >= w + gap) # Add constraint 4 self.problem += (v >= self._coord_dict[i]["y"] - self._coord_dict[j]["y"] - w) # Define the objective self.problem += p.lpSum(self._distances)
def V1G_optimization(): #this is the function for managed charging # initiate the problem statement model=lp.LpProblem('Minimize_Distribution_level_Peak_Valley_Difference', lp.LpMinimize) #define optimization variables veh_V1G=range(n_V1G_Veh) time_Interval=range(24) chargeprofiles=lp.LpVariable.dicts('charging_profiles', ((i,j) for i in veh_V1G for j in time_Interval), lowBound=0.1, upBound=power_V1GUppper) chargestates=lp.LpVariable.dicts('charging_states', ((i,j) for i in veh_V1G for j in time_Interval), cat='Binary') total_load=lp.LpVariable.dicts('total_load', time_Interval,lowBound=0.1) max_load=lp.LpVariable('max_load', lowBound=0) min_load=lp.LpVariable('min_load', lowBound=0) # define objective function model += max_load - min_load #model += max_load # define constraints for t in time_Interval: # constraint 1 & 2: to identify the max and min loads model += total_load[t] <= max_load model += total_load[t] >= min_load for t in time_Interval: # constraint 3: calculate the total load at each time interval t if opt_includeSolar == 0: model += lp.lpSum( [chargeprofiles[i,t]] for i in veh_V1G) + base_Load[t] + unmanaged_Load[t] == total_load[t] else: model += lp.lpSum([chargeprofiles[i, t]] for i in veh_V1G) + base_Load[t] + unmanaged_Load[t] - solarCurve[t] == total_load[t] for i in veh_V1G: # constraint 4: constraint on charging powers for each EV: only optimize the charge profile between start and end charging time temp_start=v1g_startingTime[i] temp_end=v1g_endingTime[i] if temp_start >= temp_end: for t in range (temp_end): model += chargeprofiles[i,t] <= chargestates[i,t] * power_V1GUppper model += chargeprofiles[i,t] >= chargestates[i,t] * power_V1GLower for t in range(temp_end, temp_start, 1): model += chargeprofiles[i,t] == 0 model += chargestates[i,t] == 0 for t in range(temp_start, 24, 1): model += chargeprofiles[i,t] <= chargestates[i,t] * power_V1GUppper model += chargeprofiles[i,t] >= chargestates[i,t] * power_V1GLower if temp_start < temp_end: for t in range(temp_start): model += chargeprofiles[i,t] == 0 model += chargestates[i,t] ==0 for t in range(temp_start, temp_end, 1): model += chargeprofiles[i,t] <= chargestates[i,t] * power_V1GUppper model += chargeprofiles[i,t] >= chargestates[i,t] * power_V1GLower for t in range(temp_end, 24, 1): model += chargeprofiles[i,t] == 0 model += chargestates[i,t]==0 for i in veh_V1G: # constraint 5: SOC constraint, cannot be greater than 1, end_SOC must be above certain levels temp_start=v1g_startingTime[i] temp_end=v1g_endingTime[i] temp_startSOC=v1g_startingSOC[i] if temp_start >= temp_end: for t in range(temp_start+1, 24, 1): temp_timer = range (temp_start, t, 1) model += temp_startSOC + lp.lpSum( [chargeprofiles[i,tn] *charge_efficiency/batteryCapacity] for tn in temp_timer) <=1 for t in range (0, temp_end+1, 1): temp_timer = range (0, t, 1) model += temp_startSOC + lp.lpSum( [chargeprofiles[i,tn] *charge_efficiency/batteryCapacity] for tn in range(temp_start, 24,1)) \ + lp.lpSum( [chargeprofiles[i,tn] *charge_efficiency/batteryCapacity] for tn in temp_timer) <=1 #if end_SOC == 1: # incrementSOC=v1g_distance[i]/batteryRange # model += lp.lpSum([chargeprofiles[i, tn] * charge_efficiency / batteryCapacity] for tn in range(temp_start, 24, 1)) \ # + lp.lpSum([chargeprofiles[i, tn] * charge_efficiency / batteryCapacity] for tn in temp_timer) >= incrementSOC # need to divide 4 if end_SOC ==2: model += temp_startSOC + lp.lpSum([chargeprofiles[i, tn] *charge_efficiency / batteryCapacity] for tn in range(temp_start, 24, 1)) + lp.lpSum([chargeprofiles[i, tn] *charge_efficiency / batteryCapacity] for tn in range(0, temp_end)) ==1 if temp_start < temp_end: for t in range (temp_start+1, temp_end+1, 1): temp_timer = range (temp_start, t, 1) model += temp_startSOC + lp.lpSum( [chargeprofiles[i,tn] *charge_efficiency/batteryCapacity] for tn in temp_timer) <=1 #if end_SOC == 1: # incrementSOC=v1g_distance[i]/batteryRange # model += lp.lpSum( [chargeprofiles[i,tn] * charge_efficiency/batteryCapacity] for tn in temp_timer) >= incrementSOC if end_SOC ==2: #model += temp_startSOC + lp.lpSum([chargeprofiles[i, tn] *(1/charge_efficiency / batteryCapacity)] for tn in range(temp_start, 24, 1)) + lp.lpSum([chargeprofiles[i, tn] *(1/charge_efficiency / batteryCapacity)] for tn in temp_timer) ==1 model += temp_startSOC + lp.lpSum([chargeprofiles[i, tn] * charge_efficiency / batteryCapacity] for tn in range(temp_start, temp_end, 1)) ==1 #for t in time_Interval: # constraint 6: number of chargers available at time interval t #model += lp.lpSum([chargestates[i, t]] for i in veh_V1G) <= 400 #print(model) status=model.solve() if isManaged==1: print(lp.LpStatus[status]) #print(lp.value(max_load), lp.value(min_load)) return chargeprofiles, total_load
def add_adjacent_variables_constraints_m4(self, s_dict) -> None: """Method to create LP variables for each pair of adjacent geometries (using mode 4). """ logging.debug("method add_adjacent_variables_constraints_m4 called") combinations = set() for i in tqdm(range(self.gdf.shape[0]), desc="Construction LP"): for j in range(self.gdf.shape[0]): if j == i: # We don't check the adjacency with itself. continue if (i, j) in combinations or (j, i) in combinations: # If the combination already exists we skip it. continue # Create a set with all possible combinations to optimize. combinations.add((i, j)) for i, j in combinations: # Create the variables for the optimal horizontal en vertical length between p_i en p_j h = p.LpVariable(f"h_{i}_{j}") v = p.LpVariable(f"v_{i}_{j}") self.problem += h >= 0 self.problem += v >= 0 # Calculate the minimum length between i en j based on their width w = self.gdf.at[i, "geom_size"] + self.gdf.at[j, "geom_size"] # Add a gap if they are non-adjacent if str(j) in self.gdf.iloc[i, :]["_neighbors"].split(","): gap = 0 self._distances.append(h) self._distances.append(v) else: gap = self.gap_size # Create the S constant based on the results in the first iteration to determine horizontal or vertical adjacency in the cartogram. if s_dict[i][j] and str(j) in self.gdf.iloc[ i, :]["_neighbors"].split(","): s = w one_minus_s = 0 elif not s_dict[i][j] and str(j) in self.gdf.iloc[ i, :]["_neighbors"].split(","): s = 0 one_minus_s = w else: s = 0 one_minus_s = 0 # Check the distance between j en i to determine in which order to place the coordinates geom_dist_x = self.gdf.at[j, "geometry"].x - self.gdf.at[i, "geometry"].x geom_dist_y = self.gdf.at[j, "geometry"].y - self.gdf.at[i, "geometry"].y # Depending on whether x_i - x_j yields a positive or negative result we decide the order # in which they are presented in the constraints. if geom_dist_x > 0: if s > 0: # Add constraint 1 self.problem += (self._coord_dict[j]["x"] - self._coord_dict[i]["x"] >= s) # Add constraint 3 self.problem += (h >= self._coord_dict[j]["x"] - self._coord_dict[i]["x"] - w) else: if s > 0: # Add constraint 1 self.problem += (self._coord_dict[i]["x"] - self._coord_dict[j]["x"] >= s) # Add constraint 3 self.problem += (h >= self._coord_dict[i]["x"] - self._coord_dict[j]["x"] - w) # Depending on whether y_i - y_j yields a positive or negative result we decide the order # in which they are presented in the constraints. if geom_dist_y > 0: if one_minus_s > 0: # Add constraint 2 self.problem += (self._coord_dict[j]["y"] - self._coord_dict[i]["y"] >= one_minus_s) # Add constraint 4 self.problem += (v >= self._coord_dict[j]["y"] - self._coord_dict[i]["y"] - w) else: if one_minus_s > 0: # Add constraint 2 self.problem += (self._coord_dict[i]["y"] - self._coord_dict[j]["y"] >= one_minus_s) # Add constraint 4 self.problem += (v >= self._coord_dict[i]["y"] - self._coord_dict[j]["y"] - w) # Define the objective self.problem += p.lpSum(self._distances)
params = (f.read()).split('\n') params = [e for e in params if e != ""] BUS_COUNT = int(params[0]) # k BUS_SIZE = int(params[1]) # s rowdies = [eval(e) for e in params[2:]] # Define the linear programming problem lp_problem = pulp.LpProblem("Optimizing_Bus_Assignments", pulp.LpMinimize) # Initialize the variables bi(u) variables = {} for i in range(BUS_COUNT): for u in range(n): varname = 'b' + str(i) + '_' + str(u) keyname = 'b[' + str(i) + '][' + str(u) + ']' x = pulp.LpVariable(varname, lowBound=0, upBound=1, cat='Integer') variables[keyname] = x # Initialize the variables zi(u, v)+ and zi(u, v)- for i in range(BUS_COUNT): for edge in edges: u = str(node2hash[edge[0]]) v = str(node2hash[edge[1]]) varname1 = 'z_' + str(i) + '_' + u + '_' + v + '_' + 'plus' keyname1 = 'z' + str(i) + '[' + u + '][' + v + ']+' varname2 = 'z_' + str(i) + '_' + u + '_' + v + '_' + 'minus' keyname2 = 'z' + str(i) + '[' + u + '][' + v + ']-' x = pulp.LpVariable(varname1, cat='Continuous') y = pulp.LpVariable(varname2, cat='Continuous') variables[keyname1] = x variables[keyname2] = y
# 线性规划2 import pulp profit = pulp.LpProblem("My LP Problem", pulp.LpMaximize) x = pulp.LpVariable('x', lowBound=0, cat='Integer') #Integer---不连续的整数 y = pulp.LpVariable('y', lowBound=2, cat='Integer') #Continuous--连续的 # Objective function目标函数 profit += 72 * x + 64 * y # Constraints约束 profit += 3 * x <= 100 profit += 12 * x + 8 * y <= 480 profit += x + y <= 50 print(profit) profit.solve() print(pulp.LpStatus[profit.status]) for variable in profit.variables(): print('{} = {}'.format(variable.name, variable.varValue)) print(pulp.value(profit.objective))