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 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 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.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 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 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 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 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 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 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 __init__(self, x, z): assert x.has_lb() and x.has_ub() self.x = x self.z = z super(SquaredEnvelope, self).__init__( (pmo.constraint(), pmo.constraint())) self[0].body = self.z - self.x**2 self[0].lb = 0 self.update_constraints()
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 __init__(self, x, y, z): assert x.has_lb() and x.has_ub() assert y.has_lb() and y.has_ub() self.x = x self.y = y self.z = z super(McCormickEnvelope, self).__init__( (pmo.constraint(), pmo.constraint(), pmo.constraint(), pmo.constraint())) self.update_constraints()
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 _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 _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.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 build_small_block_with_objects(): """Build an empty block.""" b = block() b.x = build_variable() b.c = constraint() b.o = objective() return b
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 __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 get_constraint(team): if max_vertices > 0: return pmo.constraint( expr=sum(self._model.y[n, team] for n in self._model.Nodes if n != 0) <= self._model.MaxVertexCount) else: return None
def get_constraint(team): if max_edge_cost > 0: return pmo.constraint(expr=sum( self._model.x[(u, v), team] * self._model.d[u, v] for u, v in self._model.Edges) <= self._model.MaxEdgeCost) else: return None
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 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("")
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 = 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 build_block_with_objects(): """Build an empty block.""" b = block() b._activate_large_storage_mode() b.x = build_variable() b.c = constraint() b.o = objective() return b
def build_unordered_constraint_dict(): """Build an unordered constraint_dict with no references to external objects so its size can be computed.""" return constraint_dict( ((i, 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)), ordered=False)
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 _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 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.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.w2 = pmo.variable(domain=pmo.BooleanSet) 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.IntegerSet, lb=-1) model.zi = pmo.variable(domain=pmo.IntegerSet, 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 _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.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.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 _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 _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 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("")
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 = 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 build_constraint(): """Build a constraint with no references to external objects so its size can be computed.""" expr = sum(x*c for x,c in zip(build_constraint.xlist, build_constraint.clist)) return constraint(lb=0, body=expr, ub=1)
# using data expressions d = pmo.expression_list( pmo.data_expression() for i in range(2)) s = pmo.sos([v1,v2], weights=d) assert len(s.weights) == 2 d[0].expr = p[0] + 1 d[1].expr = p[0] + p[1] assert tuple(pmo.value(w) for w in s.weights) == (2, 3) # # Example model (discontiguous variable domain) # domain = [-1.1, 4.49, 8.1, -30.2, 12.5] m = pmo.block() m.z = pmo.variable_list( pmo.variable(lb=0) for i in range(len(domain))) m.y = pmo.variable() m.o = pmo.objective(m.y, sense=pmo.maximize) m.c1 = pmo.constraint( m.y == sum(v*z for v,z in zip(m.z, domain))) m.c2 = pmo.constraint( sum(m.z) == 1) m.s = pmo.sos1(m.z)
import pyomo.kernel as pmo model = pmo.block() model.x = pmo.variable() model.c = pmo.constraint(model.x >= 1) model.o = pmo.objective(model.x) opt = pmo.SolverFactory("ipopt") result = opt.solve(model) assert str(result.solver.termination_condition) == "optimal"
def test_conic(self): model = pmo.block() model.o = pmo.objective(0.0) model.c = pmo.constraint(body=0.0, rhs=1) b = model.quadratic = pmo.block() b.x = pmo.variable_tuple((pmo.variable(), pmo.variable())) b.r = pmo.variable(lb=0) b.c = pmo.conic.quadratic(x=b.x, r=b.r) model.o.expr += b.r model.c.body += b.r del b b = model.rotated_quadratic = pmo.block() b.x = pmo.variable_tuple((pmo.variable(), pmo.variable())) b.r1 = pmo.variable(lb=0) b.r2 = pmo.variable(lb=0) b.c = pmo.conic.rotated_quadratic(x=b.x, r1=b.r1, r2=b.r2) model.o.expr += b.r1 + b.r2 model.c.body += b.r1 + b.r2 del b if mosek_version >= (9,0,0): b = model.primal_exponential = pmo.block() b.x1 = pmo.variable(lb=0) b.x2 = pmo.variable() b.r = pmo.variable(lb=0) b.c = pmo.conic.primal_exponential(x1=b.x1, x2=b.x2, r=b.r) model.o.expr += b.r model.c.body += b.r del b b = model.primal_power = pmo.block() b.x = pmo.variable_tuple((pmo.variable(), pmo.variable())) b.r1 = pmo.variable(lb=0) b.r2 = pmo.variable(lb=0) b.c = pmo.conic.primal_power(x=b.x, r1=b.r1, r2=b.r2, alpha=0.6) model.o.expr += b.r1 + b.r2 model.c.body += b.r1 + b.r2 del b b = model.dual_exponential = pmo.block() b.x1 = pmo.variable() b.x2 = pmo.variable(ub=0) b.r = pmo.variable(lb=0) b.c = pmo.conic.dual_exponential(x1=b.x1, x2=b.x2, r=b.r) model.o.expr += b.r model.c.body += b.r del b b = model.dual_power = pmo.block() b.x = pmo.variable_tuple((pmo.variable(), pmo.variable())) b.r1 = pmo.variable(lb=0) b.r2 = pmo.variable(lb=0) b.c = pmo.conic.dual_power(x=b.x, r1=b.r1, r2=b.r2, alpha=0.4) model.o.expr += b.r1 + b.r2 model.c.body += b.r1 + b.r2 opt = pmo.SolverFactory("mosek") results = opt.solve(model) self.assertEqual(results.solution.status, SolutionStatus.optimal)