def FindOBD(self): """Find the OBD (Optimized Bottleneck Energetics). Args: c_range: a tuple (min, max) for concentrations (in M). bounds: a list of (lower bound, upper bound) tuples for compound concentrations. Returns: A 3 tuple (optimal dGfs, optimal concentrations, optimal obd). """ lp_primal, x, _ = self._MakeOBDProblem() lp_primal.solve(pulp.CPLEX(msg=0)) if lp_primal.status != pulp.LpStatusOptimal: raise pulp.solvers.PulpSolverError("cannot solve OBD primal") obd = pulp.value(x[-1]) conc = np.matrix([np.exp(pulp.value(x[j])) for j in xrange(self.Nc)]).T lp_dual, w, z, u = self._MakeOBDProblemDual() lp_dual.solve(pulp.CPLEX(msg=0)) if lp_dual.status != pulp.LpStatusOptimal: raise pulp.solvers.PulpSolverError("cannot solve OBD dual") reaction_prices = np.matrix([pulp.value(w["%d" % i]) for i in xrange(self.Nr)]).T compound_prices = np.matrix([pulp.value(z["%d" % j]) for j in xrange(self.Nc)]).T - \ np.matrix([pulp.value(u["%d" % j]) for j in xrange(self.Nc)]).T # find the maximum and minimum total Gibbs energy of the pathway, # under the constraint that the driving force of each reaction is >= OBD lp_total, total_dg = self._GetTotalEnergyProblem(obd - 1e-6, pulp.LpMinimize) lp_total.solve(pulp.CPLEX(msg=0)) if lp_total.status != pulp.LpStatusOptimal: raise pulp.solvers.PulpSolverError("cannot solve total delta-G problem") min_tot_dg = pulp.value(total_dg) lp_total, total_dg = self._GetTotalEnergyProblem(obd - 1e-6, pulp.LpMaximize) lp_total.solve(pulp.CPLEX(msg=0)) if lp_total.status != pulp.LpStatusOptimal: raise pulp.solvers.PulpSolverError("cannot solve total delta-G problem") max_tot_dg = pulp.value(total_dg) params = {'OBD': obd * R * self.T, 'concentrations' : conc, 'reaction prices' : reaction_prices, 'compound prices' : compound_prices, 'maximum total dG' : max_tot_dg * R * self.T, 'minimum total dG' : min_tot_dg * R * self.T} return obd * R * self.T, params
def opt(C, X): orderNum = len(X) routeNum = len(C) routeIdx = range(routeNum) orderIdx = range(orderNum) # print routeIdx,orderIdx eps = 1.0 / 10**7 print eps var_choice = lp.LpVariable.dicts('route', routeIdx, cat='Binary') # var_choice=lp.LpVariable.dicts('route',routeIdx,lowBound=0)#尝试松弛掉01变量 exceed_labor = lp.LpVariable('Number of routes exceed 1000', 0) prob = lp.LpProblem("lastMile", lp.LpMinimize) prob += exceed_labor * 100000 + lp.lpSum(var_choice[i] * C[i] for i in routeIdx) prob += lp.lpSum(var_choice[i] for i in routeIdx) <= 1000 + exceed_labor + eps for i in orderIdx: prob += lp.lpSum(var_choice[j] for j in X[i]) >= (1 - eps) prob.solve(lp.CPLEX(msg=0)) print "\n\nstatus:", lp.LpStatus[prob.status] if lp.LpStatus[prob.status] != 'Infeasible': obj = lp.value(prob.objective) print "\n\nobjective:", obj sol_list = [var_choice[i].varValue for i in routeIdx] print "\n\nroutes:", (sum(sol_list)) # print "\n\noriginal problem:\n",prob return obj, sol_list, lp.LpStatus[prob.status] else: return None, None, lp.LpStatus[prob.status]
def main(): demand = 110 capacity = 10 prob = pulp.LpProblem("3 Node Single Commodity Flow", pulp.LpMinimize) x12 = pulp.LpVariable('x12', lowBound=0, upBound=capacity, cat='Integer') x132 = pulp.LpVariable('x132', lowBound=0, upBound=(10*capacity), cat='Integer') z = pulp.LpVariable('z', lowBound=0) prob += (z) prob += (x12+x132 == demand) prob += (z * capacity >= x12) prob += (z * 10 *capacity >= x132) print(prob) prob.writeLP("3node SCF_Loadbalancing") # solve the LP using the default solver optimization_result = prob.solve(pulp.CPLEX()) # make sure we got an optimal solution assert optimization_result == pulp.LpStatusOptimal # display the results for var in (x12, x132): print('Optimal number of {} to produce: {:1.0f}'.format(var.name, var.value()))
def solve_ilp(self, N): # build the A matrix: a_ij is 1 if j-th gram appears in the i-th sentence A = np.zeros((len(self.sentences_idx), len(self.ref_ngrams_idx))) for i in self.sentences_idx: sent = self.sentences[i].untokenized_form sngrams = list( extract_ngrams2([sent], self.stemmer, self.LANGUAGE, N)) for j in self.ref_ngrams_idx: if self.ref_ngrams[j] in sngrams: A[i][j] = 1 # Define ILP variable, x_i is 1 if sentence i is selected, z_j is 1 if gram j appears in the created summary x = pulp.LpVariable.dicts('sentences', self.sentences_idx, lowBound=0, upBound=1, cat=pulp.LpInteger) z = pulp.LpVariable.dicts('grams', self.ref_ngrams_idx, lowBound=0, upBound=1, cat=pulp.LpInteger) # Define ILP problem, maximum coverage of grams from the reference summaries prob = pulp.LpProblem("ExtractiveUpperBound", pulp.LpMaximize) prob += pulp.lpSum(z[j] for j in self.ref_ngrams_idx) # Define ILP constraints, length constraint and consistency constraint (impose that z_j is 1 if j # appears in the created summary) prob += pulp.lpSum(x[i] * self.sentences[i].length for i in self.sentences_idx) <= self.sum_length for j in self.ref_ngrams_idx: prob += pulp.lpSum(A[i][j] * x[i] for i in self.sentences_idx) >= z[j] # Solve ILP problem and post-processing to get the summary try: print('Solving using CPLEX') prob.solve(pulp.CPLEX(msg=0)) except: print('Solving using GLPK') prob.solve(pulp.GLPK(msg=0)) summary_idx = [] for idx in self.sentences_idx: if x[idx].value() == 1.0: summary_idx.append(idx) return summary_idx
def main(): prob = pulp.LpProblem("RSVP_TE_PathAllocation", pulp.LpMinimize) x_A_sf_kc = pulp.LpVariable('x_A_sf_kc', cat='Binary') x_A_sf_ny_kc = pulp.LpVariable('x_A_sf_ny_kc', cat='Binary') x_A_kc_ny = pulp.LpVariable('x_A_kc_ny', cat='Binary') x_A_kc_sf_ny = pulp.LpVariable('x_A_kc_sf_ny', cat='Binary') x_A_sf_ny = pulp.LpVariable('x_A_sf_ny', cat='Binary') x_A_sf_kc_ny = pulp.LpVariable('x_A_sf_kc_ny', cat='Binary') x_B_sf_ny = pulp.LpVariable('x_B_sf_ny', cat='Binary') x_B_sf_kc_ny = pulp.LpVariable('x_B_sf_kc_ny', cat='Binary') x_C_sf_ny = pulp.LpVariable('x_C_sf_ny', cat='Binary') x_C_sf_kc_ny = pulp.LpVariable('x_C_sf_kc_ny', cat='Binary') prob += (x_A_sf_kc + x_A_sf_ny_kc + x_A_kc_ny + x_A_kc_sf_ny + x_A_sf_ny + x_A_sf_kc_ny + x_B_sf_ny + x_B_sf_kc_ny + x_C_sf_ny + x_C_sf_kc_ny) prob += (x_A_sf_kc + x_A_sf_ny_kc == 1) prob += (x_A_kc_ny + x_A_kc_sf_ny == 1) prob += (x_A_sf_ny + x_A_sf_kc_ny == 1) prob += (x_B_sf_ny + x_B_sf_kc_ny == 1) prob += (x_C_sf_ny + x_C_sf_kc_ny == 1) prob += (45 * x_A_sf_kc + 60 * x_A_kc_sf_ny + 20 * x_A_sf_kc_ny + 80 * x_B_sf_kc_ny + 100 * x_C_sf_kc_ny <= 155) prob += (45 * x_A_sf_ny_kc + 60 * x_A_kc_sf_ny + 20 * x_A_sf_ny + 80 * x_B_sf_ny + 100 * x_C_sf_ny <= 155) prob += (45 * x_A_sf_ny_kc + 60 * x_A_kc_ny + 20 * x_A_sf_kc_ny + 80 * x_B_sf_kc_ny + 100 * x_C_sf_kc_ny <= 155) print(prob) prob.writeLP("RSVP_TE_PathAllocation.lp") # solve the LP using the CPLEX optimization_result = prob.solve(pulp.CPLEX()) # make sure we got an optimal solution assert optimization_result == pulp.LpStatusOptimal # display the results for var in (x_A_sf_kc, x_A_sf_ny_kc, x_A_kc_ny, x_A_kc_sf_ny, x_A_sf_ny, x_A_sf_kc_ny, x_B_sf_ny, x_B_sf_kc_ny, x_C_sf_ny, x_C_sf_kc_ny): print('Optimal number of {} to produce:{}'.format( var.name, var.varValue))
def min_cost_routing_diff_cost(): c12, c13, c23 = 2,2,2 c132, c123, c213 = 1,1,1 h12 = 5 h13 = 10 h23 = 7 cap12 = 10 cap13 = 10 cap23 = 15 prob = pulp.LpProblem("3Node_MultiCommodity_MinCost_Routing", pulp.LpMinimize) # Defining the Flow Variables x12 = pulp.LpVariable('x12', lowBound=0, upBound=10, cat='Integer') x132 = pulp.LpVariable('x132', lowBound=0, upBound=10, cat='Integer') x13 = pulp.LpVariable('x13', lowBound=0, upBound=10, cat='Integer') x123 = pulp.LpVariable('x123', lowBound=0, upBound=10, cat='Integer') x23 = pulp.LpVariable('x23', lowBound=0, upBound=10, cat='Integer') x213 = pulp.LpVariable('x213', lowBound=0, upBound=10, cat='Integer') # Adding Objective Function prob += (c12 * x12 + c132 * x132 + c13 * x13 + c123 * x123 + c23 * x23 + c213 * x213) # Subject to Constraints prob += (x12 + x132 == h12) prob += (x13 + x123 == h13) prob += (x23 + x213 == h23) prob += (x12 + x123 + x213 <= cap12) prob += (x13 + x132 + x213 <= cap13) prob += (x23 + x132 + x123 <= cap23) # Print the Problem print(prob) prob.writeLP("3node_MCF_MinCost.lp") # solve the LP using the CPLEX Solver optimization_result = prob.solve(pulp.CPLEX()) # make sure we got an optimal solution assert optimization_result == pulp.LpStatusOptimal # display the results for var in (x12, x132, x13, x123, x23, x213): print('Optimal Flow for {} is {:1.0f}'.format(var.name, var.value()))
def min_max_link_utilization(): h12 = 5 h13 = 10 h23 = 7 cap12 = 10 cap13 = 10 cap23 = 15 prob = pulp.LpProblem("3Node_MultiCommodity_LoadBalancing", pulp.LpMinimize) # Defining the Flow Variables x12 = pulp.LpVariable('x12', lowBound=0, cat='Continuous') x132 = pulp.LpVariable('x132', lowBound=0, cat='Continuous') x13 = pulp.LpVariable('x13', lowBound=0, cat='Continuous') x123 = pulp.LpVariable('x123', lowBound=0, cat='Continuous') x23 = pulp.LpVariable('x23', lowBound=0, cat='Continuous') x213 = pulp.LpVariable('x213', lowBound=0, cat='Continuous') z = pulp.LpVariable('z', lowBound=0) # Adding Objective Function prob += (z) # Subject to Constraints prob += (x12 + x132 == h12) prob += (x13 + x123 == h13) prob += (x23 + x213 == h23) prob += (z * cap12 >= x12 + x123 + x213) prob += (z * cap13 >= x13 + x132 + x213) prob += (z * cap23 >= x23 + x132 + x123) # Print the Problem print(prob) prob.writeLP("3node_MCF_LoadBalancing.lp") # solve the LP using the CPLEX Solver optimization_result = prob.solve(pulp.CPLEX()) # make sure we got an optimal solution assert optimization_result == pulp.LpStatusOptimal # display the results for var in (x12, x132, x13, x123, x23, x213): print('Optimal Flow for {} is {:1.0f}'.format(var.name, var.value()))
def solve_SOP(G, precedense, num_node, ss): problem = pulp.LpProblem(name='SOP', sense=pulp.LpMinimize) x = {(i, j): pulp.LpVariable(cat="Binary", name=f"x_{i}_{j}") for (i, j) in G.edges()} u = { i: pulp.LpVariable(cat="Integer", name=f"u_{i}", lowBound=1, upBound=num_node - 1) for i in G.nodes() } cost = {(i, j): G.adj[i][j]['dist'] for (i, j) in G.edges()} problem += pulp.lpSum([x[(i, j)] * cost[(i, j)] for (i, j) in G.edges()]) for i in G.nodes(): if i != num_node - 1: problem.addConstraint( pulp.lpSum([x[(i, j)] for j in range(num_node) if j != i]) == 1, f'outflow_{i}') if i != 0: problem.addConstraint( pulp.lpSum([x[(j, i)] for j in range(num_node) if j != i]) == 1, f'inflow_{i}') for i, j in G.edges(): if i != ss and j != ss: problem.addConstraint( u[i] - u[j] + (num_node - 1) * x[i, j] <= num_node - 2, f'up_{i}_{j}') for i, j in precedense: problem.addConstraint(u[i] + 1 <= u[j], f'sequential_{i}_{j}') u[ss] = 0 print('start solving') start = time.time() status = problem.solve(pulp.CPLEX()) # status = problem.solve() print(pulp.LpStatus[status]) duartion = time.time() - start print(duartion) if pulp.LpStatus[status] != 'Optimal': print('Infeasible!') exit() return x, u, duartion
def solve_ilp_problem(self, word_num, p, dep_length=None, parents=None, matrix=None, solver='glpk', mx=0.7, mn=0.2, w2=0.5, saved=None): max_length = int(mx * word_num) min_length = int(mn * word_num) prob = pulp.LpProblem('sentence_compression', pulp.LpMaximize) # initialize the word binary variables c = pulp.LpVariable.dicts(name='c', indexs=range(word_num), lowBound=0, upBound=1, cat='Integer') #objective function prob += sum((p[i] - w2 * dep_length[i]) * c[i] for i in range( word_num)) #p[i] is the probability for retain the words # #constraints if parents is not None: for j in range(word_num): if parents[j] > 0: prob += c[j] <= c[parents[j]] if saved is not None: for s in saved: prob += c[s[0]] >= c[s[1]] prob += sum([c[i] for i in range(word_num)]) <= max_length prob += sum([c[i] for i in range(word_num)]) >= min_length if solver == 'gurobi': prob.solve(pulp.GUROBI(msg=0)) elif solver == 'glpk': prob.solve(pulp.GLPK(msg=0)) elif solver == 'cplex': prob.solve(pulp.CPLEX(msg=0)) else: sys.exit('no solver specified') values = [c[j].varValue for j in range(word_num)] solution = [j for j in range(word_num) if c[j].varValue == 1] return (pulp.value(prob.objective), solution, values)
def compute_consensus_rankings( self, dataset: Dataset, scoring_scheme: ScoringScheme, return_at_most_one_ranking=False, bench_mode=False ) -> Consensus: """ :param dataset: A dataset containing the rankings to aggregate :type dataset: Dataset (class Dataset in package 'datasets') :param scoring_scheme: The penalty vectors to consider :type scoring_scheme: ScoringScheme (class ScoringScheme in package 'distances') :param return_at_most_one_ranking: the algorithm should not return more than one ranking :type return_at_most_one_ranking: bool :param bench_mode: is bench mode activated. If False, the algorithm may return more information :type bench_mode: bool :return one or more rankings if the underlying algorithm can find several equivalent consensus rankings If the algorithm is not able to provide multiple consensus, or if return_at_most_one_ranking is True then, it should return a list made of the only / the first consensus found. In all scenario, the algorithm returns a list of consensus rankings :raise ScoringSchemeNotHandledException when the algorithm cannot compute the consensus because the implementation of the algorithm does not fit with the scoring scheme """ rankings = dataset.rankings elem_id = {} id_elements = {} id_elem = 0 for ranking in rankings: for bucket in ranking: for element in bucket: if element not in elem_id: elem_id[element] = id_elem id_elements[id_elem] = element id_elem += 1 nb_elem = len(elem_id) positions = ExactAlgorithmGeneric.__positions(rankings, elem_id) sc = asarray(scoring_scheme.penalty_vectors) graph, mat_score, ties_must_be_checked = self.__graph_of_elements(positions, sc) my_values = [] my_vars = [] h_vars = {} cpt = 0 for i in range(nb_elem): for j in range(nb_elem): if not i == j: name_var = "x_%s_%s" % (i, j) my_values.append(mat_score[i][j][0]) my_vars.append(pulp.LpVariable(name_var, 0, 1, cat="Binary")) h_vars[name_var] = cpt cpt += 1 if i < j: name_var = "t_%s_%s" % (i, j) my_values.append(mat_score[i][j][2]) my_vars.append(pulp.LpVariable(name_var, 0, 1, cat="Binary")) h_vars[name_var] = cpt cpt += 1 prob = pulp.LpProblem("myProblem", pulp.LpMinimize) # add the binary order constraints for i in range(0, nb_elem - 1): for j in range(i + 1, nb_elem): if not i == j: prob += my_vars[h_vars["x_%s_%s" % (i, j)]] \ + my_vars[h_vars["x_%s_%s" % (j, i)]] \ + my_vars[h_vars["t_%s_%s" % (i, j)]] == 1 # add the transitivity constraints for i in range(0, nb_elem): for j in range(nb_elem): if j != i: i_bef_j = "x_%s_%s" % (i, j) if i < j: i_tie_j = "t_%s_%s" % (i, j) else: i_tie_j = "t_%s_%s" % (j, i) for k in range(nb_elem): if k != i and k != j: j_bef_k = "x_%s_%s" % (j, k) i_bef_k = "x_%s_%s" % (i, k) if j < k: j_tie_k = "t_%s_%s" % (j, k) else: j_tie_k = "t_%s_%s" % (k, j) if i < k: i_tie_k = "t_%s_%s" % (i, k) else: i_tie_k = "t_%s_%s" % (k, i) prob += my_vars[h_vars[i_bef_j]] +\ my_vars[h_vars[j_bef_k]] \ + my_vars[h_vars[j_tie_k]] \ - my_vars[h_vars[i_bef_k]] <= 1 prob += my_vars[h_vars[i_bef_j]] + \ my_vars[h_vars[i_tie_j]] \ + my_vars[h_vars[j_bef_k]] - my_vars[h_vars[i_bef_k]] <= 1 prob += 2 * my_vars[h_vars[i_tie_j]] \ + 2 * my_vars[h_vars[j_tie_k]] \ - my_vars[h_vars[i_tie_k]] <= 3 # optimization if not ties_must_be_checked: for i in range(0, nb_elem - 1): for j in range(i + 1, nb_elem): if not i == j: prob += my_vars[h_vars["t_%s_%s" % (i, j)]] == 0 cfc = graph.components() for i in range(len(cfc)): group_i = cfc[i] for j in range(i+1, len(cfc)): for elem_i in group_i: for elem_j in cfc[j]: prob += my_vars[h_vars["x_%s_%s" % (elem_i, elem_j)]] == 1 prob += my_vars[h_vars["x_%s_%s" % (elem_j, elem_i)]] == 0 if elem_i < elem_j: prob += my_vars[h_vars["t_%s_%s" % (elem_i, elem_j)]] == 0 else: prob += my_vars[h_vars["t_%s_%s" % (elem_j, elem_i)]] == 0 # objective function prob += pulp.lpSum(my_vars[cpt] * my_values[cpt] for cpt in range(len(my_vars))) try: prob.solve(pulp.CPLEX(msg=False)) except: prob.solve(pulp.PULP_CBC_CMD(msg=False)) h_def = {i: 0 for i in range(nb_elem)} for var in my_vars: if abs(var.value() - 1) < 0.01 and var.name[0] == "x": h_def[int(var.name.split("_")[2])] += 1 ranking = [] current_nb_def = 0 bucket = [] for elem, nb_defeats in (sorted(h_def.items(), key=itemgetter(1))): if nb_defeats == current_nb_def: bucket.append(id_elements[elem]) else: ranking.append(bucket) bucket = [id_elements[elem]] current_nb_def = nb_defeats ranking.append(bucket) return Consensus(consensus_rankings=[ranking], dataset=dataset, scoring_scheme=scoring_scheme, att={ConsensusFeature.IsNecessarilyOptimal: True, ConsensusFeature.KemenyScore: prob.objective.value(), ConsensusFeature.AssociatedAlgorithm: self.get_full_name() })
#prob+=pulp.LpSum([h[i][(i,t)] for i in modelList for t in Tm[i]])*1/2== sum([R[l][t] for t in TL]) #prob+=r[l][o]+Pday[l][o]<=(orderPool['deli_date'][o]-datetime.datetime.strptime(plan_dates[0],'%Y-%m-%d')).days #prob+=r[l][o]>=max(0,(orderPool['epst'][o]-datetime.datetime.strptime(plan_dates[0],'%Y-%m-%d')).days) #prob+=pulp.lpSum([order_spd[(order_spd['order_id'==o])&(order_spd['line_o']==l)&(order_spd['day_process']==Pday[l][o])] for l in prod_line])==orderPool['order_num'][o] #prob+=compD[l][o]<=(orderPool['deli_date'][o]-datetime.datetime.strptime(plan_dates[0],'%Y-%m-%d')).days #prob+=pulp.lpSum([Csums[l][o] for l in prod_line for o in orderList])==orderPool['order_num'].sum() #5.every line cannot made two orders at the same time #eps=1e-2 #for o in orderList: #prob+=Cmax+eps*pulp.lpSum([r[l][o] for l in prod_line])-eps*pulp.lpSum([compD[l][o] for l in prod_line]) prob.writeLP("APSModel.lp") #solver=pulp.solvers.COIN_CMD(path='/home/yumchaamax/math_dep/cbc/Cbc-2.9/build/Cbc/src/cbc',threads=16,msg=1,fracGap=0.01) prob.solve(pulp.CPLEX()) print("Status:", pulp.LpStatus[prob.status]) #for o in orderList: #for l in prod_line: #print((l,o),r[l,o].value(),compD[l,o].value(),Cmax[l,o].value()) a = [] for v in prob.variables(): #print(v.name, "=", v.varValue) a.append((v.name, v.varValue)) rlt_df = pd.DataFrame(a) rlt_df.to_csv("test.csv") print("Total amounts of products by day =", pulp.value(prob.objective))
def _solve_ilp_problem(self, words_limit=100, solver='glpk', excluded_solutions=[], unique=False): """Solve the ILP formulation of the concept-based model. Args: words_limit (int): the maximum size in words of the summary, defaults to 100. solver (str): the solver used, defaults to glpk. excluded_solutions (list of list): a list of subsets of sentences that are to be excluded, defaults to [] unique (bool): modify the model so that it produces only one optimal solution, defaults to False Returns: (value, set) tuple (int, list): the value of the objective function and the set of selected sentences as a tuple. """ # initialize container shortcuts concepts = self.weights.keys() W = self.weights L = words_limit C = len(concepts) S = len(self.sentences) assert self.word_frequency, "word_frequency must be calculated first" words = self.word_frequency.keys() frequency = self.word_frequency words_count = len(words) concepts = sorted(self.weights, key=self.weights.get, reverse=True) # fomulation of the ILP problem prob = pulp.LpProblem("ILP for Summarization", pulp.LpMaximize) # initialize the concepts binary variables c = pulp.LpVariable.dicts(name='c', indexs=range(C), lowBound=0, upBound=1, cat='Integer') # initialize the sentences binary variables s = pulp.LpVariable.dicts(name='s', indexs=range(S), lowBound=0, upBound=1, cat='Integer') # initialize the word(term) binary variables t = pulp.LpVariable.dicts(name='t', indexs=range(words_count), lowBound=0, upBound=1, cat='Integer') # objective function if unique: prob += sum(W[concepts[i]] * c[i] for i in range(C)) + \ 10e-6 * sum(frequency[words[j]] * t[j] for j in range(words_count)) else: prob += sum(W[concepts[i]] * c[i] for i in range(C)) # constraint for summary size prob += sum(s[i] * self._get_sentence_length(self.sentences[i]) for i in range(S)) <= L # integrity constraint for i in range(C): for j in range(S): if concepts[i] in self.sentences[j].concepts: prob += s[j] <= c[i] for i in range(C): prob += sum(s[j] for j in range(S) if concepts[i] in self.sentences[j].concepts) >= c[i] # word integrity constraint if unique: for i in range(words_count): for j in self.word2sent[words[i]]: prob += s[j] <= t[i] for i in range(words_count): prob += sum(s[j] for j in self.word2sent[words[i]]) >= t[i] # constraint for finding optimal solutions for sentence_set in excluded_solutions: prob += sum(s[i] for i in sentence_set) <= len(sentence_set) - 1 # solve the ilp problem if solver.lower() == "glpk": prob.solve(pulp.GLPK(msg=0)) elif solver.lower() == "gurobi": prob.solve(pulp.GUROBI(msg=0)) elif solver.lower() == "cplex": prob.solve(pulp.CPLEX(msg=0)) else: raise AssertionError("no solver specified") # retrieve the optimal subset of sentences solution = set([idx for idx in range(S) if s[idx].varValue == 1]) # return the (objective function value, solution) tuple return (pulp.value(prob.objective), solution)
def optimizeTrajectory(activeConstraints, N, T, T_end, V, P, W, M, m, minApproachDist, x_ini, x_fin, x_lim, u_lim, objects, r, dynamicsModel, omega): # -------------------- # Calculated Variables # -------------------- del_t = T_end/(T-1) numObjects = objects.shape[0] # ------------------ # Decision variables # ------------------ # Thrust u = pulp.LpVariable.dicts( "input", ((i, p, n) for i in range(T) for p in range(V) for n in range(N)), cat='Continuous') # Thrust Magnitude v = pulp.LpVariable.dicts( "inputMag", ((i, p, n) for i in range(T) for p in range(V) for n in range(N)), lowBound=0, cat='Continuous') # State x = pulp.LpVariable.dicts( "state", ((i, p, k) for i in range(T) for p in range(V) for k in range(2*N)), cat='Continuous') # ------------------ # Optimization Model # ------------------ # Instantiate Model model = pulp.LpProblem("Satellite Fuel Minimization Problem", pulp.LpMinimize) # Objective Function model += pulp.lpSum(v[i, p, n] for i in range(T) for p in range(V) for n in range(N)), "Fuel Minimization" # ----------- # Constraints # ----------- # Basic Constraints # ----------------- # Constrain thrust magnitude to abs(u[i, p, n]) for i in range(T): for p in range(V): for n in range(N): model += u[i, p, n] <= v[i, p, n] model += -u[i, p, n] <= v[i, p, n] # State and Input vector start and end values for p in range(V): for k in range(2*N): model += x[0, p, k] == x_ini[p, k] if(activeConstraints["finalConfigurationSelection"] == False): model += x[T-1, p, k] == x_fin[p, k] # Model Dynamics if dynamicsModel == "freeSpace": for constraint in freeSpaceDynamics(x, u, T, V, N, m, del_t): model += constraint elif dynamicsModel == "hills": for constraint in linearHillsDynamics(x, u, T, V, N, m, del_t, omega): model += constraint # State and Input vector limits for i in range(T): for p in range(V): for n in range(N): model += u[i, p, n] <= u_lim[p, n] model += u[i, p, n] >= -u_lim[p, n] for k in range(2*N): # Necessary? model += x[i, p, k] <= x_lim[p, k] model += x[i, p, k] >= -x_lim[p, k] # Obstacle Avoidance # ------------------ if (activeConstraints["obstacleAvoidance"] == True and objects.shape[1] > 0): #Obstacle avoidance binary decision variable a = pulp.LpVariable.dicts( "objCol", ((i, p, l, k) for i in range(T) for p in range(V) for l in range(numObjects) for k in range(2*N)), cat='Binary') for i in range(T): for p in range(V): for l in range(objects.shape[0]): model += pulp.lpSum(a[i, p, l, n] for n in range(2*N)) <= 2*N-1 for n in range(N): model += x[i, p, n] >= objects[l, n*2+1] + minApproachDist - M*a[i, p, l, N+n] model += x[i, p, n] <= objects[l, n*2] - minApproachDist + M*a[i, p, l, n] # Collision Avoidance # ------------------- if (activeConstraints["collisionAvoidance"] == True and V > 1): # Collision avoidance binary decision variable b = pulp.LpVariable.dicts( "satelliteCollisionAvoidance", ((i, p, q, k) for i in range(T) for p in range(V) for q in range(V) for k in range(2*N)), cat='Binary') for i in range(T): for p in range(V): for q in range(V): if q > p: model += pulp.lpSum(b[i, p, q, k] for k in range(2*N)) <= 2*N-1 for n in range(N): model += x[i, p, n] - x[i, q, n] >= r[n] - M*b[i, p, q, n] model += x[i, q, n] - x[i, p, n] >= r[n] - M*b[i, p, q, n+N] # Plume Avoidance for Vehicles # ---------------------------- if (activeConstraints["plumeAvoidanceVehicle"] == True): # Positive thrust c_pos = pulp.LpVariable.dicts( "plumeAvoidanceVehiclePos", ((i, p, q, n, k) for i in range(T) for p in range(V) for q in range(V) for n in range(N) for k in range(2*N+1)), cat='Binary') for i in range(T): for p in range(V): for q in range(V): if q != p: for n in range(N): model += pulp.lpSum(c_pos[i, p, q, n, k] for k in range(2*N+1)) <= 2*N model += -u[i, p, n] >= - M*c_pos[i, p, q, n, 0] model += x[i, p, n] - x[i, q, n] >= P - M*c_pos[i, p, q, n, n+1] model += x[i, q, n] - x[i, p, n] >= - M*c_pos[i, p, q, n, n+N+1] for m in range(N): if m != n: model += x[i, p, m] - x[i, q, m] >= W - M*c_pos[i, p, q, n, m+1] model += x[i, q, m] - x[i, p, m] >= W - M*c_pos[i, p, q, n, m+N+1] c_neg = pulp.LpVariable.dicts( "plumeAvoidanceVehicleNeg", ((i, p, q, n, k) for i in range(T) for p in range(V) for q in range(V) for n in range(N) for k in range(2*N+1)), cat='Binary') for i in range(T): for p in range(V): for l in range(numObjects): for n in range(N): model += pulp.lpSum(c_neg[i, p, q, n, k] for k in range(2*N+1)) <= 2*N model += u[i, p, n] >= - M*c_neg[i, p, q, n, 0] model += x[i, p, n] - x[i, q, n] >= - M*c_neg[i, p, q, n, n+1] model += x[i, q, n] - x[i, p, n] >= P - M*c_neg[i, p, q, n, n+N+1] for m in range(N): if m != n: model += x[i, p, m] - x[i, q, m] >= W - M*c_neg[i, p, q, n, m+1] model += x[i, q, m] - x[i, p, m] >= W - M*c_neg[i, p, q, n, m+N+1] # Plume Avoidance for Obstacles # ----------------------------- if (activeConstraints["plumeAvoidanceObstacle"] == True and objects.shape[1] > 0): # Positive thrust d_pos = pulp.LpVariable.dicts( "plumeAvoidanceObstaclePos", ((i, p, l, n, k) for i in range(T) for p in range(V) for l in range(numObjects) for n in range(N) for k in range(2*N+1)), cat='Binary') for i in range(T): for p in range(V): for l in range(numObjects): for n in range(N): model += pulp.lpSum(d_pos[i, p, l, n, k] for k in range(2*N+1)) <= 2*N model += -u[i, p, n] >= - M*d_pos[i, p, l, n, 0] model += x[i, p, n] - objects[l, n*2+1] >= P - M*d_pos[i, p, l, n, n+1] model += objects[l, n*2] - x[i, p, n] >= - M*d_pos[i, p, l, n, n+N+1] for m in range(N): if m != n: model += x[i, p, m] - objects[l, m*2+1] >= W - M*d_pos[i, p, l, n, m+1] model += objects[l, m*2] - x[i, p, m] >= W - M*d_pos[i, p, l, n, m+N+1] d_neg = pulp.LpVariable.dicts( "plumeAvoidanceObstacleNeg", ((i, p, l, n, k) for i in range(T) for p in range(V) for l in range(numObjects) for n in range(N) for k in range(2*N+1)), cat='Binary') for i in range(T): for p in range(V): for l in range(numObjects): for n in range(N): model += pulp.lpSum(d_neg[i, p, l, n, k] for k in range(2*N+1)) <= 2*N model += u[i, p, n] >= - M*d_neg[i, p, l, n, 0] model += x[i, p, n] - objects[l, n*2+1] >= - M*d_neg[i, p, l, n, n+1] model += objects[l, n*2] - x[i, p, n] >= P - M*d_neg[i, p, l, n, n+N+1] for m in range(N): if m != n: model += x[i, p, m] - objects[l, m*2+1] >= W - M*d_neg[i, p, l, n, m+1] model += objects[l, m*2] - x[i, p, m] >= W - M*d_neg[i, p, l, n, m+N+1] # Final Configuration Selection # ----------------------------- if (activeConstraints["finalConfigurationSelection"]): G = V f = pulp.LpVariable.dicts( "finalConfigurationSelection", ((p, g, r) for p in range(V) for g in range(G) for r in range(V)), cat='Binary') for p in range(V): for k in range(2*N): model += x[T-1, p, k] == pulp.lpSum(x_fin[r, k]*f[p, g, r] for g in range(G) for r in range(V)) # model += x[T-1, p, k] == x_fin[p, k] for p in range(V): model += pulp.lpSum(f[p, g, r] for g in range(G) for r in range(V)) == 1 for p in range(V): for g in range(G): model += pulp.lpSum(f[p, g, r] for r in range(V)) == pulp.lpSum(f[r, g, p] for r in range(V)) for g in range(G): model += pulp.lpSum(f[p, g, r] for p in range(V) for r in range(V)) == V*pulp.lpSum(f[0, g, r] for r in range(V)) # Solve model and return results in dictionary model.solve(pulp.CPLEX()) # Create Pandas dataframe for results and return return {'model':model, 'x':x, 'u':u}
def __solve_joint_ilp__(self, feedback, non_feedback, summarizer, summary_length, uncertainity={}, labels={}, unique=False, excluded_solutions=[], solver='glpk'): """ :param summary_length: The size of the backpack. i.e. how many words are allowed in the summary. :param feedback: :param non_feedback: :param unique: if True, an boudin_2015 eq. (5) is applied to enforce a unique solution. :param solver: default glpk :param excluded_solutions: :return: """ w = summarizer.weights if self.run_config['rank_subset']: w = self.sentence_ranker.all_concept_weights u = uncertainity L = summary_length NF = len(non_feedback) F = len(feedback) S = len(summarizer.sentences) if not summarizer.word_frequencies: summarizer.compute_word_frequency() tokens = summarizer.word_frequencies.keys() f = summarizer.word_frequencies T = len(tokens) # HACK Sort keys # concepts = sorted(self.weights, key=self.weights.get, reverse=True) # formulation of the ILP problem prob = pulp.LpProblem(summarizer.input_directory, pulp.LpMaximize) # initialize the concepts binary variables nf = pulp.LpVariable.dicts(name='nf', indexs=range(NF), lowBound=0, upBound=1, cat='Integer') f = pulp.LpVariable.dicts(name='F', indexs=range(F), lowBound=0, upBound=1, cat='Integer') # initialize the sentences binary variables s = pulp.LpVariable.dicts(name='s', indexs=range(S), lowBound=0, upBound=1, cat='Integer') # initialize the word binary variables t = pulp.LpVariable.dicts(name='t', indexs=range(T), lowBound=0, upBound=1, cat='Integer') # OBJECTIVE FUNCTION if labels: # log.debug('solve for Active learning 2') prob += pulp.lpSum( w[non_feedback[i]] * (1.0 - u[non_feedback[i]]) * labels[non_feedback[i]] * nf[i] for i in range(NF)) if not labels: if uncertainity: # log.debug('solve for Active learning') if feedback: # In this phase, we force new concepts to be chosen, and not those we already have feedback on, and # therefore non_feedback is added while feedback is substracted from the problem. I.e. by # substracting the feedback, those sentences will disappear from the solution. prob += pulp.lpSum(w[non_feedback[i]] * u[non_feedback[i]] * nf[i] for i in range(NF)) - pulp.lpSum( w[feedback[i]] * u[feedback[i]] * f[i] for i in range(F)) else: prob += pulp.lpSum(w[non_feedback[i]] * u[non_feedback[i]] * nf[i] for i in range(NF)) if not uncertainity: # log.debug('solve for ILP feedback') if feedback: prob += pulp.lpSum(w[non_feedback[i]] * nf[i] for i in range(NF)) - pulp.lpSum( w[feedback[i]] * f[i] for i in range(F)) else: prob += pulp.lpSum(w[non_feedback[i]] * nf[i] for i in range(NF)) if unique: prob += pulp.lpSum(w[non_feedback[i]] * nf[i] for i in range(NF)) - pulp.lpSum(w[feedback[i]] * f[i] for i in range(F)) + \ 10e-6 * pulp.lpSum(f[tokens[k]] * t[k] for k in range(T)) # CONSTRAINT FOR SUMMARY SIZE prob += pulp.lpSum(s[j] * summarizer.sentences[j].length for j in range(S)) <= L # INTEGRITY CONSTRAINTS for i in range(NF): for j in range(S): if non_feedback[i] in summarizer.sentences[j].concepts: prob += s[j] <= nf[i] for i in range(NF): prob += pulp.lpSum(s[j] for j in range(S) if non_feedback[i] in summarizer.sentences[j].concepts) >= nf[i] for i in range(F): for j in range(S): if feedback[i] in summarizer.sentences[j].concepts: prob += s[j] <= f[i] for i in range(F): prob += pulp.lpSum(s[j] for j in range(S) if feedback[i] in summarizer.sentences[j].concepts) >= f[i] # WORD INTEGRITY CONSTRAINTS if unique: for k in range(T): for j in summarizer.w2s[tokens[k]]: prob += s[j] <= t[k] for k in range(T): prob += pulp.lpSum(s[j] for j in summarizer.w2s[tokens[k]]) >= t[k] # CONSTRAINTS FOR FINDING OPTIMAL SOLUTIONS for sentence_set in excluded_solutions: prob += pulp.lpSum([s[j] for j in sentence_set]) <= len(sentence_set) - 1 # prob.writeLP('test.lp') # solving the ilp problem try: #print('Solving using CPLEX') prob.solve(pulp.CPLEX(msg=0)) except: #print('Fallback to mentioned solver') if solver == 'gurobi': prob.solve(pulp.GUROBI(msg=0)) elif solver == 'glpk': prob.solve(pulp.GLPK(msg=0)) else: sys.exit('no solver specified') # retreive the optimal subset of sentences solution = Set([j for j in range(S) if s[j].varValue == 1]) # returns the (objective function value, solution) tuple return (pulp.value(prob.objective), solution)
def opt_with_solver(node_ind, order_dict, travel_t, stay_t, pick_t, require_t, num, mini_start, initial=None, load_check=True): # order_dict = {ord:(ori_id, dest_id)}, ord in order_set, ori_id, dest_id in node_ind # node_ind = range(n), travel_t = {(i,j): travel time between i and j} # initial = (given start id, given load) big_m = 10000 eps = 1.0 / 10**7 n = len(node_ind) inter_n = [(i, j) for i in node_ind for j in node_ind if j != i] off_time = lp.LpVariable('The route-off time') p = lp.LpVariable.dicts('Punish cost', node_ind, lowBound=0) x = lp.LpVariable.dicts('Route variable', inter_n, cat='Binary') o = lp.LpVariable.dicts('Start-point flag', node_ind, cat='Binary') d = lp.LpVariable.dicts('End-point flag', node_ind, cat='Binary') a = lp.LpVariable.dicts('Arrival time', node_ind) l = lp.LpVariable.dicts('Leave time', node_ind) t = lp.LpVariable.dicts('Order count', node_ind, 0, n - 1 + eps) if load_check: load = lp.LpVariable.dicts('Arrival load', node_ind, 0, MAX_LOADS + eps) else: load = lp.LpVariable.dicts('Arrival load', node_ind, 0) prob = lp.LpProblem('Optimize a route', lp.LpMinimize) # Objective prob += off_time + lp.lpSum(p[i] for i in node_ind) # Constraints for j in node_ind: prob += lp.lpSum(x[(i, j)] for i in node_ind if i != j) == 1 - o[j] for i in node_ind: prob += lp.lpSum(x[(i, j)] for j in node_ind if j != i) == 1 - d[i] prob += lp.lpSum(o[i] for i in node_ind) == 1 prob += lp.lpSum(d[i] for i in node_ind) == 1 if not (initial is None): prob += o[initial[0]] == 1 prob += load[initial[0]] == initial[1] for order in order_dict: od = order_dict[order] prob += a[od[1]] >= l[od[0]] for i in node_ind: prob += off_time >= l[i] prob += l[i] >= a[i] + stay_t[i] prob += l[i] >= pick_t[i] prob += a[i] >= mini_start[i] prob += p[i] >= PUNISH_CO * (a[i] - require_t[i]) for i, j in inter_n: prob += a[j] >= l[i] + travel_t[(i, j)] + big_m * (x[(i, j)] - 1) prob += t[j] >= t[i] + 1 + big_m * (x[(i, j)] - 1) prob += load[j] >= load[i] + num[i] + big_m * (x[(i, j)] - 1) prob.solve( lp.CPLEX(msg=1, timelimit=CPLEX_TIME_LIMIT, options=['set logfile cplex/cplex%d.log' % os.getpid()])) # set threads 100 if lp.LpStatus[prob.status] != 'Infeasible': sol_list = [int(round(t[i].varValue)) for i in node_ind] return lp.value(prob.objective), sol_list, lp.LpStatus[prob.status] else: return None, None, lp.LpStatus[prob.status]
def solve_ilp_problem(self, summary_size=100, units="WORDS", solver='glpk', excluded_solutions=[], unique=False): """Solve the ILP formulation of the concept-based model. :param summary_size: the maximum size in words of the summary, defaults to 100. :param units: defaults to "WORDS" :param solver: the solver used, defaults to glpk :param excluded_solutions: (list of list): a list of subsets of sentences that are to be excluded, defaults to [] :param unique: (bool): modify the model so that it produces only one optimal solution, defaults to False :return: (value, set) tuple (int, list): the value of the objective function and the set of selected sentences as a tuple. """ # initialize container shortcuts concepts = self.weights.keys() w = self.weights L = summary_size C = len(concepts) S = len(self.sentences) if not self.word_frequencies: self.compute_word_frequency() tokens = self.word_frequencies.keys() f = self.word_frequencies T = len(tokens) # HACK Sort keys concepts = sorted(self.weights, key=self.weights.get, reverse=True) # formulation of the ILP problem prob = pulp.LpProblem(self.input_directory, pulp.LpMaximize) # initialize the concepts binary variables c = pulp.LpVariable.dicts(name='c', indexs=range(C), lowBound=0, upBound=1, cat='Integer') # initialize the sentences binary variables s = pulp.LpVariable.dicts(name='s', indexs=range(S), lowBound=0, upBound=1, cat='Integer') # initialize the word binary variables t = pulp.LpVariable.dicts(name='t', indexs=range(T), lowBound=0, upBound=1, cat='Integer') # OBJECTIVE FUNCTION prob += pulp.lpSum(w[concepts[i]] * c[i] for i in range(C)) if unique: prob += pulp.lpSum(w[concepts[i]] * c[i] for i in range(C)) + \ 10e-6 * pulp.lpSum(f[tokens[k]] * t[k] for k in range(T)) # CONSTRAINT FOR SUMMARY SIZE if units == "WORDS": prob += pulp.lpSum(s[j] * self.sentences[j].length for j in range(S)) <= L if units == "CHARACTERS": prob += pulp.lpSum(s[j] * len(self.sentences[j].untokenized_form) for j in range(S)) <= L # INTEGRITY CONSTRAINTS for i in range(C): for j in range(S): if concepts[i] in self.sentences[j].concepts: prob += s[j] <= c[i] for i in range(C): prob += pulp.lpSum( s[j] for j in range(S) if concepts[i] in self.sentences[j].concepts) >= c[i] # WORD INTEGRITY CONSTRAINTS if unique: for k in range(T): for j in self.w2s[tokens[k]]: prob += s[j] <= t[k] for k in range(T): prob += pulp.lpSum(s[j] for j in self.w2s[tokens[k]]) >= t[k] # CONSTRAINTS FOR FINDING OPTIMAL SOLUTIONS for sentence_set in excluded_solutions: prob += pulp.lpSum([s[j] for j in sentence_set ]) <= len(sentence_set) - 1 # prob.writeLP('test.lp') # solving the ilp problem try: print('Solving using Cplex') prob.solve(pulp.CPLEX(msg=0)) except: print('Fallback to mentioned solver') if solver == 'gurobi': prob.solve(pulp.GUROBI(msg=0)) elif solver == 'glpk': prob.solve(pulp.GLPK(msg=0)) else: sys.exit('no solver specified') # retreive the optimal subset of sentences solution = set([j for j in range(S) if s[j].varValue == 1]) # returns the (objective function value, solution) tuple return (pulp.value(prob.objective), solution)
for k in storage) >= MinPctDemand * sumdk model += pulp.lpSum(Xjk[j, k] * TransCostjk.ix[(j, k), 2] for j in warehouse for k in storage) >= MinPctDemand * sumdk model += pulp.lpSum(Xjk[j, k] * TransCostjk.ix[(j, k), 3] for j in warehouse for k in storage) >= MinPctDemand * sumdk #Quantity - Quality linking constraint for i in supplier: for j in warehouse: model += Xij[(i, j)] * (1 - defective) >= netXij[(i, j)] #Number of facilities model += pulp.lpSum([zj[j] for j in warehouse]) >= zmin model += pulp.lpSum([zj[j] for j in warehouse]) <= zmax solver = pulp.CPLEX() model.setSolver(solver) model.solve() print(pulp.LpStatus[model.status]) print(pulp.value(model.objective)) count1 = 0 count2 = 0 for j in warehouse: if (zj[j].varValue == 1): print pulp.lpSum(Xjk[j, k].varValue for k in storage) if (pulp.lpSum(Xjk[j, k].varValue for k in storage) >= 1000000): FacilityCost = 300000 count1 = count1 + 1
############################################################### ############################################################### # Fitting the models # 3 hour time limit, note this does not count the presolve time tl = 3 * 60 * 60 pmed12 = pmed(Ar=areas, Di=dist_dict, Co=cont_dict, Ca=call_dict, Ta=12, In=0.1, Th=10) pmed12.solve(solver=pulp.CPLEX(timeLimit=tl, msg=True)) # takes around 10 minutes #pmed12.solve(solver=pulp.SCIP_CMD(msg=True)) # takes about 5 hours to get the solution #pmed12.solve(solver=pulp.GLPK_CMD(timeLimit=tl,msg=True)) # does not converge even after 12+ hours # Showing a map pmed12.map_plot(carr_report, 'PDGrid') # Figure out subtours stres = pmed12.collect_subtours() # Resolving with warm start with subtour constraints pmed12.solve(solver=pulp.CPLEX_CMD(timeLimit=tl, msg=False, warmStart=True)) # Now it is OK stres = pmed12.collect_subtours() pmed12.map_plot(carr_report, 'PDGrid')
import pulp as solver from pulp import * import Graph import os import gc import signal from tqdm import tqdm z = 0 solvers = [solver.CPLEX(timeLimit=7200), solver.GLPK(), solver.GUROBI()] solverUsado = 0 problems_packing = [ "Instances/packing/" + i for i in os.listdir("Instances/packing/") ] problems_sep = [ "Instances/separated/" + i for i in os.listdir("Instances/separated/") ] problems = problems_packing + problems_sep print(problems) #problems = problems[3:] def signal_handler(signum, frame): raise Exception("Timed out!") for ptk in problems: signal.signal(signal.SIGALRM, signal_handler) signal.alarm(8100) try: print("Initializing graph", ptk)
def avg_link_utilization(): h12 = 5 h13 = 10 h23 = 7 cap12 = 10 cap13 = 10 cap23 = 15 prob = pulp.LpProblem("3Node_MultiCommodity_AvgDelay", pulp.LpMinimize) # Defining the Flow Variables x12 = pulp.LpVariable('x12', lowBound=0, cat='Continuous') x132 = pulp.LpVariable('x132', lowBound=0, cat='Continuous') x13 = pulp.LpVariable('x13', lowBound=0, cat='Continuous') x123 = pulp.LpVariable('x123', lowBound=0, cat='Continuous') x23 = pulp.LpVariable('x23', lowBound=0, cat='Continuous') x213 = pulp.LpVariable('x213', lowBound=0, cat='Continuous') y12 = pulp.LpVariable('y12', lowBound=0, cat='Continuous') y13 = pulp.LpVariable('y13', lowBound=0, cat='Continuous') y23 = pulp.LpVariable('y23', lowBound=0, cat='Continuous') z12 = pulp.LpVariable('z12', lowBound=0) z13 = pulp.LpVariable('z13', lowBound=0) z23 = pulp.LpVariable('z23', lowBound=0) # Adding Objective Function prob += (z12 * math.pow(cap12, -1) + z13 * math.pow(cap13, -1) + z23 * math.pow(cap23, -1)) # Subject to Constraints prob += (x12 + x132 == h12) prob += (x13 + x123 == h13) prob += (x23 + x213 == h23) prob += (x12 + x123 + x213 == y12) prob += (x13 + x132 + x213 == y13) prob += (x23 + x123 + x123 == y23) prob += (z12 * 2 >= 3 * y12) prob += (z13 * 2 >= 3 * y13) prob += (z23 * 2 >= 3 * y23) prob += (z12 * 2 >= 9 * y12 - 2 * cap12) prob += (z13 * 2 >= 9 * y13 - 2 * cap13) prob += (z23 * 2 >= 9 * y23 - 2 * cap23) prob += (z12 >= 15 * y12 - 8 * cap12) prob += (z13 >= 15 * y13 - 8 * cap13) prob += (z23 >= 15 * y23 - 8 * cap23) prob += (z12 >= 50 * y12 - 36 * cap12) prob += (z13 >= 50 * y13 - 36 * cap13) prob += (z23 >= 50 * y23 - 36 * cap23) prob += (z12 >= 200 * y12 - 171 * cap12) prob += (z13 >= 200 * y13 - 171 * cap13) prob += (z23 >= 200 * y23 - 171 * cap23) prob += (z12 >= 4000 * y12 - 3781 * cap12) prob += (z13 >= 4000 * y13 - 3781 * cap13) prob += (z23 >= 4000 * y23 - 3781 * cap23) # Print the Problem print(prob) prob.writeLP("3node_MCF_AvgDelay.lp") # solve the LP using the CPLEX Solver optimization_result = prob.solve(pulp.CPLEX()) # make sure we got an optimal solution assert optimization_result == pulp.LpStatusOptimal # display the results for var in (x12, x132, x13, x123, x23, x213): print('Optimal Flow for {} is {:1.0f}'.format(var.name, var.value()))
def optimizeTrajectory(N, T, T_end, V, P, W, M, m, TSFC, minApproachDist, x_ini, x_fin, x_lim, u_lim, objects, r): # -------------------- # Calculated Variables # -------------------- del_t = T_end/T numObjects = objects.shape[0] # ------------------ # Decision variables # ------------------ # Thrust u = pulp.LpVariable.dicts( "input", ((i, p, n) for i in range(T) for p in range(V) for n in range(N)), cat='Continuous') # Thrust Magnitude v = pulp.LpVariable.dicts( "inputMag", ((i, p, n) for i in range(T) for p in range(V) for n in range(N)), lowBound=0, cat='Continuous') # State x = pulp.LpVariable.dicts( "state", ((i, p, k) for i in range(T) for p in range(V) for k in range(2*N)), cat='Continuous') # Object collision a = pulp.LpVariable.dicts( "objCol", ((i, p, l, k) for i in range(T) for p in range(V) for l in range(numObjects) for k in range(2*N)), cat='Binary') # Satellite Collision Avoidance b = pulp.LpVariable.dicts( "satelliteCollisionAvoidance", ((i, p, q, k) for i in range(T) for p in range(V) for q in range(V) for k in range(2*N)), cat='Binary') # Plume Impingement c_plus = pulp.LpVariable.dicts( "plumeImpingementPositive", ((i, p, q, n, k) for i in range(T) for p in range(V) for q in range(V) for n in range(N) for k in range(2*N)), cat='Binary') c_minus = pulp.LpVariable.dicts( "plumeImpingementNegative", ((i, p, q, n, k) for i in range(T) for p in range(V) for q in range(V) for n in range(N) for k in range(2*N)), cat='Binary') # ------------------ # Optimization Model # ------------------ # Instantiate Model model = pulp.LpProblem("Satellite Fuel Minimization Problem", pulp.LpMinimize) # Objective Function model += pulp.lpSum(v[i, p, n] for i in range(T) for p in range(V) for n in range(N)), "Fuel Minimization" # ----------- # Constraints # ----------- # Basic Constraints # ----------------- # Constrain thrust magnitude to abs(u[i, p, n]) for i in range(T): for p in range(V): for n in range(N): model += u[i, p, n] <= v[i, p, n] model += -u[i, p, n] <= v[i, p, n] # State and Input vector start and end values for p in range(V): for k in range(2*N): model += x[0, p, k] == x_ini[p, k] model += x[T-1, p, k] == x_fin[p, k] # Model Dynamics for constraint in freeSpaceDynamics(x, u, T, V, N, m, del_t): model += constraint # State and Input vector limits for i in range(T): for p in range(V): for n in range(N): model += u[i, p, n] <= u_lim[p, n] model += u[i, p, n] >= -u_lim[p, n] for k in range(2*N): # Necessary? model += x[i, p, k] <= x_lim[p, k] model += x[i, p, k] >= -x_lim[p, k] # Obstacle Avoidance # ------------------ if objects.shape[1] > 0: for i in range(T): for p in range(V): for l in range(numObjects): model += pulp.lpSum(a[i, p, l, n] for n in range(2*N)) <= 2*N-1 for n in range(N): model += x[i, p, n] >= objects[l, N+n] + minApproachDist - M*a[i, p, l, N+n] model += x[i, p, n] <= objects[l, n] - minApproachDist + M*a[i, p, l, n] # Collision Avoidance # ------------------- if V > 1: # If more than one vehicle for i in range(T): for p in range(V): for q in range(V): if q > p: model += pulp.lpSum(b[i, p, q, k] for k in range(2*N)) <= 2*N-1 for n in range(N): model += x[i, p, n] - x[i, q, n] >= r[n] - M*b[i, p, q, n] model += x[i, q, n] - x[i, p, n] >= r[n] - M*b[i, p, q, n+N] # Plume Impingement # ----------------- # Positive thrust if V > 1: # If more than one vehicle for i in range(T): for p in range(V): for q in range(V): if q != p: for n in range(N): model += pulp.lpSum(c_plus[i, p, q, n, k] for k in range(2*N)) <= 2*N model += -u[i, p, n] >= - M*c_plus[i, p, q, n, 0] model += x[i, p, n] - x[i, q, n] >= P - M*c_plus[i, p, q, n, n] model += x[i, q, n] - x[i, p, n] >= - M*c_plus[i, p, q, n, n+N] for m in range(N): if m != n: x[i, p, m] - x[i, q, m] >= W - M*c_plus[i, p, q, n, m] x[i, q, m] - x[i, p, m] >= W - M*c_plus[i, p, q, n, m+N] # Negative thrust for i in range(T): for p in range(V): for q in range(V): if q != p: for n in range(N): model += pulp.lpSum(c_minus[i, p, q, n, k] for k in range(2*N)) <= 2*N model += u[i, p, n] >= - M*c_minus[i, p, q, n, 0] model += x[i, p, n] - x[i, q, n] >= - M*c_minus[i, p, q, n, n] model += x[i, q, n] - x[i, p, n] >= P - M*c_minus[i, p, q, n, n+N] for m in range(N): if m != n: x[i, p, m] - x[i, q, n] >= W - M*c_minus[i, p, q, n, m] x[i, q, m] - x[i, p, m] >= W - M*c_minus[i, p, q, n, m+N] # Plume Avoidance for Vehicles # ---------------------------- # Plume Avoidance for Obstacles # ----------------------------- # Final Configuration Selection # ----------------------------- # Solve model and return results in dictionary model.solve(pulp.CPLEX()) # Create Pandas dataframe for results and return return {'model':model, 'x':x, 'u':u}
import pulp as solver from pulp import * import time import gc z = 0 solvers = [ solver.CPLEX(timeLimit=30), solver.GLPK(), solver.GUROBI(), solver.PULP_CBC_CMD(), solver.COIN() ] solverUsado = 3 def solver_exact(g, init, final, is_first, is_last, name): var = [(i + ',' + str(t)) for i in g.edge for t in range(1, g.z)] var2 = [(str(i) + ',' + str(t)) for i in g.vertices for t in range(1, g.z)] X = solver.LpVariable.dicts("X", var, cat=solver.LpBinary) Y = solver.LpVariable.dicts("Y", var2, cat=solver.LpBinary) problem = solver.LpProblem("The_best_Cut", solver.LpMinimize) if is_first: problem += (solver.lpSum( X.get( str(i.split(',')[0]) + ',' + str(i.split(',')[1]) + ',' + str(t)) * g.mis[i.split(',')[0]][i.split(',')[1]] for i in g.edge for t in range(1, g.z)) + solver.lpSum( ((g.pis[k.split(',')[0]][k.split(',')[1]])) - ((g.mis[k.split(',')[0]][k.split(',')[1]])) for k in g.edgeCuts) / 2) + solver.lpSum(
def solve_ilp_problem(self, summary_size=1500,solver='glpk', excluded_solutions=[]): """Solve the ILP formulation of the concept-based model. Args: summary_size (int): the maximum size in words of the summary, 摘要最大的单词数 defaults to 100. solver (str): the solver used, defaults to glpk. 缺省解决办法glpk excluded_solutions (list of list): a list of subsets of sentences that are to be excluded, defaults to [] Returns: (value, set) tuple (int, list): the value of the objective function and the set of selected sentences as a tuple. """ # initialize container shortcuts concepts = self.weights.keys()#权重关键字 w = self.weights#权重 L = summary_size#摘要大小 C = len(concepts)#权重概念数目 S = len(self.sentences)#句子长度 if not self.word_frequencies: self.compute_word_frequency()#如果不存在单词频率,则计算单词频率 tokens = self.word_frequencies.keys()#单词频率的标记 f = self.word_frequencies #单词频率 T = len(tokens)#单词数目 # HACK Sort keys concepts = sorted(self.weights, key=self.weights.get, reverse=True)#根据weight的key来进行排序 # formulation of the ILP problem prob = pulp.LpProblem(self.input_directory, pulp.LpMaximize) # initialize the concepts binary variables c = pulp.LpVariable.dicts(name='c', indexs=range(C), #权重概念数目 lowBound=0, upBound=1, cat='Integer') #用来构造变量字典,可以让我们不用一个个地创建Lp变量实例。name指定所有变量的前缀,index是列表,其中的元素会被用来构成变量名 #lowBound和upBound是下界和上界,默认分别是负无穷到正无穷,cat用来指定变量是离散(Integer,Binary)还是连续(Continuous)。 # initialize the sentences binary variables s = pulp.LpVariable.dicts(name='s', indexs=range(S), #句子长度 lowBound=0, upBound=1, cat='Integer') # initialize the word binary variables t = pulp.LpVariable.dicts(name='t', indexs=range(T), #单词数目 lowBound=0, upBound=1, cat='Integer') # OBJECTIVE FUNCTION prob += sum(w[concepts[i]] * c[i] for i in range(C))#使得概念权重*概念变量之和最大 # CONSTRAINT FOR SUMMARY SIZE 摘要大小的限制 prob += sum(s[j] * self.sentences[j].length for j in range(S)) <= L #判断是否取句子进入摘要,总长度小于L,s[j]取值应该是1/0 # INTEGRITY CONSTRAINTS 限制 for i in range(C): for j in range(S): if concepts[i] in self.sentences[j].concepts: prob += s[j] <= c[i]#如果s[j]小于等于c[i],那么prob加进去,不可能出现s[j]进去,c[j]没有的情况 for i in range(C): prob += sum(s[j] for j in range(S) if concepts[i] in self.sentences[j].concepts) >= c[i] #c[i]肯定是要小于s[j]的 # WORD INTEGRITY CONSTRAINTS # CONSTRAINTS FOR FINDING OPTIMAL SOLUTIONS for sentence_set in excluded_solutions: prob += sum([s[j] for j in sentence_set]) <= len(sentence_set)-1 # prob.writeLP('test.lp') # solving the ilp problem if solver == 'gurobi': prob.solve(pulp.GUROBI(msg=0)) elif solver == 'glpk': prob.solve(pulp.GLPK(msg=0)) elif solver == 'cplex': prob.solve(pulp.CPLEX(msg=0)) else: sys.exit('no solver specified') # retreive the optimal subset of sentences solution = set([j for j in range(S) if s[j].varValue == 1]) # returns the (objective function value, solution) tuple return (pulp.value(prob.objective), solution)