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))