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
