def solve_nonlinear(Aw, Af, alpha, beta, gamma, delta):
m = pmo.block()
m.h = pmo.variable(lb=0)
m.w = pmo.variable(lb=0)
m.d = pmo.variable(lb=0)
m.c = pmo.constraint_tuple([
pmo.constraint(body=2 * (m.h * m.w + m.h * m.d), ub=Aw),
pmo.constraint(body=m.w * m.d, ub=Af),
pmo.constraint(lb=alpha, body=m.h / m.w, ub=beta),
pmo.constraint(lb=gamma, body=m.d / m.w, ub=delta)
])
m.o = pmo.objective(m.h * m.w * m.d, sense=pmo.maximize)
m.h.value, m.w.value, m.d.value = (1, 1, 1)
ipopt = pmo.SolverFactory("ipopt")
result = ipopt.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("nonlinear solution:")
print("h: {0:.4f}, w: {1:.4f}, d: {2:.4f}".\
format(m.h(), m.w(), m.d()))
print("volume: {0: .5f}".\
format(m.o()))
print("")
def solve_nonlinear():
m = pmo.block()
m.x = pmo.variable()
m.y = pmo.variable()
m.z = pmo.variable()
m.c = pmo.constraint_tuple([
pmo.constraint(body=0.1 * pmo.sqrt(m.x) + (2.0 / m.y), ub=1),
pmo.constraint(body=(1.0 / m.z) + (m.y / (m.x**2)), ub=1)
])
m.o = pmo.objective(m.x + (m.y**2) * m.z, sense=pmo.minimize)
m.x.value, m.y.value, m.z.value = (1, 1, 1)
ipopt = pmo.SolverFactory("ipopt")
result = ipopt.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("nonlinear solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(m.x(), m.y(), m.z()))
print("objective: {0: .5f}".\
format(m.o()))
print("")
def test_iis_no_variable_values(self):
with pyomo.opt.ReaderFactory("sol") as reader:
if reader is None:
raise IOError("Reader 'sol' is not registered")
result = reader(currdir+"iis_no_variable_values.sol", suffixes=["iis"])
soln = result.solution(0)
self.assertEqual(len(list(soln.variable['v0'].keys())), 1)
self.assertEqual(soln.variable['v0']['iis'], 1)
self.assertEqual(len(list(soln.variable['v1'].keys())), 1)
self.assertEqual(soln.variable['v1']['iis'], 1)
self.assertEqual(len(list(soln.constraint['c0'].keys())), 1)
self.assertEqual(soln.constraint['c0']['Iis'], 4)
import pyomo.kernel as pmo
m = pmo.block()
m.v0 = pmo.variable()
m.v1 = pmo.variable()
m.c0 = pmo.constraint()
m.iis = pmo.suffix(direction=pmo.suffix.IMPORT)
from pyomo.core.expr.symbol_map import SymbolMap
soln.symbol_map = SymbolMap()
soln.symbol_map.addSymbol(m.v0, 'v0')
soln.symbol_map.addSymbol(m.v1, 'v1')
soln.symbol_map.addSymbol(m.c0, 'c0')
m.load_solution(soln)
pmo.pprint(m.iis)
self.assertEqual(m.iis[m.v0], 1)
self.assertEqual(m.iis[m.v1], 1)
self.assertEqual(m.iis[m.c0], 4)
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 _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a1 = pmo.parameter(value=1.0)
model.a2 = pmo.parameter_dict({1: pmo.parameter(value=1.0)})
model.a3 = pmo.parameter(value=1.0)
model.a4 = pmo.parameter_dict({1: pmo.parameter(value=1.0)})
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.z1 = pmo.variable()
model.z2 = pmo.variable()
model.dummy_expr1 = pmo.expression(model.a1 * model.a2[1])
model.dummy_expr2 = pmo.expression(model.y / model.a3 * model.a4[1])
model.inactive_obj = pmo.objective(model.x + 3.0 * model.y + 1.0 +
model.z1 - model.z2)
model.inactive_obj.deactivate()
model.p = pmo.parameter(value=0.0)
model.obj = pmo.objective(model.p + model.inactive_obj)
model.c1 = pmo.constraint(
model.dummy_expr1 <= pmo.noclone(model.dummy_expr2))
model.c2 = pmo.constraint((2.0, model.x / model.a3 - model.y, 10))
model.c3 = pmo.constraint((0, model.z1 + 1, 10))
model.c4 = pmo.constraint((-10, model.z2 + 1, 0))
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 __init__(self, xL, xU, yL, yU):
assert xL <= xU
assert yL <= yU
self._model = pmo.block()
x = self._model.x = pmo.variable(lb=xL, ub=xU)
y = self._model.y = pmo.variable(lb=yL, ub=yU)
x2 = self._model.x2 = pmo.variable(lb=-pybnb.inf, ub=pybnb.inf)
x2y = self._model.x2y = pmo.variable(lb=-pybnb.inf, ub=pybnb.inf)
self._model.x2_c = SquaredEnvelope(x, x2)
# Temporarily provide bounds to the x2 variable so
# they can be used to build the McCormick
# constraints for x2y. After that, they are no
# longer needed as they are enforced by the
# McCormickEnvelope constraints.
x2.bounds = self._model.x2_c.derived_output_bounds()
self._model.x2y_c = McCormickEnvelope(x2, y, x2y)
x2.bounds = (-pybnb.inf, pybnb.inf)
# original objective
self._model.f = pmo.expression(
(x**4 - 2 * (x**2) * y + 0.5 * (x**2) - x + (y**2) + 0.5))
# convex relaxation
self._model.f_convex = pmo.expression(
(x**4 - 2 * x2y + 0.5 * (x**2) - x + (y**2) + 0.5))
self._model.objective = pmo.objective(sense=pmo.minimize)
self._ipopt = pmo.SolverFactory("ipopt")
self._ipopt.options["tol"] = 1e-9
self._last_bound_was_feasible = False
# make sure the PyomoProblem initializer is called
# after the model is built
super(Rosenbrock2D, self).__init__()
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 _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a1 = pmo.parameter(value=1.0)
model.a2 = pmo.parameter_dict(
{1: pmo.parameter(value=1.0)})
model.a3 = pmo.parameter(value=1.0)
model.a4 = pmo.parameter_dict(
{1: pmo.parameter(value=1.0)})
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.z1 = pmo.variable()
model.z2 = pmo.variable()
model.dummy_expr1 = pmo.expression(model.a1*model.a2[1])
model.dummy_expr2 = pmo.expression(model.y/model.a3*model.a4[1])
model.inactive_obj = pmo.objective(
model.x + 3.0*model.y + 1.0 + model.z1 - model.z2)
model.inactive_obj.deactivate()
model.p = pmo.parameter(value=0.0)
model.obj = pmo.objective(model.p + model.inactive_obj)
model.c1 = pmo.constraint(model.dummy_expr1 <= pmo.noclone(model.dummy_expr2))
model.c2 = pmo.constraint((2.0, model.x/model.a3 - model.y, 10))
model.c3 = pmo.constraint((0, model.z1 + 1, 10))
model.c4 = pmo.constraint((-10, model.z2 + 1, 0))
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 solve_nonlinear():
m = pmo.block()
m.x = pmo.variable()
m.y = pmo.variable()
m.z = pmo.variable()
m.c = pmo.constraint_tuple([
pmo.constraint(body=0.1*pmo.sqrt(m.x) + (2.0/m.y),
ub=1),
pmo.constraint(body=(1.0/m.z) + (m.y/(m.x**2)),
ub=1)])
m.o = pmo.objective(m.x + (m.y**2)*m.z,
sense=pmo.minimize)
m.x.value, m.y.value, m.z.value = (1,1,1)
ipopt = pmo.SolverFactory("ipopt")
result = ipopt.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("nonlinear solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(m.x(), m.y(), m.z()))
print("objective: {0: .5f}".\
format(m.o()))
print("")
def test_constraint_removal_2(self):
m = pmo.block()
m.x = pmo.variable()
m.y = pmo.variable()
m.z = pmo.variable()
m.c1 = pmo.conic.rotated_quadratic.as_domain(2, m.x, [m.y])
m.c2 = pmo.conic.quadratic(m.x, [m.y, m.z])
m.c3 = pmo.constraint(m.z >= 0)
m.c4 = pmo.constraint(m.x + m.y >= 0)
opt = pmo.SolverFactory('mosek_persistent')
opt.set_instance(m)
self.assertEqual(opt._solver_model.getnumcon(), 5)
self.assertEqual(opt._solver_model.getnumcone(), 2)
opt.remove_block(m.c1)
self.assertEqual(opt._solver_model.getnumcon(), 2)
self.assertEqual(opt._solver_model.getnumcone(), 1)
opt.remove_constraints(m.c2, m.c3)
self.assertEqual(opt._solver_model.getnumcon(), 1)
self.assertEqual(opt._solver_model.getnumcone(), 0)
self.assertRaises(ValueError, opt.remove_constraint, m.c2)
opt.add_constraint(m.c2)
opt.add_block(m.c1)
self.assertEqual(opt._solver_model.getnumcone(), 2)
def solve_nonlinear(Aw, Af, alpha, beta, gamma, delta):
m = pmo.block()
m.h = pmo.variable(lb=0)
m.w = pmo.variable(lb=0)
m.d = pmo.variable(lb=0)
m.c = pmo.constraint_tuple([
pmo.constraint(body=2*(m.h*m.w + m.h*m.d), ub=Aw),
pmo.constraint(body=m.w*m.d,
ub=Af),
pmo.constraint(lb=alpha,
body=m.h/m.w,
ub=beta),
pmo.constraint(lb=gamma,
body=m.d/m.w,
ub=delta)])
m.o = pmo.objective(m.h * m.w * m.d,
sense=pmo.maximize)
m.h.value, m.w.value, m.d.value = (1,1,1)
ipopt = pmo.SolverFactory("ipopt")
result = ipopt.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("nonlinear solution:")
print("h: {0:.4f}, w: {1:.4f}, d: {2:.4f}".\
format(m.h(), m.w(), m.d()))
print("volume: {0: .5f}".\
format(m.o()))
print("")
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.f = pmo.variable()
model.x = pmo.variable(lb=1,ub=3)
model.fi = pmo.parameter_dict()
model.fi[1] = pmo.parameter(value=1.0)
model.fi[2] = pmo.parameter(value=2.0)
model.fi[3] = pmo.parameter(value=0.0)
model.xi = pmo.parameter_dict()
model.xi[1] = pmo.parameter(value=1.0)
model.xi[2] = pmo.parameter(value=2.0)
model.xi[3] = pmo.parameter(value=3.0)
model.p = pmo.variable(domain=NonNegativeReals)
model.n = pmo.variable(domain=NonNegativeReals)
model.lmbda = pmo.variable_dict(
(i, pmo.variable()) for i in range(1,4))
model.obj = pmo.objective(model.p+model.n)
model.c1 = pmo.constraint_dict()
model.c1[1] = pmo.constraint((0.0, model.lmbda[1], 1.0))
model.c1[2] = pmo.constraint((0.0, model.lmbda[2], 1.0))
model.c1[3] = pmo.constraint(0.0 <= model.lmbda[3])
model.c2 = pmo.sos2(model.lmbda.values())
model.c3 = pmo.constraint(sum(model.lmbda.values()) == 1)
model.c4 = pmo.constraint(model.f==sum(model.fi[i]*model.lmbda[i]
for i in model.lmbda))
model.c5 = pmo.constraint(model.x==sum(model.xi[i]*model.lmbda[i]
for i in model.lmbda))
model.x.fix(2.75)
# Make an empty SOS constraint
model.c6 = pmo.sos2([])
def solve_conic():
m = pmo.block()
m.t = pmo.variable()
m.u = pmo.variable()
m.v = pmo.variable()
m.w = pmo.variable()
m.k = pmo.block_tuple([
# exp(u-t) + exp(2v + w - t) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.u - m.t),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=2*m.v + m.w - m.t),
# exp(0.5u + log(0.1)) + exp(-v + log(2)) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=0.5*m.u + pmo.log(0.1)),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=-m.v + pmo.log(2)),
# exp(-w) + exp(v-2u) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=-m.w),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.v - 2*m.u)])
m.c = pmo.constraint_tuple([
pmo.constraint(body=m.k[0].r + m.k[1].r,
ub=1),
pmo.constraint(body=m.k[2].r + m.k[3].r,
ub=1),
pmo.constraint(body=m.k[4].r + m.k[5].r,
ub=1)])
m.o = pmo.objective(m.t,
sense=pmo.minimize)
mosek = pmo.SolverFactory("mosek")
result = mosek.solve(m)
assert str(result.solver.termination_condition) == "optimal"
x, y, z = pmo.exp(m.u()), pmo.exp(m.v()), pmo.exp(m.w())
print("conic solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(x, y, z))
print("objective: {0: .5f}".\
format(x + (y**2)*z))
print("")
def _get_small_block():
b = block()
b.x1 = variable(domain_type=None, lb=None, ub=None)
b.x2 = variable(domain_type=None, lb=None, ub=None)
b.x3 = variable(domain_type=None, lb=None, ub=None)
b.x4 = variable(domain_type=None, lb=None, ub=None)
b.x5 = variable(domain_type=None, lb=None, ub=None)
return b
def _get_small_block():
b = block()
b.x1 = variable(domain_type=None, lb=None, ub=None)
b.x2 = variable(domain_type=None, lb=None, ub=None)
b.x3 = variable(domain_type=None, lb=None, ub=None)
b.x4 = variable(domain_type=None, lb=None, ub=None)
b.x5 = variable(domain_type=None, lb=None, ub=None)
return b
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=pmo.Integers)
model.y = pmo.variable(domain=pmo.Integers)
model.o = pmo.objective(model.x+model.y)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(lb=1)
model.y = pmo.variable(lb=1)
model.o = pmo.objective(model.x + model.y)
model.c = pmo.constraint(model.x + model.y <= 0)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(lb=1)
model.y = pmo.variable(lb=1)
model.o = pmo.objective(model.x+model.y)
model.c = pmo.constraint(model.x+model.y <= 0)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=pmo.IntegerSet)
model.y = pmo.variable(domain=pmo.IntegerSet)
model.o = pmo.objective(model.x+model.y)
def solve_conic():
m = pmo.block()
m.t = pmo.variable()
m.u = pmo.variable()
m.v = pmo.variable()
m.w = pmo.variable()
m.k = pmo.block_tuple([
# exp(u-t) + exp(2v + w - t) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.u - m.t),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=2*m.v + m.w - m.t),
# exp(0.5u + log(0.1)) + exp(-v + log(2)) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=0.5*m.u + pmo.log(0.1)),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=-m.v + pmo.log(2)),
# exp(-w) + exp(v-2u) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=-m.w),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.v - 2*m.u)])
m.c = pmo.constraint_tuple([
pmo.constraint(body=m.k[0].r + m.k[1].r, ub=1),
pmo.constraint(body=m.k[2].r + m.k[3].r, ub=1),
pmo.constraint(body=m.k[4].r + m.k[5].r, ub=1)
])
m.o = pmo.objective(m.t, sense=pmo.minimize)
mosek = pmo.SolverFactory("mosek")
result = mosek.solve(m)
assert str(result.solver.termination_condition) == "optimal"
x, y, z = pmo.exp(m.u()), pmo.exp(m.v()), pmo.exp(m.w())
print("conic solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(x, y, z))
print("objective: {0: .5f}".\
format(x + (y**2)*z))
print("")
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 test_component_map_hack(self):
m = pmo.block()
m.v = pmo.variable()
m.c = pmo.constraint()
m.B = pmo.block_list()
m.B.append(pmo.block())
m.B[0].v = pmo.variable()
m.B[0].c = pmo.constraint()
m.b = pmo.block()
m.b.v = pmo.variable()
m.b.c = pmo.constraint()
self.assertTrue(type(m.component_map()) == dict)
def build_block_list_with_variables():
blist = block_list()
for i in range(N):
b = block()
b._activate_large_storage_mode()
b.x1 = variable(domain_type=None, lb=None, ub=None)
b.x2 = variable(domain_type=None, lb=None, ub=None)
b.x3 = variable(domain_type=None, lb=None, ub=None)
b.x4 = variable(domain_type=None, lb=None, ub=None)
b.x5 = variable(domain_type=None, lb=None, ub=None)
blist.append(b)
return blist
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=1.0)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=Binary)
model.obj = pmo.objective(model.x + 3.0*model.y)
model.c1 = pmo.constraint(model.a <= model.y)
model.c2 = pmo.constraint((2.0, model.x/model.a - model.y, 10))
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=1.0)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=Binary)
model.obj = pmo.objective(model.x**2 + 3.0*model.y**2)
model.c1 = pmo.constraint(model.a <= model.y)
model.c2 = pmo.constraint((2.0, model.x/model.a - model.y, 10))
def build_block_list_with_variables():
blist = block_list()
for i in range(N):
b = block()
b._activate_large_storage_mode()
b.x1 = variable(domain_type=None, lb=None, ub=None)
b.x2 = variable(domain_type=None, lb=None, ub=None)
b.x3 = variable(domain_type=None, lb=None, ub=None)
b.x4 = variable(domain_type=None, lb=None, ub=None)
b.x5 = variable(domain_type=None, lb=None, ub=None)
blist.append(b)
return blist
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=Binary)
model.y = pmo.variable(domain=Binary)
model.z = pmo.variable(domain=Binary)
model.obj = pmo.objective(model.x, sense=maximize)
model.c0 = pmo.constraint(model.x + model.y + model.z == 1)
model.qc0 = pmo.constraint(model.x**2 + model.y**2 <= model.z**2)
model.qc1 = pmo.constraint(model.x**2 <= model.y * model.z)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=Binary)
model.y = pmo.variable(domain=Binary)
model.z = pmo.variable(domain=Binary)
model.obj = pmo.objective(model.x,sense=maximize)
model.c0 = pmo.constraint(model.x+model.y+model.z == 1)
model.qc0 = pmo.constraint(model.x**2 + model.y**2 <= model.z**2)
model.qc1 = pmo.constraint(model.x**2 <= model.y*model.z)
def test_component_objects_hack(self):
m = pmo.block()
m.v = pmo.variable()
m.c = pmo.constraint()
m.B = pmo.block_list()
m.B.append(pmo.block())
m.B[0].v = pmo.variable()
m.B[0].c = pmo.constraint()
m.b = pmo.block()
m.b.v = pmo.variable()
m.b.c = pmo.constraint()
for obj1, obj2 in zip(m.components(),
m.component_objects()):
self.assertIs(obj1, obj2)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=Binary)
model.y = pmo.variable(domain=Binary)
model.z = pmo.variable(domain=Binary)
model.o = pmo.objective(-model.x - model.y - model.z)
model.c1 = pmo.constraint(model.x + model.y <= 1)
model.c2 = pmo.constraint(model.x + model.z <= 1)
model.c3 = pmo.constraint(model.y + model.z <= 1)
model.c4 = pmo.constraint(model.x + model.y + model.z >= 1.5)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=Binary)
model.y = pmo.variable(domain=Binary)
model.z = pmo.variable(domain=Binary)
model.o = pmo.objective(-model.x-model.y-model.z)
model.c1 = pmo.constraint(model.x+model.y <= 1)
model.c2 = pmo.constraint(model.x+model.z <= 1)
model.c3 = pmo.constraint(model.y+model.z <= 1)
model.c4 = pmo.constraint(model.x+model.y+model.z >= 1.5)
def __init__(
self,
interval_set,
params: dict,
):
super().__init__()
## Setup
self.id = params["name"]
self.objective_terms = {}
# Need to reference interval set in coupling method, either need to add it to class or pass it to function.
self.interval_set = interval_set
self.component_element_ids = params[
"component_element_names"] # resources or other collections
## Parameters
self.import_limit = aml.parameter(
params["import_limit"]) # assume positive
self.export_limit = aml.parameter(params["export_limit"])
## Expressions/Variables
# Should we define net_export as a variable and set equal later - allows to define upper and lower bounds here
# or should it be an expression here, and we reconstruct constraints later whenever we add elements - i.e. the coupling aspect of the problem
# It really depends on how the model is "constructed" - one option is to define everything as constructor functions that are called when the model is constructed, but order of construction matters here!
# If we define as a variable, then we decouple them.
self.net_export = aml.variable_dict()
for interval in interval_set:
self.net_export[interval] = aml.variable(lb=-self.import_limit,
ub=self.export_limit)
def _generate_base_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = list(range(1,13))
model.x = pmo.variable_dict(
((i, pmo.variable()) for i in model.s))
model.x[1].lb = -1
model.x[1].ub = 1
model.x[2].lb = -1
model.x[2].ub = 1
model.obj = pmo.objective(expr=sum(model.x[i]*((-1)**(i+1))
for i in model.s))
variable_order = [
model.x[3],
model.x[4],
model.x[5],
model.x[6],
model.x[7],
model.x[8],
model.x[9],
model.x[10],
model.x[11],
model.x[12]]
return variable_order
def _generate_model(self):
self.model = None
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=1.0)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.inactive_obj = pmo.objective(model.y)
model.inactive_obj.deactivate()
model.obj = pmo.objective(model.x**2 + 3.0 * model.inactive_obj**2 +
1.0)
model.c1 = pmo.constraint(model.a <= model.y)
model.c2 = pmo.constraint(2.0 <= model.x / model.a - model.y <= 10)
def _generate_model(self):
self.model = None
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = list(range(1,13))
model.x = pmo.variable_dict(
(i, pmo.variable()) for i in model.s)
model.x[1].lb = -1
model.x[1].ub = 1
model.x[2].lb = -1
model.x[2].ub = 1
model.obj = pmo.objective(sum(model.x[i]*((-1)**(i+1))
for i in model.s))
model.c = pmo.constraint_dict()
# to make the variable used in the constraint match the name
model.c[3] = pmo.constraint(model.x[3]>=-1.)
model.c[4] = pmo.constraint(model.x[4]<=1.)
model.c[5] = pmo.constraint(model.x[5]==-1.)
model.c[6] = pmo.constraint(model.x[6]==-1.)
model.c[7] = pmo.constraint(model.x[7]==1.)
model.c[8] = pmo.constraint(model.x[8]==1.)
model.c[9] = pmo.constraint((-1.,model.x[9],-1.))
model.c[10] = pmo.constraint((-1.,model.x[10],-1.))
model.c[11] = pmo.constraint((1.,model.x[11],1.))
model.c[12] = pmo.constraint((1.,model.x[12],1.))
model.c_inactive = pmo.constraint_dict()
# to make the variable used in the constraint match the name
model.c_inactive[3] = pmo.constraint(model.x[3]>=-2.)
model.c_inactive[4] = pmo.constraint(model.x[4]<=2.)
def __init__(self):
self._pyomo_model = pmo.block()
self._pyomo_model.x = pmo.variable()
self._pyomo_model.c = pmo.constraint()
self._pyomo_model.o = pmo.objective()
self._pyomo_model_objective = self._pyomo_model.o
super(Junk, self).__init__()
def _generate_base_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = list(range(1,13))
model.x = pmo.variable_dict(
((i, pmo.variable()) for i in model.s))
model.x[1].lb = -1
model.x[1].ub = 1
model.x[2].lb = -1
model.x[2].ub = 1
model.obj = pmo.objective(expr=sum(model.x[i]*((-1)**(i+1))
for i in model.s))
variable_order = [
model.x[3],
model.x[4],
model.x[5],
model.x[6],
model.x[7],
model.x[8],
model.x[9],
model.x[10],
model.x[11],
model.x[12]]
return variable_order
def build_unordered_variable_dict():
"""Build an unordered variable_dict with no references to external
objects so its size can be computed."""
return variable_dict(
((i, variable(domain_type=None, lb=None, ub=None, value=None))
for i in range(N)),
ordered=False)
def _generate_model(self):
self.model = None
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = list(range(1, 13))
model.x = pmo.variable_dict((i, pmo.variable()) for i in model.s)
model.x[1].lb = -1
model.x[1].ub = 1
model.x[2].lb = -1
model.x[2].ub = 1
model.obj = pmo.objective(
sum(model.x[i] * ((-1)**(i + 1)) for i in model.s))
model.c = pmo.constraint_dict()
# to make the variable used in the constraint match the name
model.c[3] = pmo.constraint(model.x[3] >= -1.)
model.c[4] = pmo.constraint(model.x[4] <= 1.)
model.c[5] = pmo.constraint(model.x[5] == -1.)
model.c[6] = pmo.constraint(model.x[6] == -1.)
model.c[7] = pmo.constraint(model.x[7] == 1.)
model.c[8] = pmo.constraint(model.x[8] == 1.)
model.c[9] = pmo.constraint((-1., model.x[9], -1.))
model.c[10] = pmo.constraint((-1., model.x[10], -1.))
model.c[11] = pmo.constraint((1., model.x[11], 1.))
model.c[12] = pmo.constraint((1., model.x[12], 1.))
model.c_inactive = pmo.constraint_dict()
# to make the variable used in the constraint match the name
model.c_inactive[3] = pmo.constraint(model.x[3] >= -2.)
model.c_inactive[4] = pmo.constraint(model.x[4] <= 2.)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.b = pmo.block()
model.B = pmo.block_dict((i, pmo.block())
for i in range(1,4))
model.a = pmo.parameter(value=1.0)
model.b.x = pmo.variable(lb=0)
model.B[1].x = pmo.variable(lb=0)
model.obj = pmo.objective(expr=model.b.x + 3.0*model.B[1].x)
model.obj.deactivate()
model.B[2].c = pmo.constraint(expr=-model.B[1].x <= -model.a)
model.B[2].obj = pmo.objective(expr=model.b.x + 3.0*model.B[1].x + 2)
model.B[3].c = pmo.constraint(expr=(2.0, model.b.x/model.a - model.B[1].x, 10))
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.b = pmo.block()
model.B = pmo.block_dict((i, pmo.block()) for i in range(1, 4))
model.a = pmo.parameter(value=1.0)
model.b.x = pmo.variable(lb=0)
model.B[1].x = pmo.variable(lb=0)
model.obj = pmo.objective(expr=model.b.x + 3.0 * model.B[1].x)
model.obj.deactivate()
model.B[2].c = pmo.constraint(expr=-model.B[1].x <= -model.a)
model.B[2].obj = pmo.objective(expr=model.b.x + 3.0 * model.B[1].x + 2)
model.B[3].c = pmo.constraint(
expr=2.0 <= model.b.x / model.a - model.B[1].x <= 10)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(model.x-model.x)
model.con = pmo.constraint(model.x == 1.0)
def __init__(self, V, W,
pyomo_solver="ipopt",
pyomo_solver_io="nl",
integer_tolerance=1e-4):
assert V > 0
assert integer_tolerance > 0
self.V = V
self.W = W
self._integer_tolerance = integer_tolerance
N = range(len(self.W))
m = self.model = pmo.block()
x = m.x = pmo.variable_dict()
y = m.y = pmo.variable_dict()
for i in N:
y[i] = pmo.variable(domain=pmo.Binary)
for j in N:
x[i,j] = pmo.variable(domain=pmo.Binary)
m.B = pmo.expression(sum(y.values()))
m.objective = pmo.objective(m.B, sense=pmo.minimize)
m.B_nontrivial = pmo.constraint(m.B >= 1)
m.capacity = pmo.constraint_dict()
for i in N:
m.capacity[i] = pmo.constraint(
sum(x[i,j]*self.W[j] for j in N) <= self.V*y[i])
m.assign_1 = pmo.constraint_dict()
for j in N:
m.assign_1[j] = pmo.constraint(
sum(x[i,j] for i in N) == 1)
# relax everything for the bound solves,
# since the objective uses a simple heuristic
self.true_domain_type = pmo.ComponentMap()
for xij in self.model.x.components():
self.true_domain_type[xij] = xij.domain_type
xij.domain_type = pmo.RealSet
for yi in self.model.y.components():
self.true_domain_type[yi] = yi.domain_type
yi.domain_type = pmo.RealSet
self.opt = pmo.SolverFactory(
pyomo_solver,
solver_io=pyomo_solver_io)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(model.x - model.x)
model.con = pmo.constraint(model.x == 1.0)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(0.0)
model.con = pmo.linear_constraint(terms=[(model.x,1.0)],
rhs=1.0)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=0.1)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable_dict()
model.y[1] = pmo.variable(domain=NonNegativeReals)
model.y[2] = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(model.x + model.y[1]+2*model.y[2])
model.c1 = pmo.constraint(model.a <= model.y[2])
model.c2 = pmo.constraint((2.0, model.x, 10.0))
model.c3 = pmo.sos1(model.y.values())
model.c4 = pmo.constraint(sum(model.y.values()) == 1)
# Make an empty SOS constraint
model.c5 = pmo.sos1([])
def solve_conic(Aw, Af, alpha, beta, gamma, delta):
m = pmo.block()
m.x = pmo.variable()
m.y = pmo.variable()
m.z = pmo.variable()
m.k = pmo.block_tuple([
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.x + m.y + pmo.log(2.0/Aw)),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.x + m.z + pmo.log(2.0/Aw))])
m.c = pmo.constraint_tuple([
pmo.constraint(body=m.k[0].r + m.k[1].r,
ub=1),
pmo.constraint(body=m.y + m.z, ub=pmo.log(Af)),
pmo.constraint(lb=pmo.log(alpha),
body=m.x - m.y,
ub=pmo.log(beta)),
pmo.constraint(lb=pmo.log(gamma),
body=m.z - m.y,
ub=pmo.log(delta))])
m.o = pmo.objective(m.x + m.y + m.z,
sense=pmo.maximize)
mosek = pmo.SolverFactory("mosek")
result = mosek.solve(m)
assert str(result.solver.termination_condition) == "optimal"
h, w, d = pmo.exp(m.x()), pmo.exp(m.y()), pmo.exp(m.z())
print("conic solution:")
print("h: {0:.4f}, w: {1:.4f}, d: {2:.4f}".\
format(h, w, d))
print("volume: {0: .5f}".\
format(h*w*d))
print("")
def test_type_hack(self):
for obj in [pmo.variable(),
pmo.constraint(),
pmo.objective(),
pmo.expression(),
pmo.parameter(),
pmo.suffix(),
pmo.sos([]),
pmo.block()]:
ctype = obj.ctype
self.assertIs(obj.__class__._ctype, ctype)
self.assertIs(obj.type(), ctype)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = [1,2]
model.x = pmo.variable()
model.y = pmo.variable()
model.z = pmo.variable(lb=0)
model.obj = pmo.objective_dict()
for i in model.s:
model.obj[i] = pmo.objective(
inactive_index_LP_obj_rule(model,i))
model.OBJ = pmo.objective(model.x+model.y)
model.obj[1].deactivate()
model.OBJ.deactivate()
model.c1 = pmo.constraint_dict()
model.c1[1] = pmo.constraint(model.x<=1)
model.c1[2] = pmo.constraint(model.x>=-1)
model.c1[3] = pmo.constraint(model.y<=1)
model.c1[4] = pmo.constraint(model.y>=-1)
model.c1[1].deactivate()
model.c1[4].deactivate()
model.c2 = pmo.constraint_dict()
for i in model.s:
model.c2[i] = pmo.constraint(
inactive_index_LP_c2_rule(model, i))
model.b = pmo.block()
model.b.c = pmo.constraint(model.z >= 2)
model.B = pmo.block_dict()
model.B[1] = pmo.block()
model.B[1].c = pmo.constraint(model.z >= 3)
model.B[2] = pmo.block()
model.B[2].c = pmo.constraint(model.z >= 1)
model.b.deactivate()
model.B[1].deactivate()
def _generate_model(self):
self.model = None
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=RealInterval(bounds=(float('-inf'), None)))
model.y = pmo.variable(ub=float('inf'))
model.obj = pmo.objective(model.x - model.y)
model.c = pmo.constraint_dict()
model.c[1] = pmo.constraint(model.x >= -2)
model.c[2] = pmo.constraint(model.y <= 3)
cdata = model.c[3] = pmo.constraint((0, 1, 3))
assert cdata.lb == 0
assert cdata.ub == 3
assert cdata.body() == 1
assert not cdata.equality
cdata = model.c[4] = pmo.constraint((0, 2, 3))
assert cdata.lb == 0
assert cdata.ub == 3
assert cdata.body() == 2
assert not cdata.equality
cdata = model.c[5] = pmo.constraint((0, 1, None))
assert cdata.lb == 0
assert cdata.ub is None
assert cdata.body() == 1
assert not cdata.equality
cdata = model.c[6] = pmo.constraint((None, 0, 1))
assert cdata.lb is None
assert cdata.ub == 1
assert cdata.body() == 0
assert not cdata.equality
cdata = model.c[7] = pmo.constraint((1,1))
assert cdata.lb == 1
assert cdata.ub == 1
assert cdata.body() == 1
assert cdata.equality
def solve_nonlinear():
m = pmo.block()
m.x = pmo.variable(lb=0)
m.y = pmo.variable(lb=0)
m.z = pmo.variable(lb=0)
m.c = pmo.constraint(body=m.x + m.y + 0.5*m.z,
rhs=2)
m.o = pmo.objective((m.x**0.2)*(m.y**0.8) + (m.z**0.4) - m.x,
sense=pmo.maximize)
m.x.value, m.y.value, m.z.value = (1,1,1)
ipopt = pmo.SolverFactory("ipopt")
result = ipopt.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("nonlinear solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(m.x(), m.y(), m.z()))
print("objective: {0: .5f}".\
format(m.o()))
print("")
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.z = pmo.variable(domain=NonNegativeReals)
model.fixed_var = pmo.variable()
model.fixed_var.fix(0.2)
model.q1 = pmo.variable(ub=0.2)
model.q2 = pmo.variable(lb=-2)
model.obj = pmo.objective(model.x+model.q1-model.q2,sense=maximize)
model.c0 = pmo.constraint(model.x+model.y+model.z == 1)
model.qc0 = pmo.constraint(model.x**2 + model.y**2 + model.fixed_var <= model.z**2)
model.qc1 = pmo.constraint(model.x**2 <= model.y*model.z)
model.c = pmo.constraint_dict()
model.c[1] = pmo.constraint(lb=0, body=-model.q1**2 + model.fixed_var)
model.c[2] = pmo.constraint(body=model.q2**2 + model.fixed_var, ub=5)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.w2 = pmo.variable(domain=pmo.Binary)
model.x2 = pmo.variable(domain_type=pmo.IntegerSet,
lb=0, ub=1)
model.yb = pmo.variable(domain_type=pmo.IntegerSet,
lb=1, ub=1)
model.zb = pmo.variable(domain_type=pmo.IntegerSet,
lb=0, ub=0)
model.yi = pmo.variable(domain=pmo.Integers, lb=-1)
model.zi = pmo.variable(domain=pmo.Integers, ub=1)
model.obj = pmo.objective(model.w2 - model.x2 +\
model.yb - model.zb +\
model.yi - model.zi)
model.c3 = pmo.constraint(model.w2 >= 0)
model.c4 = pmo.constraint(model.x2 <= 1)
def solve_conic():
m = pmo.block()
m.x = pmo.variable(lb=0)
m.y = pmo.variable(lb=0)
m.z = pmo.variable(lb=0)
m.p = pmo.variable()
m.q = pmo.variable()
m.r = pmo.variable(lb=0)
m.k = pmo.block_tuple([
pmo.conic.primal_power.as_domain(r1=m.x,
r2=m.y,
x=[None],
alpha=0.2),
pmo.conic.primal_power.as_domain(r1=m.z,
r2=1,
x=[None],
alpha=0.4)])
m.c = pmo.constraint(body=m.x + m.y + 0.5*m.z,
rhs=2)
m.o = pmo.objective(m.k[0].x[0] + m.k[1].x[0] - m.x,
sense=pmo.maximize)
mosek = pmo.SolverFactory("mosek")
result = mosek.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("conic solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(m.x(), m.y(), m.z()))
print("objective: {0: .5f}".\
format(m.o()))
print("")
import pyomo.kernel as pmo
#
# Specialized Conic Constraints
#
c = pmo.conic.quadratic(
r=pmo.variable(lb=0),
x=[pmo.variable(), pmo.variable()])
assert not c.has_lb()
assert c.has_ub() and (c.ub == 0)
assert c.check_convexity_conditions()
print(c.body)
c = pmo.conic.rotated_quadratic(
r1=pmo.variable(lb=0),
r2=pmo.variable(lb=0),
x=[pmo.variable(), pmo.variable()])
assert not c.has_lb()
assert c.has_ub() and (c.ub == 0)
assert c.check_convexity_conditions()
print(c.body)
c = pmo.conic.primal_exponential(
r=pmo.variable(lb=0),
x1=pmo.variable(lb=0),
x2=pmo.variable())
assert not c.has_lb()
assert c.has_ub() and (c.ub == 0)
assert c.check_convexity_conditions()
print(c.body)
