def get_best_libs_unlimited_ships(self, ind_libs_available, days_available, solverName="scip"): ind_books_available = set() for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: ind_books_available.add(book) ind_books_available = np.array(list(ind_books_available)) book_libs_lists_available = [[] for _ in range(self.num_books)] for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: book_libs_lists_available[book].append(lib) self.model = pmo.block() self.model.books = pmo.variable_dict() for book in ind_books_available: self.model.books[book] = pmo.variable(lb=0, ub=1) self.model.libs = pmo.variable_dict() for lib in ind_libs_available: self.model.libs[lib] = pmo.variable(domain=pmo.Binary) self.model.max_libs_in_time = pmo.constraint_list() self.model.max_libs_in_time.append( pmo.constraint( sum([ self.model.libs[lib] * self.lib_days[lib] for lib in ind_libs_available ]) <= days_available)) self.model.use_books = pmo.constraint_list() for book in ind_books_available: libs = book_libs_lists_available[book] self.model.use_books.append( pmo.constraint( self.model.books[book] <= sum(self.model.libs[lib] for lib in libs))) self.model.objective = pmo.objective(sum( self.book_points[book] * self.model.books[book] for book in ind_books_available), sense=-1) solver = self.get_solver(solverName) solver_result = solver.solve(self.model) result = [] for lib in ind_libs_available: if self.model.libs[lib] != 0: result.append(lib) return result
def define_model(**kwds): sense = kwds.pop("sense") m = block() m.x = variable_list() m.Fx = variable_list() m.piecewise = block_list() for i in range(4): m.x.append(variable(lb=0, ub=6)) m.Fx.append(variable()) m.piecewise.append( piecewise(breakpoints, values, input=m.x[i], output=m.Fx[i], **kwds)) m.obj = objective(expr=sum(m.Fx), sense=sense) # fix the answer for testing purposes m.set_answer = constraint_list() m.set_answer.append(constraint(m.x[0] == 0.0)) m.set_answer.append(constraint(m.x[1] == 3.0)) m.set_answer.append(constraint(m.x[2] == 5.5)) m.set_answer.append(constraint(m.x[3] == 6.0)) return m
def define_model(**kwds): sense = kwds.pop("sense") m = pmo.block() m.x = pmo.variable_list() m.Fx = pmo.variable_list() m.piecewise = pmo.block_list() for i in range(7): m.x.append(pmo.variable(lb=-5, ub=4)) m.Fx.append(pmo.variable()) m.piecewise.append( pmo.piecewise(breakpoints, values, input=m.x[i], output=m.Fx[i], **kwds)) m.obj = pmo.objective(expr=sum(m.Fx), sense=sense) # fix the answer for testing purposes m.set_answer = pmo.constraint_list() m.set_answer.append(pmo.constraint(m.x[0] == -5.0)) m.set_answer.append(pmo.constraint(m.x[1] == -3.0)) m.set_answer.append(pmo.constraint(m.x[2] == -2.5)) m.set_answer.append(pmo.constraint(m.x[3] == -1.5)) m.set_answer.append(pmo.constraint(m.x[4] == 2.0)) m.set_answer.append(pmo.constraint(m.x[5] == 3.5)) m.set_answer.append(pmo.constraint(m.x[6] == 4.0)) return m
def define_model(**kwds): sense = kwds.pop("sense") m = pmo.block() m.x = pmo.variable_list() m.Fx = pmo.variable_list() m.piecewise = pmo.block_list() for i in range(4): m.x.append(pmo.variable(lb=0, ub=3)) m.Fx.append(pmo.variable()) m.piecewise.append( pmo.piecewise(breakpoints, values, input=m.x[i], output=m.Fx[i], **kwds)) m.obj = pmo.objective(expr=sum(m.Fx) + sum(m.x), sense=sense) # fix the answer for testing purposes m.set_answer = pmo.constraint_list() # Fx1 should solve to 0 m.set_answer.append(pmo.constraint(expr= m.x[0] == 0.5)) m.set_answer.append(pmo.constraint(expr= m.x[1] == 1.0)) m.set_answer.append(pmo.constraint(expr= m.Fx[1] == 0.5)) # Fx[2] should solve to 1 m.set_answer.append(pmo.constraint(expr= m.x[2] == 1.5)) # Fx[3] should solve to 1.5 m.set_answer.append(pmo.constraint(expr= m.x[3] == 2.5)) return m
def build_constraint_list(): """Build a constraint_list with no references to external objects so its size can be computed.""" return constraint_list( constraint(rhs=1, body=sum(A_data[p]*X_kernel[A_indices[p]] for p in range(A_indptr[i], A_indptr[i+1]))) for i in range(N))
def define_model(**kwds): sense = kwds.pop("sense") m = pmo.block() m.x = pmo.variable_list() m.Fx = pmo.variable_list() m.piecewise = pmo.block_list() for i in range(7): m.x.append(pmo.variable(lb=-5, ub=4)) m.Fx.append(pmo.variable()) m.piecewise.append( pmo.piecewise(breakpoints, values, input=m.x[i], output=m.Fx[i], **kwds)) m.obj = pmo.objective(expr=sum(m.Fx), sense=sense) # fix the answer for testing purposes m.set_answer = pmo.constraint_list() m.set_answer.append(pmo.constraint(m.x[0] == -5.0)) m.set_answer.append(pmo.constraint(m.x[1] == -3.0)) m.set_answer.append(pmo.constraint(m.x[2] == -2.5)) m.set_answer.append(pmo.constraint(m.x[3] == -1.5)) m.set_answer.append(pmo.constraint(m.x[4] == 2.0)) m.set_answer.append(pmo.constraint(m.x[5] == 3.5)) m.set_answer.append(pmo.constraint(m.x[6] == 4.0)) return m
def build_linear_constraint_list(): """Build a constraint_list of linear_constraints with no references to external objects so its size can be computed.""" return constraint_list( linear_constraint(variables=(X_kernel[A_indices[p]] for p in range(A_indptr[i], A_indptr[i+1])), coefficients=(A_data[p] for p in range(A_indptr[i], A_indptr[i+1])), rhs=1) for i in range(N))
def solve_pyomo_kernel(self, solver='cplex'): """ Solve the problem using the kernel library of the Pyomo package. Parameters ---------- solver (str, default:'cplex'): defines the solver used to solve the optimization problem Returns ------- obj_fun (real): objective function sol (list): optimal solution of variables """ # Model m = pk.block() # Sets m.i = range(self.nvar) m.j = range(self.ncon) # Variables m.x = pk.variable_list() for _ in m.i: m.x.append(pk.variable(domain=pk.Reals, lb=0)) # Objective function m.obj = pk.objective(pe.quicksum(self.c[i] * m.x[i] for i in m.i), sense=pk.minimize) # Constraints m.con = pk.constraint_list() for j in m.j: m.con.append( pk.constraint(body=pe.quicksum(self.A[j][i] * m.x[i] for i in m.i), lb=None, ub=self.b[j])) # Solve problem res = pe.SolverFactory(solver).solve(m, symbolic_solver_labels=True, tee=True) print(res['Solver'][0]) # Output return round(m.obj(), 2), [round(m.x[i].value, 2) for i in m.i]
class IJunk(IBlock): __slots__ = () class junk(pmo.block): _ctype = IJunk class junk_list(pmo.block_list): __slots__ = () _ctype = IJunk _model = pmo.block() _model.v = pmo.variable() _model.V = pmo.variable_list() _model.V.append(pmo.variable()) _model.V.append(pmo.variable_list()) _model.V[1].append(pmo.variable()) _model.c = pmo.constraint() _model.C = pmo.constraint_list() _model.C.append(pmo.constraint()) _model.C.append(pmo.constraint_list()) _model.C[1].append(pmo.constraint()) b_clone = _model.clone() _model.b = b_clone.clone() _model.B = pmo.block_list() _model.B.append(b_clone.clone()) _model.B.append(pmo.block_list()) _model.B[1].append(b_clone.clone()) del b_clone _model.j = junk() _model.J = junk_list() _model.J.append(junk()) _model.J.append(junk_list()) _model.J[1].append(junk())
_ctype = IJunk class junk_list(pmo.block_list): __slots__ = () _ctype = IJunk _model = pmo.block() _model.v = pmo.variable() _model.V = pmo.variable_list() _model.V.append(pmo.variable()) _model.V.append(pmo.variable_list()) _model.V[1].append(pmo.variable()) _model.c = pmo.constraint() _model.C = pmo.constraint_list() _model.C.append(pmo.constraint()) _model.C.append(pmo.constraint_list()) _model.C[1].append(pmo.constraint()) b_clone = _model.clone() _model.b = b_clone.clone() _model.B = pmo.block_list() _model.B.append(b_clone.clone()) _model.B.append(pmo.block_list()) _model.B[1].append(b_clone.clone()) del b_clone _model.j = junk() _model.J = junk_list() _model.J.append(junk()) _model.J.append(junk_list()) _model.J[1].append(junk())
# Create the parameters model.param_cost = pmo.parameter_dict() for _worker in model.set_workers: for _task in model.set_tasks: model.param_cost[(_worker, _task)] = pmo.parameter(costs[_worker][_task]) # Create the variables model.var_x = pmo.variable_dict() for _worker in model.set_workers: for _task in model.set_tasks: model.var_x[(_worker, _task)] = pmo.variable(domain=pmo.Binary) # Create the constraints ## Each task is assigned to at least 1 worker model.con_task = pmo.constraint_list() for _task in model.set_tasks: model.con_task.append( pmo.constraint( sum(model.var_x[(_worker, _task)] for _worker in model.set_workers) >= 1)) ## Total size of tasks for each worker is at most total_size_max model.con_size = pmo.constraint_list() for _worker in model.set_workers: model.con_task.append( pmo.constraint( sum(sizes[_task] * model.var_x[(_worker, _task)] for _task in model.set_tasks) <= TOTAL_SIZE_MAX)) # Create the objective expr = pmo.expression_list()
import pyomo.kernel as pmo # # List containers # vl = pmo.variable_list( pmo.variable() for i in range(10)) cl = pmo.constraint_list() for i in range(10): cl.append(pmo.constraint(vl[-1] == 1)) cl.insert(0, pmo.constraint(vl[0]**2 >= 1)) del cl[0] # # Dict containers # vd = pmo.variable_dict( ((str(i), pmo.variable()) for i in range(10))) cd = pmo.constraint_dict( (i, pmo.constraint(v == 1)) for i,v in vd.items()) cd = pmo.constraint_dict() for i, v in vd.items(): cd[i] = pmo.constraint(v == 1)
# Create the parameters model.param_cost = pmo.parameter_dict() for _worker in model.set_workers: for _task in model.set_tasks: model.param_cost[(_worker, _task)] = pmo.parameter(costs[_worker][_task]) # Create the variables model.var_x = pmo.variable_dict() for _worker in model.set_workers: for _task in model.set_tasks: model.var_x[(_worker, _task)] = pmo.variable(domain=pmo.Binary) # Create the constraints ## Each worker is assigned to at most 1 task model.con_worker = pmo.constraint_list() for _worker in model.set_workers: model.con_worker.append( pmo.constraint( sum(model.var_x[(_worker, _task)] for _task in model.set_tasks) <= 1)) ## Each task is assigned to exactly 1 worker model.con_task = pmo.constraint_list() for _task in model.set_tasks: model.con_task.append( pmo.constraint( sum(model.var_x[(_worker, _task)] for _worker in model.set_workers) == 1)) # Create the objective expr = pmo.expression_list()
# define an optimization model with indexed containers b = pmo.block() b.p = pmo.parameter() b.plist = pmo.parameter_list(pmo.parameter() for i in range(10)) b.pdict = pmo.parameter_dict( ((i, j), pmo.parameter()) for i in range(10) for j in range(10)) b.x = pmo.variable() b.xlist = pmo.variable_list(pmo.variable() for i in range(10)) b.xdict = pmo.variable_dict( ((i, j), pmo.variable()) for i in range(10) for j in range(10)) b.c = pmo.constraint(b.x >= 1) b.clist = pmo.constraint_list( pmo.constraint(b.xlist[i] >= i) for i in range(10)) b.cdict = pmo.constraint_dict(((i, j), pmo.constraint(b.xdict[i, j] >= i * j)) for i in range(10) for j in range(10)) b.o = pmo.objective(b.x + sum(b.xlist) + sum(b.xdict.values())) # # Define a custom tiny_block # # The tiny_block class uses more efficient storage for the # case when a small number of objects are placed on the block. class Widget(pmo.tiny_block): def __init__(self, p, input=None): super(Widget, self).__init__()
def create_optimization_model(self, config): self.logger.info('Creating optimization model.') # Consider using context managers # limit_sell = False # GET COMPONENTS FROM SYSTEM if self.system.has_battery: battery = self.system.get_battery_object() if self.system.has_external_grid: supply = self.system.get_external_grid_object() # STARTING MODEL m = pk.block() # Track the default attributes of the model to be aware of which the user adds. default_attributes = set(m.__dict__.keys()) default_attributes.add('default_attributes') # SETS m.periods = range(config['periods']) m.E_set = [] # VARIABLES m.E = pk.variable_dict() if self.system.has_stochastic_generators and not self.system.has_external_grid: m.E_set.append('stochastic') m.E['stochastic'] = pk.variable_list() for t in m.periods: m.E['stochastic'].append( pk.variable(domain_type=pk.RealSet, lb=0, ub=self.system.stochastic_electrical_gen[t])) if self.system.has_external_grid: m.E_set.append('buy') m.E_set.append('sell') m.E['buy'] = pk.variable_list() for _ in m.periods: m.E['buy'].append(pk.variable(domain=pk.NonNegativeReals)) m.E['sell'] = pk.variable_list() for _ in m.periods: m.E['sell'].append(pk.variable(domain=pk.NonNegativeReals)) m.y_grid = pk.variable_list() for _ in m.periods: m.y_grid.append( pk.variable(domain_type=pk.IntegerSet, lb=0, ub=1)) if self.system.has_battery: m.E_set.append('batt_chrg') m.E_set.append('batt_dis') m.E['batt_chrg'] = pk.variable_list() for _ in m.periods: # The upper bound are impose in the constraints below m.E['batt_chrg'].append( pk.variable(domain_type=pk.RealSet, lb=0)) m.E['batt_dis'] = pk.variable_list() for _ in m.periods: m.E['batt_dis'].append( pk.variable(domain_type=pk.RealSet, lb=0)) m.y_bat = pk.variable_list() for _ in m.periods: m.y_bat.append( pk.variable(domain_type=pk.IntegerSet, lb=0, ub=1)) m.soc = pk.variable_list() for _ in m.periods: m.soc.append( pk.variable(domain_type=pk.RealSet, lb=battery.soc_lb, ub=battery.soc_ub)) # Extra soc variable for the last value of soc that should be >= soc_l m.soc.append( pk.variable(domain_type=pk.RealSet, lb=battery.soc_l, ub=battery.soc_ub)) # PARAMETERS if self.system.has_external_grid: m.prices = { 'buy': supply.electricity_purchase_prices.copy(), 'sell': supply.electricity_selling_prices.copy(), } # OBJECTIVE FUNCTION obj_exp = 0 obj_sense = pk.minimize if self.system.has_external_grid: obj_exp = quicksum((m.E['buy'][t] * m.prices['buy'][t] for t in m.periods), linear=True) \ - quicksum((m.E['sell'][t] * m.prices['sell'][t] for t in m.periods), linear=True) m.obj = pk.objective(obj_exp, sense=obj_sense) # CONSTRAINTS # Grid constraints # if limit_sell: # m.c_limit_sell = pk.constraint( # lb=0, body=system['selling_ratio'] # * sum(m.E['buy'][t] + system['E_pv'][t] for t in m.periods) # - sum(m.E['sell'][t] for t in m.periods)) grid_m = 1e5 m.cl_y_buy = pk.constraint_list() for t in m.periods: m.cl_y_buy.append( pk.constraint(body=m.y_grid[t] * grid_m - m.E['buy'][t], lb=0)) m.cl_y_sell = pk.constraint_list() for t in m.periods: m.cl_y_sell.append( pk.constraint(body=(1 - m.y_grid[t]) * grid_m - m.E['sell'][t], lb=0)) # Balance constraints energy_balance_exp = [0 for _ in m.periods] if self.system.has_fix_loads: for t in m.periods: energy_balance_exp[t] = -1 * self.system.fix_electrical_load[t] if self.system.has_external_grid: for t in m.periods: energy_balance_exp[ t] = energy_balance_exp[t] + m.E['buy'][t] - m.E['sell'][t] if self.system.has_battery: for t in m.periods: energy_balance_exp[t] = energy_balance_exp[t] + m.E[ 'batt_dis'][t] - m.E['batt_chrg'][t] if self.system.has_stochastic_generators and not self.system.has_external_grid: for t in m.periods: energy_balance_exp[ t] = energy_balance_exp[t] + m.E['stochastic'][t] else: for t in m.periods: energy_balance_exp[t] = energy_balance_exp[ t] + self.system.stochastic_electrical_gen[t] m.cl_balance = pk.constraint_list() for t in m.periods: m.cl_balance.append( pk.constraint(body=energy_balance_exp[t], rhs=0)) # Battery constraints and restrictions if self.system.has_battery: m.soc[0].fix(battery.soc_0) m.cl_soc = pk.constraint_list() for t in m.periods: m.cl_soc.append( pk.constraint( body=battery.batt_C * (m.soc[t + 1] - m.soc[t]) + 1 / battery.batt_dis_per * m.E['batt_dis'][t] - battery.batt_chrg_per * m.E['batt_chrg'][t], rhs=0)) m.cl_y_char = pk.constraint_list() for t in m.periods: m.cl_y_char.append( pk.constraint(body=m.y_bat[t] * battery.batt_chrg_speed - m.E['batt_chrg'][t], lb=0)) m.cl_y_dis = pk.constraint_list() for t in m.periods: m.cl_y_char.append( pk.constraint( body=(1 - m.y_bat[t]) * battery.batt_dis_speed - m.E['batt_dis'][t], lb=0)) # FINISHING # Determine the user defined attributes (written in this source code) by subtracting the defaults one. all_attributes = set(m.__dict__.keys()) m.user_defined_attributes = list(all_attributes - default_attributes) self.optimization_model = m return m
def get_optimal_books_for_ordered_libs(self, ind_libs_best, days_available=None, book_points_available=None, solverName="scip"): if days_available is None: days_available = self.num_days if book_points_available is None: book_points_available = self.book_points lib_num_books_available = np.zeros(self.num_libs, dtype=int) ind_libs_available = [] for lib in ind_libs_best: days_available -= self.lib_days[lib] lib_num_books_available[lib] = days_available * self.lib_ships[lib] ind_libs_available = ind_libs_best ind_books_available = set() for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: if book_points_available[book] != 0: ind_books_available.add(book) ind_books_available = np.array(list(ind_books_available)) book_libs_lists_available = [[] for _ in range(self.num_books)] for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: book_libs_lists_available[book].append(lib) self.model = pmo.block() self.model.books = pmo.variable_dict() for book in ind_books_available: self.model.books[book] = pmo.variable(lb=0, ub=1) self.model.lib_books = pmo.variable_dict() for lib in ind_libs_available: for book in self.lib_books_lists[lib]: self.model.lib_books[lib, book] = pmo.variable(domain=pmo.Binary) self.model.every_book_once = pmo.constraint_list() for book in ind_books_available: libs = book_libs_lists_available[book] self.model.every_book_once.append( pmo.constraint( sum(self.model.lib_books[lib, book] for lib in libs) <= 1)) self.model.use_books = pmo.constraint_list() for book in ind_books_available: libs = book_libs_lists_available[book] self.model.use_books.append( pmo.constraint(self.model.books[book] <= sum( self.model.lib_books[lib, book] for lib in libs))) self.model.max_books_per_lib = pmo.constraint_list() for lib in ind_libs_available: books = self.lib_books_lists[lib] num_books = lib_num_books_available[lib] self.model.max_books_per_lib.append( pmo.constraint( sum(self.model.lib_books[lib, book] for book in books) <= num_books)) self.model.objective = pmo.objective(sum( book_points_available[book] * self.model.books[book] for book in ind_books_available), sense=-1) solver = self.get_solver(solverName) solver_result = solver.solve(self.model) # Can be used to see solver results # print(solver_result) result = [] for lib in ind_libs_available: books = self.lib_books_lists[lib] result.append((lib, [ book for book in books if self.model.lib_books.get((lib, book)) != 0 ])) return result
# @Constraints_single m.c = pmo.constraint(sum(m.vd.values()) <= 9) # @Constraints_single # @Constraints_dict m.cd = pmo.constraint_dict() for i in m.s: for j in m.q: m.cd[i,j] = \ pmo.constraint( body=m.vd[i], rhs=j) # @Constraints_dict # @Constraints_list # uses 0-based indexing m.cl = pmo.constraint_list() for j in m.q: m.cl.append(pmo.constraint(lb=-5, body=m.vl[j] - m.v, ub=5)) # @Constraints_list # @Expressions_single m.e = pmo.expression(-m.v) # @Expressions_single # @Expressions_dict m.ed = pmo.expression_dict() for i in m.s: m.ed[i] = \ pmo.expression(-m.vd[i]) # @Expressions_dict # @Expressions_list # uses 0-based indexed
def get_optimal_ordering_and_books(self, ind_libs_available, days_available=None, book_points_available=None, solverName="scip"): if days_available is None: days_available = self.num_days if book_points_available is None: book_points_available = self.book_points ind_books_available = set() for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: if book_points_available[book] != 0: ind_books_available.add(book) ind_books_available = np.array(list(ind_books_available)) book_libs_lists_available = [[] for _ in range(self.num_books)] for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: book_libs_lists_available[book].append(lib) ind_index_available = np.arange(len(ind_libs_available)) self.model = pmo.block() self.model.books = pmo.variable_dict() for book in ind_books_available: self.model.books[book] = pmo.variable(lb=0, ub=1) self.model.lib_books = pmo.variable_dict() for lib in ind_libs_available: for book in self.lib_books_lists[lib]: self.model.lib_books[lib, book] = pmo.variable(lb=0, ub=1) self.model.lib_index = pmo.variable_dict() for lib in ind_libs_available: for index in ind_index_available: self.model.lib_index[lib, index] = pmo.variable(domain=pmo.Binary) self.model.times_remaining = pmo.variable_dict() for time in ind_index_available: self.model.times_remaining[time] = pmo.variable(lb=0, ub=self.num_days) self.model.lib_times_remaining = pmo.variable_dict() for lib in ind_libs_available: self.model.lib_times_remaining[lib] = pmo.variable(lb=0, ub=2 * self.num_days) self.model.every_book_once = pmo.constraint_list() for book in ind_books_available: libs = book_libs_lists_available[book] self.model.every_book_once.append( pmo.constraint( sum(self.model.lib_books[lib, book] for lib in libs) <= 1)) self.model.use_books = pmo.constraint_list() for book in ind_books_available: libs = book_libs_lists_available[book] self.model.use_books.append( pmo.constraint(self.model.books[book] <= sum( self.model.lib_books[lib, book] for lib in libs))) self.model.one_place_per_lib = pmo.constraint_list() for lib in ind_libs_available: self.model.one_place_per_lib.append( pmo.constraint( sum([ self.model.lib_index[lib, index] for index in ind_index_available ]) == 1)) self.model.one_lib_per_place = pmo.constraint_list() for index in ind_index_available: self.model.one_lib_per_place.append( pmo.constraint( sum([ self.model.lib_index[lib, index] for lib in ind_libs_available ]) == 1)) self.model.use_libs = pmo.constraint_list() for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: self.model.use_libs.append( pmo.constraint(self.model.lib_books[lib, book] <= sum([ self.model.lib_index[lib, index] for index in ind_index_available ]))) self.model.remaining_times = pmo.constraint_list() for time in ind_index_available: prev_time = self.model.times_remaining[ time - 1] if time else days_available self.model.remaining_times.append( pmo.constraint( self.model.times_remaining[time] == prev_time - sum([ self.model.lib_index[lib, time] * self.lib_days[lib] for lib in ind_libs_available ]))) self.model.lib_remaining_times = pmo.constraint_list() for time in ind_index_available: for lib in ind_libs_available: self.model.lib_remaining_times.append( pmo.constraint( self.model.lib_times_remaining[lib] <= self.model.times_remaining[time] + days_available * (1 - self.model.lib_index[lib, time]))) self.model.lib_max_num_books = pmo.constraint_list() for lib in ind_libs_available: books = self.lib_books_lists[lib] self.model.lib_max_num_books.append( pmo.constraint( sum([self.model.lib_books[lib, book] for book in books]) <= self.lib_ships[lib] * self.model.lib_times_remaining[lib])) self.model.objective = pmo.objective(sum( book_points_available[book] * self.model.books[book] for book in ind_books_available), sense=-1) solver = self.get_solver(solverName) solver_result = solver.solve(self.model) result = [] for index in range(len(ind_libs_available)): for lib in ind_libs_available: if self.model.lib_index.get((lib, index)) != 0: books = self.lib_books_lists[lib] result.append((lib, [ book for book in books if self.model.lib_books.get((lib, book)) != 0 ])) return result
capacities = [100] * 5 model = pmo.block() # Create the sets model.set_goods = range(len(values)) model.set_bins = range(len(capacities)) # Create the variables model.var_pack = pmo.variable_dict() for i in model.set_goods: for j in model.set_bins: model.var_pack[(i, j)] = pmo.variable(domain=pmo.Binary) # Create the constraints model.con_capacity = pmo.constraint_list() for j in model.set_bins: model.con_capacity.append( pmo.constraint( sum(model.var_pack[(i, j)] * weights[i] for i in model.set_goods) <= capacities[j])) model.con_ispack = pmo.constraint_list() for i in model.set_goods: model.con_ispack.append( pmo.constraint( sum(model.var_pack[(i, j)] for j in model.set_bins) <= 1)) # Create the objective model.obj = pmo.objective(sum(model.var_pack[(i, j)] * values[i] for i in model.set_goods
def get_optimal_ordering_and_books_for_subsection(self, ind_libs_available, lo, hi, solverName="scip"): days_available = self.num_days book_points_available = self.book_points ind_books_available = set() for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: if book_points_available[book] != 0: ind_books_available.add(book) ind_books_available = np.array(list(ind_books_available)) book_libs_lists_available = [[] for _ in range(self.num_books)] for lib in ind_libs_available: books = self.lib_books_lists[lib] for book in books: book_libs_lists_available[book].append(lib) ind_index_available = np.arange(hi - lo) ind_libs_available_reorder = ind_libs_available[lo:hi] days_available_reorder = days_available - self.lib_days[ ind_libs_available[:lo]].sum() lib_num_books_available = np.zeros(self.num_libs, dtype=int) days_remaining = days_available for lib in ind_libs_available: days_remaining -= self.lib_days[lib] lib_num_books_available[lib] = days_remaining * self.lib_ships[lib] self.model = pmo.block() self.model.books = pmo.variable_dict() for book in ind_books_available: self.model.books[book] = pmo.variable(lb=0, ub=1) self.model.lib_books = pmo.variable_dict() for lib in ind_libs_available: for book in self.lib_books_lists[lib]: self.model.lib_books[lib, book] = pmo.variable(lb=0, ub=1) self.model.lib_index = pmo.variable_dict() for lib in ind_libs_available_reorder: for index in ind_index_available: self.model.lib_index[lib, index] = pmo.variable(domain=pmo.Binary) self.model.times_remaining = pmo.variable_dict() for time in ind_index_available: self.model.times_remaining[time] = pmo.variable(lb=0, ub=self.num_days) self.model.lib_times_remaining = pmo.variable_dict() for lib in ind_libs_available_reorder: self.model.lib_times_remaining[lib] = pmo.variable(lb=0, ub=2 * self.num_days) self.model.every_book_once = pmo.constraint_list() for book in ind_books_available: libs = book_libs_lists_available[book] self.model.every_book_once.append( pmo.constraint( sum(self.model.lib_books[lib, book] for lib in libs) <= 1)) self.model.use_books = pmo.constraint_list() for book in ind_books_available: libs = book_libs_lists_available[book] self.model.use_books.append( pmo.constraint(self.model.books[book] <= sum( self.model.lib_books[lib, book] for lib in libs))) self.model.one_place_per_lib = pmo.constraint_list() for lib in ind_libs_available_reorder: self.model.one_place_per_lib.append( pmo.constraint( sum([ self.model.lib_index[lib, index] for index in ind_index_available ]) == 1)) self.model.one_lib_per_place = pmo.constraint_list() for index in ind_index_available: self.model.one_lib_per_place.append( pmo.constraint( sum([ self.model.lib_index[lib, index] for lib in ind_libs_available_reorder ]) == 1)) self.model.use_libs = pmo.constraint_list() for lib in ind_libs_available_reorder: books = self.lib_books_lists[lib] for book in books: self.model.use_libs.append( pmo.constraint(self.model.lib_books[lib, book] <= sum([ self.model.lib_index[lib, index] for index in ind_index_available ]))) self.model.remaining_times = pmo.constraint_list() for time in ind_index_available: prev_time = self.model.times_remaining[ time - 1] if time else days_available_reorder self.model.remaining_times.append( pmo.constraint( self.model.times_remaining[time] == prev_time - sum([ self.model.lib_index[lib, time] * self.lib_days[lib] for lib in ind_libs_available_reorder ]))) self.model.lib_remaining_times = pmo.constraint_list() for time in ind_index_available: for lib in ind_libs_available_reorder: self.model.lib_remaining_times.append( pmo.constraint( self.model.lib_times_remaining[lib] <= self.model.times_remaining[time] + days_available * (1 - self.model.lib_index[lib, time]))) self.model.lib_max_num_books = pmo.constraint_list() for lib in ind_libs_available_reorder: books = self.lib_books_lists[lib] self.model.lib_max_num_books.append( pmo.constraint( sum([self.model.lib_books[lib, book] for book in books]) <= self.lib_ships[lib] * self.model.lib_times_remaining[lib])) self.model.max_books_per_lib = pmo.constraint_list() for lib in ind_libs_available: if not lib in list(ind_libs_available_reorder): books = self.lib_books_lists[lib] num_books = lib_num_books_available[lib] self.model.max_books_per_lib.append( pmo.constraint( sum(self.model.lib_books[lib, book] for book in books) <= num_books)) self.model.objective = pmo.objective(sum( book_points_available[book] * self.model.books[book] for book in ind_books_available), sense=-1) solver = self.get_solver(solverName) solver_result = solver.solve(self.model) # Can be used to see solver results # print(solver_result) result = [] for lib in ind_libs_available[:lo]: books = self.lib_books_lists[lib] result.append((lib, [ book for book in books if self.model.lib_books.get((lib, book)) != 0 ])) for index in ind_index_available: for lib in ind_libs_available_reorder: if self.model.lib_index.get((lib, index)) != 0: books = self.lib_books_lists[lib] result.append((lib, [ book for book in books if self.model.lib_books.get((lib, book)) != 0 ])) for lib in ind_libs_available[hi:]: books = self.lib_books_lists[lib] result.append((lib, [ book for book in books if self.model.lib_books.get((lib, book)) != 0 ])) return result
model.var_group2 = pmo.variable_dict() for _pair in range(5): model.var_group2[_pair] = pmo.variable(domain=pmo.Binary) model.var_group3 = pmo.variable_dict() for _pair in range(5): model.var_group3[_pair] = pmo.variable(domain=pmo.Binary) model.var_x = pmo.variable_dict() for _worker in model.set_workers: for _task in model.set_tasks: model.var_x[(_worker, _task)] = pmo.variable(domain=pmo.Binary) # Create the constraints ## Each pair in groups can only be chosen once model.con_group = pmo.constraint_list() model.con_group.append( pmo.constraint(sum(model.var_group1[_pair] for _pair in range(5)) == 1)) model.con_group.append( pmo.constraint(sum(model.var_group2[_pair] for _pair in range(5)) == 1)) model.con_group.append( pmo.constraint(sum(model.var_group3[_pair] for _pair in range(5)) == 1)) ## Each task is assigned to exactly 1 worker model.con_task = pmo.constraint_list() for _task in model.set_tasks: model.con_task.append( pmo.constraint( sum(model.var_x[(_worker, _task)] for _worker in model.set_workers) == 1)) ## Each worker is assigned to at most 1 task