def test_substitution_issue905(self): x = Variable("x") y = Variable("y") m = Model(x, [x >= y], {"y": 1}) bm = Model(m.cost, Bounded(m)) sol = bm.solve(verbosity=0) self.assertAlmostEqual(sol["cost"], 1.0) bm = Model(m.cost, Bounded(m, lower=1e-10)) sol = bm.solve(verbosity=0) self.assertAlmostEqual(sol["cost"], 1.0) bm = Model(m.cost, Bounded(m, upper=1e10)) sol = bm.solve(verbosity=0) self.assertAlmostEqual(sol["cost"], 1.0)
def test_sp_bounded(self): x = Variable("x") y = Variable("y") with SignomialsEnabled(): m = Model(x, [x + y >= 1, y <= 0.1]) # solves cost = m.localsolve(verbosity=0, solver=self.solver)["cost"] self.assertAlmostEqual(cost, 0.9, self.ndig) with SignomialsEnabled(): m = Model(x, [x + y >= 1]) # dual infeasible with self.assertRaises(UnboundedGP): m.localsolve(verbosity=0, solver=self.solver) gp = m.sp(checkbounds=False).gp() self.assertRaises(DualInfeasible, gp.solve, solver=self.solver, verbosity=0) with SignomialsEnabled(): m = Model(x, Bounded([x + y >= 1], verbosity=0)) sol = m.localsolve(verbosity=0, solver=self.solver) boundedness = sol["boundedness"] # depends on solver, platform, whims of the numerical deities if "value near lower bound" in boundedness: # pragma: no cover self.assertIn(x.key, boundedness["value near lower bound"]) else: # pragma: no cover self.assertIn(y.key, boundedness["value near upper bound"])
def test_sp_bounded(self): x = Variable("x") y = Variable("y") with SignomialsEnabled(): m = Model(x, [x + y >= 1, y <= 0.1]) # solves cost = m.localsolve(verbosity=0, solver=self.solver)["cost"] self.assertAlmostEqual(cost, 0.9, self.ndig) with SignomialsEnabled(): m = Model(x, [x + y >= 1]) # dual infeasible with self.assertRaises(UnboundedGP): m.localsolve(verbosity=0, solver=self.solver) gp = m.sp(allow_missingbounds=True).gp(allow_missingbounds=True) self.assertRaises(DualInfeasible, gp.solve, solver=self.solver, verbosity=0) with SignomialsEnabled(): m = Model(x, Bounded([x + y >= 1], verbosity=0)) sol = m.localsolve(verbosity=0, solver=self.solver) boundedness = sol["boundedness"] if "value near lower bound" in boundedness: self.assertIn(x.key, boundedness["value near lower bound"]) if "value near upper bound" in boundedness: self.assertIn(y.key, boundedness["value near upper bound"])
def test_unbounded_debugging(self): "Test nearly-dual-feasible problems" x = Variable("x") y = Variable("y") m = Model(x * y, [x * y**1.01 >= 100]) with self.assertRaises((RuntimeWarning, ValueError)): m.solve(self.solver, verbosity=0) # test one-sided bound m = Model(x * y, Bounded(m, verbosity=0, lower=0.001)) sol = m.solve(self.solver, verbosity=0) bounds = sol["boundedness"] self.assertEqual(bounds["sensitive to lower bound"], [x.key]) # end test one-sided bound m = Model(x * y, Bounded(m, verbosity=0)) sol = m.solve(self.solver, verbosity=0) bounds = sol["boundedness"] if "sensitive to upper bound" in bounds: self.assertEqual(bounds["sensitive to upper bound"], [y.key]) if "sensitive to lower bound" in bounds: self.assertEqual(bounds["sensitive to lower bound"], [x.key])
def test_unbounded_debugging(self): "Test nearly-dual-feasible problems" x = Variable("x") y = Variable("y") m = Model(x * y, [x * y**1.01 >= 100]) with self.assertRaises((DualInfeasible, UnknownInfeasible)): m.solve(self.solver, verbosity=0) # test one-sided bound m = Model(x * y, Bounded(m, verbosity=0, lower=0.001)) sol = m.solve(self.solver, verbosity=0) bounds = sol["boundedness"] self.assertEqual(bounds["sensitive to lower bound"], set([x.key])) # end test one-sided bound m = Model(x * y, Bounded(m, verbosity=0)) sol = m.solve(self.solver, verbosity=0) bounds = sol["boundedness"] if "sensitive to upper bound" in bounds: self.assertIn(y.key, bounds["sensitive to upper bound"]) if "sensitive to lower bound" in bounds: self.assertIn(x.key, bounds["sensitive to lower bound"])
def test_unbounded_debugging(self): "Test nearly-dual-feasible problems" from gpkit.constraints.bounded import Bounded x = Variable("x") y = Variable("y") m = Model(x*y, [x*y**1.000001 >= 100]) with self.assertRaises((RuntimeWarning, ValueError)): m.solve(self.solver, verbosity=0) m = Model(x*y, Bounded(m, verbosity=0)) sol = m.solve(self.solver, verbosity=0) bounds = sol["boundedness"] self.assertEqual(bounds["sensitive to upper bound"], [y.key]) self.assertEqual(bounds["sensitive to lower bound"], [x.key])
def test_unbounded_debugging(self): "Test nearly-dual-feasible problems" x = Variable("x") y = Variable("y") m = Model(x * y, [x * y**1.01 >= 100]) with self.assertRaises((DualInfeasible, UnknownInfeasible)): m.solve(self.solver, verbosity=0) # test one-sided bound m = Model(x * y, Bounded(m, lower=0.001)) sol = m.solve(self.solver, verbosity=0) bounds = sol["boundedness"] self.assertEqual(bounds["sensitive to lower bound of 0.001"], set([x.key])) # end test one-sided bound m = Model(x * y, [x * y**1.01 >= 100]) m = Model(x * y, Bounded(m)) sol = m.solve(self.solver, verbosity=0) bounds = sol["boundedness"] # depends on solver, platform, whims of the numerical deities if "sensitive to upper bound of 1e+30" in bounds: # pragma: no cover self.assertIn(y.key, bounds["sensitive to upper bound of 1e+30"]) else: # pragma: no cover self.assertIn(x.key, bounds["sensitive to lower bound of 1e-30"])
def test_sp_bounded(self): x = Variable("x") y = Variable("y") with SignomialsEnabled(): m = Model(x, [x + y >= 1, y <= 0.1]) # solves cost = m.localsolve(verbosity=0)["cost"] self.assertAlmostEqual(cost, 0.9, self.ndig) with SignomialsEnabled(): m = Model(x, [x + y >= 1]) # dual infeasible with self.assertRaises((RuntimeWarning, ValueError)): m.localsolve(verbosity=0) with SignomialsEnabled(): m = Model(x, Bounded([x + y >= 1], verbosity=0)) sol = m.localsolve(verbosity=0) if "value near lower bound" in sol["boundedness"]: self.assertIn(x, sol["boundedness"]["value near lower bound"]) if "value near upper bound" in sol["boundedness"]: self.assertIn(y, sol["boundedness"]["value near upper bound"])
def optimize_aircraft(m, substitutions, fixedBPR=False, pRatOpt=True, x0 = None): """ Optimizes an aircraft of a given configuration :param m: aircraft model with objective and configuration :param fixedBPR: boolean specifying whether or not BPR is fixed (depends on config) :param pRatOpt: boolean specifying whether or not pressure ratio is optimized (depends on config) :return: solution of aircraft model """ if fixedBPR: substitutions.update({ '\\alpha_{max}': 6.97, #8.62, }) if pRatOpt: del substitutions['\pi_{f_D}'] del substitutions['\pi_{lc_D}'] del substitutions['\pi_{hc_D}'] m.substitutions.update(substitutions) m = Model(m.cost, Bounded(m), m.substitutions) sol = m.localsolve(verbosity=2, iteration_limit=200, reltol=0.01) return sol
def relaxed_constants(model, include_only=None, exclude=None): """ Method to precondition an SP so it solves with a relaxed constants algorithim ARGUMENTS --------- model: the model to solve with relaxed constants RETURNS ------- feas: the input model but with relaxed constants and a new objective """ if model.substitutions: constsrelaxed = ConstantsRelaxed(Bounded(model)) feas = Model(constsrelaxed.relaxvars.prod()**20 * model.cost, constsrelaxed) # NOTE: It hasn't yet been seen but might be possible that # the model.cost component above could cause infeasibility else: feas = Model(model.cost, model) return feas
"Demonstrate a trivial unbounded variable" from gpkit import Variable, Model from gpkit.constraints.bounded import Bounded x = Variable("x") constraints = [x >= 1] m = Model(1/x, constraints) # MOSEK returns DUAL_INFEAS_CER on .solve() m = Model(1/x, Bounded(constraints)) # by default, prints bounds warning during solve sol = m.solve(verbosity=0) print(sol.summary()) # but they can also be accessed from the solution: assert (sol["boundedness"]["value near upper bound of 1e+30"] == sol["boundedness"]["sensitive to upper bound of 1e+30"])