def test_replacement_walker0(self): M = ConcreteModel() M.x = Var(range(3)) M.w = VarList() M.z = Param(range(3), mutable=True) e = sum_product(M.z, M.x) self.assertIs(type(e), LinearExpression) walker = ReplacementWalkerTest1(M) f = walker.dfs_postorder_stack(e) self.assertTrue(compare_expressions(LinearExpression(linear_coefs=[i for i in M.z.values()], linear_vars=[i for i in M.x.values()]), e)) self.assertTrue(compare_expressions(LinearExpression(linear_coefs=[i for i in M.z.values()], linear_vars=[i for i in M.w.values()]), f)) del M.w del M.w_index M.w = VarList() e = 2*sum_product(M.z, M.x) walker = ReplacementWalkerTest1(M) f = walker.dfs_postorder_stack(e) self.assertTrue(compare_expressions(2*LinearExpression(linear_coefs=[i for i in M.z.values()], linear_vars=[i for i in M.x.values()]), e)) self.assertTrue(compare_expressions(2*LinearExpression(linear_coefs=[i for i in M.z.values()], linear_vars=[i for i in M.w.values()]), f))
def test_fixed_attr(self): """Test fixed attribute""" self.model.x = VarList() self.model.y = VarList() self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.instance.x.add() self.instance.y.add() self.instance.y.add() self.instance.y.add() self.instance.x.fixed = True self.assertEqual(self.instance.x[1].fixed, False) self.instance.y[1].fixed = True self.assertEqual(self.instance.y[1].fixed, True)
def test_stats2(self): model = ConcreteModel() # model.x = Var([1, 2]) def obj_rule(model, i): return sum_product(model.x) model.y = VarList() model.y.add() model.y.add() # model.obj = Objective([1, 2], rule=obj_rule) model.o = ObjectiveList() model.o.add(model.y[1]) model.o.add(model.y[2]) # def c_rule(model, i): expr = 0 for j in [1, 2]: expr += j * model.x[j] return expr == 0 model.c = Constraint([1, 2], rule=c_rule) model.C = ConstraintList() model.C.add(model.y[1] == 0) model.C.add(model.y[2] == 0) # self.assertEqual(model.nvariables(), 4) self.assertEqual(model.nobjectives(), 4) self.assertEqual(model.nconstraints(), 4)
def test_domain2(self): def x_domain(model, i): if i == 1: return NonNegativeReals elif i == 2: return Reals elif i == 3: return Integers self.model.x = VarList(domain=x_domain) self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.instance.x.add() self.assertEqual(str(self.instance.x[1].domain), str(NonNegativeReals)) self.assertEqual(str(self.instance.x[2].domain), str(Reals)) self.assertEqual(str(self.instance.x[3].domain), str(Integers)) try: self.instance.x.domain except AttributeError: pass # test the property setter self.instance.x.domain = Binary self.assertEqual(str(self.instance.x[1].domain), str(Binary)) self.assertEqual(str(self.instance.x[2].domain), str(Binary)) self.assertEqual(str(self.instance.x[3].domain), str(Binary))
def test_keys(self): """Test keys method""" self.model.x = VarList() self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.assertEqual(set(self.instance.x.keys()), set([1, 2]))
def test_len(self): """Test len method""" self.model.x = VarList() self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.assertEqual(len(self.instance.x), 2)
def test_bounds_option2(self): """Test bounds option""" self.model.x = VarList(bounds=(-1.0, 1.0)) self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.assertEqual(value(self.instance.x[1].lb), -1.0) self.assertEqual(value(self.instance.x[1].ub), 1.0)
def test_domain1(self): self.model.x = VarList(domain=NonNegativeReals) self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.assertEqual(str(self.instance.x[1].domain), str(NonNegativeReals)) self.assertEqual(str(self.instance.x[2].domain), str(NonNegativeReals)) self.instance.x[1].domain = Integers self.assertEqual(str(self.instance.x[1].domain), str(Integers))
def test_value_attr(self): """Test value attribute""" self.model.x = VarList() self.model.y = VarList() self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.instance.x.add() self.instance.y.add() self.instance.y.add() self.instance.y.add() try: self.instance.x = 3.5 self.fail("Expected ValueError") except ValueError: pass self.instance.y[1] = 3.5 self.assertEqual(self.instance.y[1], 3.5)
def test_replacement_walker2(self): M = ConcreteModel() M.x = Param(mutable=True) M.w = VarList() e = M.x walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertTrue(compare_expressions(M.x, e)) self.assertTrue(compare_expressions(2*M.w[1], f))
def test_initialize_with_dict(self): """Test initialize option with a dictionary""" self.model.x = VarList(initialize={1: 1.3, 2: 2.3}) self.instance = self.model.create_instance() self.assertEqual(self.instance.x[1], 1.3) self.assertEqual(self.instance.x[2], 2.3) self.instance.x[1] = 1 self.instance.x[2] = 2 self.assertEqual(self.instance.x[1], 1) self.assertEqual(self.instance.x[2], 2)
def test_rule_option(self): """Test rule option""" def x_init(model, i): return 1.3 self.model.x = VarList(initialize=x_init) self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.assertEqual(self.instance.x[1].value, 1.3)
def test_replacement_walker2(self): M = ConcreteModel() M.x = Param(mutable=True) M.w = VarList() e = M.x walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertEqual("x", str(e)) self.assertEqual("2*w[1]", str(f))
def test_replacement_walker4(self): M = ConcreteModel() M.x = Param(mutable=True) M.y = Var() M.w = VarList() e = inequality(0, sin(M.x) + M.x * M.y + 3, 1) walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertEqual("0 <= sin(x) + x*y + 3 <= 1", str(e)) self.assertEqual("0 <= sin(2*w[1]) + 2*w[1]*y + 3 <= 1", str(f))
def test_replacement_walker3(self): M = ConcreteModel() M.x = Var() M.y = Var() M.w = VarList() e = sin(M.x) + M.x*M.y + 3 <= 0 walker = ReplacementWalkerTest2(M) f = walker.dfs_postorder_stack(e) self.assertTrue(compare_expressions(sin(M.x) + M.x*M.y + 3 <= 0, e)) self.assertTrue(compare_expressions(sin(2*M.w[1]) + 2*M.w[1]*(2*M.w[2]) + 3 <= 0, f))
def test_bounds_option1(self): """Test bounds option""" def x_bounds(model, i): return (-1.0, 1.0) self.model.x = VarList(bounds=x_bounds) self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.assertEqual(value(self.instance.x[1].lb), -1.0) self.assertEqual(value(self.instance.x[1].ub), 1.0)
def test_replacement_walker3(self): M = ConcreteModel() M.x = Var() M.y = Var() M.w = VarList() e = sin(M.x) + M.x * M.y + 3 <= 0 walker = ReplacementWalkerTest2(M) f = walker.dfs_postorder_stack(e) self.assertEqual("sin(x) + x*y + 3 <= 0.0", str(e)) self.assertEqual("sin(2*w[1]) + 2*w[1]*(2*w[2]) + 3 <= 0.0", str(f))
def test_replacement_walker4(self): M = ConcreteModel() M.x = Param(mutable=True) M.y = Var() M.w = VarList() e = inequality(0, sin(M.x) + M.x*M.y + 3, 1) walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertTrue(compare_expressions(inequality(0, sin(M.x) + M.x*M.y + 3, 1), e)) self.assertTrue(compare_expressions(inequality(0, sin(2*M.w[1]) + 2*M.w[1]*M.y + 3, 1), f))
def test_initialize_with_const(self): """Test initialize option with a constant""" self.model.x = VarList(initialize=3) self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.instance.x.add() self.assertEqual(self.instance.x[1], 3) self.assertEqual(self.instance.x[2], 3) self.instance.x[1] = 1 self.instance.x[2] = 2 self.assertEqual(self.instance.x[1], 1) self.assertEqual(self.instance.x[2], 2)
def test_replacement_walker6(self): M = ConcreteModel() M.x = Var() M.w = VarList() M.z = Param(mutable=True) e = (M.z * 2) * 3 walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertTrue(not e.is_potentially_variable()) self.assertTrue(f.is_potentially_variable()) self.assertEqual("z*2*3", str(e)) self.assertEqual("2*w[1]*2*3", str(f))
def test_replacement_walker5(self): M = ConcreteModel() M.x = Var() M.w = VarList() M.z = Param(mutable=True) e = M.z * M.x walker = ReplacementWalkerTest2(M) f = walker.dfs_postorder_stack(e) self.assertTrue(e.__class__ is MonomialTermExpression) self.assertTrue(f.__class__ is ProductExpression) self.assertEqual("z*x", str(e)) self.assertEqual("z*(2*w[1])", str(f))
def test_without_initial_value(self): """Test default initialization method""" self.model.x = VarList() self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.instance.x.add() self.assertEqual(self.instance.x[1].value, None) self.assertEqual(self.instance.x[2].value, None) self.instance.x[1] = 5 self.instance.x[2] = 6 self.assertEqual(self.instance.x[1].value, 5) self.assertEqual(self.instance.x[2].value, 6)
def test_replacement_walker6(self): M = ConcreteModel() M.x = Var() M.w = VarList() M.z = Param(mutable=True) e = (M.z*2)*3 walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertTrue(not e.is_potentially_variable()) self.assertTrue(f.is_potentially_variable()) self.assertTrue(compare_expressions(M.z*2*3, e)) self.assertTrue(compare_expressions(ProductExpression([ProductExpression([2*M.w[1], 2]), 3]), f))
def test_replacement_walker5(self): M = ConcreteModel() M.x = Var() M.w = VarList() M.z = Param(mutable=True) e = M.z*M.x walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertIs(e.__class__, MonomialTermExpression) self.assertIs(f.__class__, ProductExpression) self.assertTrue(f.arg(0).is_potentially_variable()) self.assertTrue(compare_expressions(M.z*M.x, e)) self.assertTrue(compare_expressions(2*M.w[1]*M.x, f))
def test_value(self): """Check the value of the variable""" self.model.x = VarList(initialize=3.3) self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() tmp = value(self.instance.x[1].value) self.assertEqual(type(tmp), float) self.assertEqual(tmp, 3.3) tmp = float(self.instance.x[1].value) self.assertEqual(type(tmp), float) self.assertEqual(tmp, 3.3) tmp = int(self.instance.x[1].value) self.assertEqual(type(tmp), int) self.assertEqual(tmp, 3)
def test_initialize_with_function(self): """Test initialize option with an initialization rule""" def init_rule(model, key): i = key + 11 return key == 1 and 1.3 or 2.3 self.model.x = VarList(initialize=init_rule) self.instance = self.model.create_instance() self.instance.x.add() self.instance.x.add() self.instance.x.add() self.assertEqual(self.instance.x[1].value, 1.3) self.assertEqual(self.instance.x[2].value, 2.3) self.instance.x[1] = 1 self.instance.x[2] = 2 self.assertEqual(self.instance.x[1], 1) self.assertEqual(self.instance.x[2], 2)
def test_replacement_walker0(self): M = ConcreteModel() M.x = Var(range(3)) M.w = VarList() M.z = Param(range(3), mutable=True) e = sum_product(M.z, M.x) self.assertIs(type(e), LinearExpression) walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertEqual("z[0]*x[0] + z[1]*x[1] + z[2]*x[2]", str(e)) self.assertEqual("2*w[1]*x[0] + 2*w[2]*x[1] + 2*w[3]*x[2]", str(f)) e = 2 * sum_product(M.z, M.x) walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertEqual("2*(z[0]*x[0] + z[1]*x[1] + z[2]*x[2])", str(e)) self.assertEqual("2*(2*w[4]*x[0] + 2*w[5]*x[1] + 2*w[6]*x[2])", str(f))
def test_replacement_walker7(self): M = ConcreteModel() M.x = Var() M.w = VarList() M.z = Param(mutable=True) M.e = Expression(expr=M.z * 2) e = M.x * M.e self.assertTrue(e.arg(1).is_potentially_variable()) self.assertTrue(not e.arg(1).arg(0).is_potentially_variable()) self.assertEqual("x*(z*2)", str(e)) walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertTrue(e.__class__ is ProductExpression) self.assertTrue(f.__class__ is ProductExpression) self.assertEqual(id(e), id(f)) self.assertTrue(f.arg(1).is_potentially_variable()) self.assertTrue(f.arg(1).arg(0).is_potentially_variable()) self.assertEqual("x*(2*w[1]*2)", str(f))
def test_replaceRF(self): # These data objects are normally initialized by # replaceExternalFunctionsWithVariables self.interface.data.all_variables = ComponentSet() self.interface.data.truth_models = ComponentMap() self.interface.data.ef_outputs = VarList() # The objective function has no EF. # Therefore, replaceEF should do nothing expr = self.interface.model.obj.expr new_expr = self.interface.replaceEF(expr) self.assertEqual(expr, new_expr) # The first contraint has one EF. # Therefore, replaceEF should do a substitution expr = self.interface.model.c1.expr new_expr = self.interface.replaceEF(expr) self.assertIsNot(expr, new_expr) self.assertEquals( str(new_expr), 'x[0]*z[0]**2 + trf_data.ef_outputs[1] == 2.8284271247461903')
def test_replacement_walker7(self): M = ConcreteModel() M.x = Var() M.w = VarList() M.z = Param(mutable=True) M.e = Expression(expr=M.z*2) e = M.x*M.e self.assertTrue(e.arg(1).is_potentially_variable()) self.assertTrue(not e.arg(1).arg(0).is_potentially_variable()) self.assertTrue(compare_expressions(ProductExpression([M.x, (NPV_ProductExpression([M.z, 2]))]), e, include_named_exprs=False)) walker = ReplacementWalkerTest3(M) f = walker.dfs_postorder_stack(e) self.assertTrue(e.__class__ is ProductExpression) self.assertTrue(f.__class__ is ProductExpression) self.assertEqual(id(e), id(f)) self.assertTrue(f.arg(1).is_potentially_variable()) self.assertTrue(f.arg(1).arg(0).is_potentially_variable()) self.assertTrue(compare_expressions(M.x*ProductExpression([2*M.w[1], 2]), f, include_named_exprs=False))