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 __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 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 testMethod(obj): if not testing_solvers[solver, writer]: obj.skipTest("Solver %s (interface=%s) is not available" % (solver, writer)) m = pyutilib.misc.import_file(os.path.join(thisDir, 'kernel_problems', problem), clear_cache=True) model = m.define_model(**kwds) opt = pmo.SolverFactory(solver, solver_io=writer) results = opt.solve(model) # non-recursive new_results = ((var.name, var.value) for var in model.components(ctype=pmo.variable.ctype, active=True, descend_into=False)) baseline_results = getattr(obj,problem+'_results') for name, value in new_results: if abs(baseline_results[name]-value) > 0.00001: raise IOError("Difference in baseline solution values and " "current solution values using:\n" + \ "Solver: "+solver+"\n" + \ "Writer: "+writer+"\n" + \ "Variable: "+name+"\n" + \ "Solution: "+str(value)+"\n" + \ "Baseline: "+str(baseline_results[name])+"\n")
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_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, solver: str = "cbc", solver_params: dict = None, ): self.optimizer = aml.SolverFactory(solver) if solver_params: for param, value in solver_params: self.optimizer.options[param] = value
def bounding_box(A, b, solver_name="gurobi"): """ Find upper and lower bounds for each variable. Parameters ---------- A : np.ndarray e.g. lhs of polytope for N-X secured network b : np.ndarray e.g. rhs of polytope for N-X secured network solver_name : str, default "gurobi" Solver Returns ------- np.ndarray lower bounds np.ndarray upper bounds """ dim = A.shape[1] model = pmo.block() variables = [] for i in range(dim): setattr(model, f"x{i}", pmo.variable()) variables.append(getattr(model, f"x{i}")) model.A = pmo.matrix_constraint(A, ub=b, x=variables, sparse=True) opt = pmo.SolverFactory(solver_name) lower_upper_bounds = [] for sense in [pmo.minimize, pmo.maximize]: bounds = [] for i in range(dim): model.objective = pmo.objective(getattr(model, f"x{i}"), sense=sense) result = opt.solve(model) assert str(result.solver.termination_condition) == "optimal" bounds.append(result["Problem"][0]["Lower bound"]) del model.objective bounds = np.array(bounds).reshape(len(bounds), 1) lower_upper_bounds.append(bounds) return tuple(lower_upper_bounds)
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 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 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_direct") 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_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 import mosek if mosek.Env().getversion() >= (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_direct") results = opt.solve(model) self.assertEqual(results.solution.status, SolutionStatus.optimal)
fvals = f(pw_xarray, pw_yarray, package=np) pw_f = pmo.piecewise_nd(tri, fvals, input=[m.x, m.y], output=m.z, bound='lb') m.approx.pw_f = pw_f gvals = g(pw_xarray, pw_yarray, package=np) pw_g = pmo.piecewise_nd(tri, gvals, input=[m.x, m.y], output=m.z, bound='eq') m.approx.pw_g = pw_g # # Solve the approximate model to generate a warmstart for # the real model # m.real.deactivate() m.approx.activate() glpk = pmo.SolverFactory("glpk") status = glpk.solve(m) assert str(status.solver.status) == "ok" assert str(status.solver.termination_condition) == "optimal" print("Approximate f value at MIP solution: %s" % (pw_f( (m.x.value, m.y.value)))) print("Approximate g value at MIP solution: %s" % (pw_g( (m.x.value, m.y.value)))) print("Real f value at MIP solution: %s" % (f(m.x.value, m.y.value))) print("Real g value at MIP solution: %s" % (g(m.x.value, m.y.value))) # # Solve the real nonlinear model using a local solver #
def get_solver(self, solverName): solver = pmo.SolverFactory(solverName) if solverName == "cbc": solver.options["threads"] = 4 solver.options["sec"] = 300 return solver
## 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() for _worker in model.set_workers: for _task in model.set_tasks: expr.append( pmo.expression(model.param_cost[(_worker, _task)] * model.var_x[(_worker, _task)])) model.obj = pmo.objective(sum(expr), sense=pmo.minimize) # Solve opt = pmo.SolverFactory('cplex') result = opt.solve(model) # Print the solution if result.solver.termination_condition == TerminationCondition.optimal or result.solver.status == SolverStatus.ok: print('Total cost = ', pmo.value(model.obj), '\n') for i in range(NUM_WORKERS): for j in range(NUM_TASKS): # Test if x[i,j] is 1 (with tolerance for floating point arithmetic). if model.var_x[(i, j)].value > 0.5: print('Worker %d assigned to task %d. Cost = %d' % (i, j, costs[i][j]))
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"