def Xtest_rangeset_domain(self): self.model = ConcreteModel() self.model.s = RangeSet(3) #Set(initialize=[1,2,3]) self.model.y = Var([1, 2], within=self.model.s) self.model.obj = Objective(expr=self.model.y[1] - self.model.y[2]) self.model.con1 = Constraint(expr=self.model.y[1] >= 1.1) self.model.con2 = Constraint(expr=self.model.y[2] <= 2.9) self.instance = self.model.create_instance() self.opt = SolverFactory("glpk") self.results = self.opt.solve(self.instance) self.instance.load(self.results) self.assertEqual(self.instance.y[1], 2) self.assertEqual(self.instance.y[2], 2)
def test_rule5(self): """Test rule option""" model = ConcreteModel() model.B = RangeSet(1, 4) def f(model): ans = 0 for i in model.B: ans = ans + model.x[i] return (ans, 1) model.x = Var(model.B, initialize=2) model.c = Constraint(rule=f) self.assertEqual(model.c(), 8) self.assertEqual(value(model.c.body), 8)
def test_determine_valid_values(self): m = ConcreteModel() m.x = Var() m.y = Var(RangeSet(4), domain=Binary) m.z = Var(domain=Integers, bounds=(-1, 2)) m.constr = Constraint(expr=m.x == m.y[1] + 2 * m.y[2] + m.y[3] + 2 * m.y[4] + m.z) m.logical = ConstraintList() m.logical.add(expr=m.y[1] + m.y[2] == 1) m.logical.add(expr=m.y[3] + m.y[4] == 1) m.logical.add(expr=m.y[2] + m.y[4] <= 1) var_to_values_map = determine_valid_values( m, detect_effectively_discrete_vars(m, 1E-6), Bunch(equality_tolerance=1E-6, pruning_solver='glpk')) valid_values = set([1, 2, 3, 4, 5]) self.assertEqual(set(var_to_values_map[m.x]), valid_values)
def test_len(self): """Test len method""" model = self.create_model() model.obj = Objective(model.A,model.A) self.assertEqual(len(model.obj),0) model = self.create_model() """Test rule option""" def f(model): ans=0 for i in model.x.keys(): ans = ans + model.x[i] return ans model.x = Var(RangeSet(1,4),initialize=2) model.obj = Objective(rule=f) self.assertEqual(len(model.obj),1)
def test_rule_option1(self): model = self.create_model() model.B = RangeSet(1,4) def f(model, i): ans=0 for j in model.B: ans = ans + model.x[j] ans *= i ans = ans <= 0 ans = ans >= 0 return ans model.x = Var(model.B, initialize=2) model.c = Constraint(model.A,rule=f) self.assertEqual(model.c[1](), 8) self.assertEqual(model.c[2](), 16) self.assertEqual(len(model.c), 4)
def setUp(self): m = ConcreteModel() m.mycomp = Var() m.MyComp = Var() m.that = Var() self.long1 = m.myverylongcomponentname = Var() self.long2 = m.myverylongcomponentnamerighthere = Var() self.long3 = m.anotherlongonebutdifferent = Var() self.long4 = m.anotherlongonebutdifferentlongcomponentname = Var() self.long5 = m.longcomponentname_1_ = Var() m.s = RangeSet(10) m.ind = Var(m.s) m.myblock = Block() m.myblock.mystreet = Constraint() m.add_component("myblock.mystreet", Var()) self.thecopy = m.__getattribute__("myblock.mystreet") self.m = m
def test_assert_units_consistent_all_components(self): # test all scalar components consistent u = units m = self._create_model_and_vars() m.obj = Objective(expr=m.dx / m.t - m.vx) m.con = Constraint(expr=m.dx / m.t == m.vx) # vars already added m.exp = Expression(expr=m.dx / m.t - m.vx) m.suff = Suffix(direction=Suffix.LOCAL) # params already added # sets already added m.rs = RangeSet(5) m.disj1 = Disjunct() m.disj1.constraint = Constraint(expr=m.dx / m.t <= m.vx) m.disj2 = Disjunct() m.disj2.constraint = Constraint(expr=m.dx / m.t <= m.vx) m.disjn = Disjunction(expr=[m.disj1, m.disj2]) # block tested as part of model m.extfn = ExternalFunction(python_callback_function, units=u.m / u.s, arg_units=[u.m, u.s]) m.conext = Constraint(expr=m.extfn(m.dx, m.t) - m.vx == 0) m.cset = ContinuousSet(bounds=(0, 1)) m.svar = Var(m.cset, units=u.m) m.dvar = DerivativeVar(sVar=m.svar, units=u.m / u.s) def prt1_rule(m): return {'avar': m.dx} def prt2_rule(m): return {'avar': m.dy} m.prt1 = Port(rule=prt1_rule) m.prt2 = Port(rule=prt2_rule) def arcrule(m): return dict(source=m.prt1, destination=m.prt2) m.arc = Arc(rule=arcrule) # complementarities do not work yet # The expression system removes the u.m since it is multiplied by zero. # We need to change the units_container to allow 0 when comparing units # m.compl = Complementarity(expr=complements(m.dx/m.t >= m.vx, m.dx == 0*u.m)) assert_units_consistent(m)
def test_simple_rule(self): m = ConcreteModel() m.I = RangeSet(3) m.x = Var(m.I) @m.Constraint(m.I) def c(m, i): return m.x[i] <= 0 template, indices = templatize_constraint(m.c) self.assertEqual(len(indices), 1) self.assertIs(indices[0]._set, m.I) self.assertEqual(str(template), "x[_1] <= 0.0") # Test that the RangeSet iterator was put back self.assertEqual(list(m.I), list(range(1,4))) # Evaluate the template indices[0].set_value(2) self.assertEqual(str(resolve_template(template)), 'x[2] <= 0.0')
def test_rule_option2(self): """Test rule option""" model = self.create_model() model.B = RangeSet(1,4) def f(model, i): if i == 1: return Objective.Skip ans=0 for j in model.B: ans = ans + model.x[j] ans *= i return ans model.x = Var(model.B, initialize=2) model.obj = Objective(model.A,rule=f) self.assertEqual(model.obj[2](), 16) self.assertEqual(value(model.obj[2]), 16)
def test_len(self): model = self.create_model() model.c = Constraint(model.A) self.assertEqual(len(model.c),0) model = self.create_model() model.B = RangeSet(1,4) """Test rule option""" def f(model): ans=0 for i in model.B: ans = ans + model.x[i] ans = ans==2 return ans model.x = Var(model.B, initialize=2) model.c = Constraint(rule=f) self.assertEqual(len(model.c),1)
def test_fix_discrete(self): # Coverage of the _clear_attribute method self.model.A = RangeSet(1,4) self.model.a = Var() self.model.b = Var(within=self.model.A) self.model.c = Var(within=NonNegativeIntegers) self.model.d = Var(within=Integers, bounds=(-2,3)) self.model.e = Var(within=Boolean) self.model.f = Var(domain=Boolean) instance=self.model.create_instance() xfrm = TransformationFactory('core.fix_discrete') rinst = xfrm.create_using(instance) self.assertFalse(rinst.a.is_fixed()) self.assertTrue(rinst.b.is_fixed()) self.assertTrue(rinst.c.is_fixed()) self.assertTrue(rinst.d.is_fixed()) self.assertTrue(rinst.e.is_fixed()) self.assertTrue(rinst.f.is_fixed())
def test_init_param_from_ndarray(self): # Test issue #2033 m = ConcreteModel() m.ix_set = RangeSet(2) p_init = np.array([0, 5]) def init_workaround(model, i): return p_init[i - 1] m.p = Param(m.ix_set, initialize=init_workaround) m.v = Var(m.ix_set) expr = m.p[1] > m.v[1] self.assertIsInstance(expr, InequalityExpression) self.assertEqual(str(expr), "v[1] < 0") expr = m.p[2] > m.v[2] self.assertIsInstance(expr, InequalityExpression) self.assertEqual(str(expr), "v[2] < 5")
def _make_stripping_arcs(self): self._stripping_stream_index = RangeSet( self.config.feed_tray_location + 1, self.config.number_of_trays - 1) def rule_liq_stream(self, i): return {"source": self.stripping_section[i].liq_out, "destination": self.stripping_section[i + 1].liq_in} def rule_vap_stream(self, i): return {"source": self.stripping_section[i + 1].vap_out, "destination": self.stripping_section[i].vap_in} self.stripping_liq_stream = Arc( self._stripping_stream_index, rule=rule_liq_stream) self.stripping_vap_stream = Arc( self._stripping_stream_index, rule=rule_vap_stream)
def test_rule_option2(self): """Test rule option""" model = self.create_model() model.B = RangeSet(1,4) def f(model, i): if i > 2: return ObjectiveList.End i = 2*i - 1 ans=0 for j in model.B: ans = ans + model.x[j] ans *= i return ans model.x = Var(model.B, initialize=2) model.o = ObjectiveList(rule=f) self.assertEqual(model.o[1](), 8) self.assertEqual(len(model.o), 2)
def test_identify_mutable_parameters(self): m = ConcreteModel() m.I = RangeSet(3) m.a = Var(initialize=1) m.b = Var(m.I, initialize=1) # # There are no variables in expressions with only vars # self.assertEqual(list(identify_mutable_parameters(m.a)), []) self.assertEqual(list(identify_mutable_parameters(m.b[1])), []) self.assertEqual(list(identify_mutable_parameters(m.a + m.b[1])), []) self.assertEqual(list(identify_mutable_parameters(m.a**m.b[1])), []) self.assertEqual( list(identify_mutable_parameters(m.a**m.b[1] + m.b[2])), []) self.assertEqual( list( identify_mutable_parameters(m.a**m.b[1] + m.b[2] * m.b[3] * m.b[2])), [])
def test_lookup_and_iter_sparse_data(self): m = ConcreteModel() m.I = RangeSet(3) m.x = Var(m.I, m.I, dense=False) rd = _ReferenceDict(m.x[...]) rs = _ReferenceSet(m.x[...]) self.assertEqual(len(rd), 0) # Note: we will periodically re-check the dict to ensure # iteration doesn't accidentally declare data self.assertEqual(len(rd), 0) self.assertEqual(len(rs), 9) self.assertEqual(len(rd), 0) self.assertIn((1, 1), rs) self.assertEqual(len(rd), 0) self.assertEqual(len(rs), 9)
def test_fixed_var_propagate(self): """Test for transitivity in a variable equality set.""" m = ConcreteModel() m.v1 = Var(initialize=1) m.v2 = Var(initialize=2) m.v3 = Var(initialize=3) m.v4 = Var(initialize=4) m.c1 = Constraint(expr=m.v1 == m.v2) m.c2 = Constraint(expr=m.v2 == m.v3) m.c3 = Constraint(expr=m.v3 == m.v4) m.v2.fix() m.s = RangeSet(4) m.x = Var(m.s, initialize=5) m.c = Constraint(m.s) m.c.add(1, expr=m.x[1] == m.x[3]) m.c.add(2, expr=m.x[2] == m.x[4]) m.c.add(3, expr=m.x[2] == m.x[3]) m.c.add(4, expr=m.x[1] == 1) m.y = Var([1, 2], initialize=3) m.c_too = Constraint(expr=m.y[1] == m.y[2]) m.z1 = Var() m.z2 = Var() m.ignore_me = Constraint(expr=m.y[1] + m.z1 + m.z2 <= 0) TransformationFactory('contrib.propagate_fixed_vars').apply_to(m) self.assertTrue(m.v1.fixed) self.assertTrue(m.v2.fixed) self.assertTrue(m.v3.fixed) self.assertTrue(m.v4.fixed) self.assertEquals(value(m.v4), 2) self.assertTrue(m.x[1].fixed) self.assertTrue(m.x[2].fixed) self.assertTrue(m.x[3].fixed) self.assertTrue(m.x[4].fixed) self.assertEquals(value(m.x[4]), 1) self.assertFalse(m.y[1].fixed) self.assertFalse(m.y[2].fixed) self.assertFalse(m.z1.fixed) self.assertFalse(m.z2.fixed)
def Village_economy_model(vmodel): from pyomo.environ import Param, RangeSet, NonNegativeReals, Var, Set, Objective, maximize # Time parameters vmodel.Years = Param() # Number of years of the project #supporting sets lists and tuples tupsec = ("Trad", "Modern") tupvec = ("El", "Modern_NEl","Trad_NEl") # SETS vmodel.years = RangeSet(1, vmodel.Years) vmodel.sectors = Set(dimen=1, initialize = tupsec ) vmodel.envector = Set(dimen=1, initialize = tupvec ) #PARAMETERS vmodel.delta = Param(vmodel.sectors) vmodel.endelta = Param() vmodel.engamma = Param(vmodel.sectors) vmodel.gamma = Param(vmodel.sectors) vmodel.disc_rate = Param() vmodel.enel = Param(vmodel.sectors,vmodel.envector) vmodel.speclab = Param(vmodel.envector) vmodel.speccap = Param(vmodel.envector) vmodel.specvar = Param(vmodel.envector) vmodel.workingpeople = Param() vmodel.workinghoursyr = Param() #VARIABLES vmodel.Labor=Var(vmodel.years,vmodel.sectors,Within=NonNegativeReals) vmodel.Capital=Var(vmodel.years,vmodel.sectors) vmodel.Investment=Var(vmodel.years,vmodel.sectors,Within=NonNegativeReals) vmodel.Output=Var(vmodel.years,vmodel.sectors,Within=NonNegativeReals) vmodel.Consumption=Var(vmodel.years,Within=NonNegativeReals) vmodel.Utility=Var() #ENERGY VARIABLES vmodel.Enlabor=Var(vmodel.years,vmodel.envector,Within=NonNegativeReals) vmodel.Encapital=Var(vmodel.years,vmodel.envector) vmodel.Eninvestment=Var(vmodel.years,vmodel.envector) vmodel.Varcost=Var(vmodel.years,vmodel.envector) vmodel.Energy=Var(vmodel.years,vmodel.envector,Within=NonNegativeReals) vmodel.Energyinput=Var(vmodel.years,vmodel.sectors,Within=NonNegativeReals)
def test_induced_linear_in_disjunct(self): m = ConcreteModel() m.x = Var([0], bounds=(-3, 8)) m.y = Var(RangeSet(2), domain=Binary) m.logical = ConstraintList() m.logical.add(expr=m.y[1] + m.y[2] == 1) m.v = Var([1]) m.v[1].setlb(-2) m.v[1].setub(7) m.bilinear_outside = Constraint(expr=m.x[0] * m.v[1] >= 2) m.disjctn = Disjunction( expr=[[m.x[0] * m.v[1] == 3, 2 * m.x[0] == m.y[1] + m.y[2]], [m.x[0] * m.v[1] == 4]]) TransformationFactory('contrib.induced_linearity').apply_to(m) self.assertEqual( m.disjctn.disjuncts[0].constraint[1].body.polynomial_degree(), 1) self.assertEqual(m.bilinear_outside.body.polynomial_degree(), 2) self.assertEqual( m.disjctn.disjuncts[1].constraint[1].body.polynomial_degree(), 2)
def test_rule_option1a(self): """Test rule option""" model = self.create_model() model.B = RangeSet(1,4) @simple_objectivelist_rule def f(model, i): if i > 4: return None ans=0 for j in model.B: ans = ans + model.x[j] ans *= i return ans model.x = Var(model.B, initialize=2) model.o = ObjectiveList(rule=f) self.assertEqual(model.o[1](), 8) self.assertEqual(model.o[2](), 16) self.assertEqual(len(model.o), 4)
def setup_mccormick_cuts(b, name, nsegs, *sets): print( 'Warning: setup_mccormick_cuts is now deprecated in favor of the util.mccormick.add_mccormick_relaxation function, which automatically performs setup.' ) cuts = b.mccormick_cuts = Set(initialize=['lb1', 'lb2', 'ub1', 'ub2']) sets_cuts = sets + (cuts, ) setattr(b, name, Constraint(*sets_cuts)) if nsegs > 1: # If we are doing piecewise McCormick, set up additional constraints and variables. b.seg_length = Param(*sets, mutable=True) segs = b.segs = RangeSet(nsegs) sets_segs = sets + (segs, ) b.seg_active = Var(*sets_segs, domain=Binary) b.delta_y = Var(*sets_segs, domain=NonNegativeReals) b.eq_seg_active_sum = Constraint(*sets) b.eq_y = Constraint(*sets) b.eq_dy_ub = Constraint(*sets) b.eq_x_lb = Constraint(*sets) b.eq_x_ub = Constraint(*sets)
def test_rule_option3a(self): model = self.create_model() model.B = RangeSet(1,4) @simple_constraint_rule def f(model, i): if i%2 == 0: return None ans=0 for j in model.B: ans = ans + model.x[j] ans *= i ans = ans <= 0 ans = ans >= 0 return ans model.x = Var(model.B, initialize=2) model.c = Constraint(model.A,rule=f) self.assertEqual(model.c[1](), 8) self.assertEqual(len(model.c), 2)
def test_rule_option2(self): model = self.create_model() model.B = RangeSet(1,4) def f(model, i): if i > 2: return ConstraintList.End i = 2*i - 1 ans=0 for j in model.B: ans = ans + model.x[j] ans *= i ans = ans <= 0 ans = ans >= 0 return ans model.x = Var(model.B, initialize=2) model.c = ConstraintList(rule=f) self.assertEqual(model.c[1](), 8) self.assertEqual(len(model.c), 2)
def test_identify_vars_vars(self): m = ConcreteModel() m.I = RangeSet(3) m.a = Var(initialize=1) m.b = Var(m.I, initialize=1) m.p = Param(initialize=1, mutable=True) m.x = ExternalFunction(library='foo.so', function='bar') # # Identify variables in various algebraic expressions # self.assertEqual( list(identify_variables(m.a)), [m.a] ) self.assertEqual( list(identify_variables(m.b[1])), [m.b[1]] ) self.assertEqual( list(identify_variables(m.a+m.b[1])), [ m.a, m.b[1] ] ) self.assertEqual( list(identify_variables(m.a**m.b[1])), [ m.a, m.b[1] ] ) self.assertEqual( list(identify_variables(m.a**m.b[1] + m.b[2])), [ m.a, m.b[1], m.b[2] ] ) self.assertEqual( list(identify_variables( m.a**m.b[1] + m.b[2]*m.b[3]*m.b[2])), [ m.a, m.b[1], m.b[2], m.b[3] ] ) self.assertEqual( list(identify_variables( m.a**m.b[1] + m.b[2]/m.b[3]*m.b[2])), [ m.a, m.b[1], m.b[2], m.b[3] ] ) # # Identify variables in the arguments to functions # self.assertEqual( list(identify_variables( m.x(m.a, 'string_param', 1, [])*m.b[1] )), [ m.a, m.b[1] ] ) self.assertEqual( list(identify_variables( m.x(m.p, 'string_param', 1, [])*m.b[1] )), [ m.b[1] ] ) self.assertEqual( list(identify_variables( tanh(m.a)*m.b[1] )), [ m.a, m.b[1] ] ) self.assertEqual( list(identify_variables( abs(m.a)*m.b[1] )), [ m.a, m.b[1] ] ) # # Check logic for allowing duplicates # self.assertEqual( list(identify_variables(m.a**m.a + m.a)), [ m.a ] )
def test_solve_with_store4(self): model = ConcreteModel() model.A = RangeSet(1, 4) model.b = Block() model.b.x = Var(model.A, bounds=(-1, 1)) model.b.obj = Objective(expr=sum_product(model.b.x)) model.c = Constraint(expr=model.b.x[1] >= 0) opt = SolverFactory('glpk') results = opt.solve(model, load_solutions=False) self.assertEqual(len(model.solutions), 0) self.assertEqual(len(results.solution), 1) model.solutions.load_from(results) self.assertEqual(len(model.solutions), 1) self.assertEqual(len(results.solution), 1) # model.solutions.store_to(results) results.write(filename=join(currdir, 'solve_with_store8.out'), format='json') self.assertMatchesYamlBaseline(join(currdir, "solve_with_store8.out"), join(currdir, "solve_with_store4.txt"))
def test_jacobian(self): m = ConcreteModel() m.I = RangeSet(4) m.x = Var(m.I) idxMap = {} jacs = [] for i in m.I: idxMap[i] = len(jacs) jacs.append(m.x[i]) expr = m.x[1]+m.x[2]*m.x[3]**2 ans = differentiate(expr, wrt_list=jacs) self.assertEqual(len(ans), len(m.I)) self.assertEqual(str(ans[0]), "1.0") self.assertEqual(str(ans[1]), "x[3]**2.0") self.assertEqual(str(ans[2]), "2.0*x[2]*x[3]") # 0 calculated by bypassing sympy self.assertEqual(str(ans[3]), "0.0")
def _make_rectification_arcs(self): self._rectification_stream_index = RangeSet( 1, self.config.feed_tray_location - 2) def rule_liq_stream(self, i): return { "source": self.rectification_section[i].liq_out, "destination": self.rectification_section[i + 1].liq_in } def rule_vap_stream(self, i): return { "source": self.rectification_section[i + 1].vap_out, "destination": self.rectification_section[i].vap_in } self.rectification_liq_stream = Arc(self._rectification_stream_index, rule=rule_liq_stream) self.rectification_vap_stream = Arc(self._rectification_stream_index, rule=rule_vap_stream)
def test_optimal_mip(self): self.model.Idx = RangeSet(2) self.model.X = Var(self.model.Idx, within=NonNegativeIntegers) self.model.Y = Var(self.model.Idx, within=Binary) self.model.C1 = Constraint(expr=self.model.X[1] == self.model.X[2] + 1) self.model.Obj = Objective(expr=self.model.Y[1] + self.model.Y[2] - self.model.X[1], sense=maximize) results = self.opt.solve(self.model) self.assertEqual(1.0, results.problem.lower_bound) self.assertEqual(1.0, results.problem.upper_bound) self.assertEqual(results.problem.number_of_binary_variables, 2) self.assertEqual(results.problem.number_of_integer_variables, 4) self.assertEqual(ProblemSense.maximize, results.problem.sense) self.assertEqual(TerminationCondition.optimal, results.solver.termination_condition) self.assertEqual( 'Model was solved to optimality (subject to tolerances), and an optimal solution is available.', results.solver.termination_message) self.assertEqual(SolverStatus.ok, results.solver.status)
def test_solve_with_pickle(self): model = ConcreteModel() model.A = RangeSet(1, 4) model.b = Block() model.b.x = Var(model.A, bounds=(-1, 1)) model.b.obj = Objective(expr=sum_product(model.b.x)) model.c = Constraint(expr=model.b.x[1] >= 0) opt = SolverFactory('glpk') self.assertEqual(len(model.solutions), 0) results = opt.solve(model, symbolic_solver_labels=True) self.assertEqual(len(model.solutions), 1) # self.assertEqual(model.solutions[0].gap, 0.0) #self.assertEqual(model.solutions[0].status, SolutionStatus.feasible) self.assertEqual(model.solutions[0].message, None) # buf = pickle.dumps(model) tmodel = pickle.loads(buf) self.assertEqual(len(tmodel.solutions), 1) self.assertEqual(tmodel.solutions[0].gap, 0.0) #self.assertEqual(tmodel.solutions[0].status, SolutionStatus.feasible) self.assertEqual(tmodel.solutions[0].message, None)
def test_solve4(self): model = ConcreteModel() model.A = RangeSet(1,4) model.x = Var(model.A, bounds=(-1,1)) def obj_rule(model): return sum_product(model.x) model.obj = Objective(rule=obj_rule) def c_rule(model): expr = 0 for i in model.A: expr += i*model.x[i] return expr == 0 model.c = Constraint(rule=c_rule) opt = SolverFactory('glpk') results = opt.solve(model, symbolic_solver_labels=True) model.solutions.store_to(results) results.write(filename=join(currdir,'solve4.out'), format='json') with open(join(currdir,"solve4.out"), 'r') as out, \ open(join(currdir,"solve1.txt"), 'r') as txt: self.assertStructuredAlmostEqual(json.load(txt), json.load(out), abstol=1e-4, allow_second_superset=True)