def test_numpy_float(self):
# Test issue #31
m = ConcreteModel()
m.T = Set(initialize=range(3))
m.v = Var(initialize=1, bounds=(0, None))
m.c = Var(m.T, initialize=20)
h = [np.float32(1.0), 1.0, 1]
def rule(m, t):
return m.c[0] == h[t] * m.c[0]
m.x = Constraint(m.T, rule=rule)
def rule(m, t):
return m.c[0] == h[t] * m.c[0] * m.v
m.y = Constraint(m.T, rule=rule)
def rule(m, t):
return m.c[0] == h[t] * m.v
m.z = Constraint(m.T, rule=rule)
#m.pprint()
for t in m.T:
self.assertTrue(compare_expressions(m.x[0].expr, m.x[t].expr))
self.assertTrue(compare_expressions(m.y[0].expr, m.y[t].expr))
self.assertTrue(compare_expressions(m.z[0].expr, m.z[t].expr))
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_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_no_replacement(self):
m = ConcreteModel()
m.x = Param(mutable=True)
m.y = Var([1,2,3])
e = sum(m.y[i] for i in m.y) == 0
f = ReplacementWalker_ReplaceInternal().dfs_postorder_stack(e)
self.assertTrue(compare_expressions(m.y[1] + m.y[2] + m.y[3] == 0, e))
self.assertTrue(compare_expressions(m.y[1] + m.y[2] + m.y[3] == 0, f))
self.assertIs(e, f)
def test_replace_nested(self):
m = ConcreteModel()
m.x = Param(mutable=True)
m.y = Var([1,2,3])
e = m.y[1]*m.y[2]*m.y[2]*m.y[3] == 0
f = ReplacementWalker_ReplaceInternal().dfs_postorder_stack(e)
self.assertTrue(compare_expressions(m.y[1]*m.y[2]*m.y[2]*m.y[3] == 0, e))
self.assertTrue(compare_expressions(m.y[1] + m.y[2] + m.y[2] + m.y[3] == 0, f))
self.assertIs(type(f.arg(0)), SumExpression)
self.assertEqual(f.arg(0).nargs(), 4)
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_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_numpy_scalar_times_scalar_var(self):
# Test issue #685
m = ConcreteModel()
m.x = Var()
e = np.float64(5) * m.x
self.assertIs(type(e), MonomialTermExpression)
self.assertTrue(compare_expressions(e, 5.0 * m.x))
e = m.x * np.float64(5)
self.assertIs(type(e), MonomialTermExpression)
self.assertTrue(compare_expressions(e, 5.0 * m.x))
def test_npv_sum(self):
m = ConcreteModel()
m.p1 = Param(mutable=True)
m.p2 = Param(mutable=True)
m.x = Var()
e1 = m.p1 + 2
e2 = replace_expressions(e1, {id(m.p1): m.p2})
e3 = replace_expressions(e1, {id(m.p1): m.x})
self.assertTrue(compare_expressions(e2, m.p2 + 2))
self.assertTrue(compare_expressions(e3, m.x + 2))
def test_npv_unary(self):
m = ConcreteModel()
m.p1 = Param(mutable=True)
m.p2 = Param(mutable=True)
m.x = Var(initialize=0)
e1 = sin(m.p1)
e2 = replace_expressions(e1, {id(m.p1): m.p2})
e3 = replace_expressions(e1, {id(m.p1): m.x})
self.assertTrue(compare_expressions(e2, sin(m.p2)))
self.assertTrue(compare_expressions(e3, sin(m.x)))
def test_npv_abs(self):
m = ConcreteModel()
m.p1 = Param(mutable=True)
m.p2 = Param(mutable=True)
m.x = Var()
e1 = abs(m.p1)
e2 = replace_expressions(e1, {id(m.p1): m.p2})
e3 = replace_expressions(e1, {id(m.p1): m.x})
self.assertTrue(compare_expressions(e2, abs(m.p2)))
self.assertTrue(compare_expressions(e3, abs(m.x)))
def test_npv_div(self):
m = ConcreteModel()
m.p1 = Param(mutable=True)
m.p2 = Param(mutable=True)
m.x = Var()
e1 = m.p1/3
e2 = replace_expressions(e1, {id(m.p1): m.p2})
e3 = replace_expressions(e1, {id(m.p1): m.x})
self.assertTrue(compare_expressions(e2, m.p2/3))
self.assertTrue(compare_expressions(e3, DivisionExpression([m.x, 3])))
def test_npv_product(self):
m = ConcreteModel()
m.p1 = Param(mutable=True)
m.p2 = Param(mutable=True)
m.x = Var()
e1 = m.p1*3
e2 = replace_expressions(e1, {id(m.p1): m.p2})
e3 = replace_expressions(e1, {id(m.p1): m.x})
self.assertTrue(compare_expressions(e2, m.p2*3))
self.assertTrue(compare_expressions(e3, ProductExpression([m.x, 3])))
def test_npv_negation(self):
m = ConcreteModel()
m.p1 = Param(mutable=True)
m.p2 = Param(mutable=True)
m.x = Var()
e1 = -m.p1
e2 = replace_expressions(e1, {id(m.p1): m.p2})
e3 = replace_expressions(e1, {id(m.p1): m.x})
self.assertTrue(compare_expressions(e2, -m.p2))
self.assertTrue(compare_expressions(e3, NegationExpression([m.x])))
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.assertTrue(compare_expressions(M.z*M.x, e))
self.assertTrue(compare_expressions(M.z*(2*M.w[1]), f))
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_indexed_constraint(self):
m = ConcreteModel()
m.x = Var([0, 1, 2, 3])
A = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
b = np.array([10, 20])
m.c = Constraint([0, 1], expr=A @ m.x <= b)
self.assertTrue(
compare_expressions(
m.c[0].expr,
m.x[0] + 2 * m.x[1] + 3 * m.x[2] + 4 * m.x[3] <= 10))
self.assertTrue(
compare_expressions(
m.c[1].expr,
5 * m.x[0] + 6 * m.x[1] + 7 * m.x[2] + 8 * m.x[3] <= 20))
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_multiple(self):
m = pe.ConcreteModel()
m.x = pe.Var()
m.y = pe.Var()
e = m.x**2 + m.x * m.y / 3 + 4
expected = [(SumExpression, 3), (PowExpression, 2), m.x, 2,
(DivisionExpression, 2), (ProductExpression, 2), m.x, m.y,
3, 4]
pn = convert_expression_to_prefix_notation(e)
self.assertEqual(pn, expected)
e2 = m.x**2 + m.x * m.y / 3 + 4
e3 = m.y**2 + m.x * m.y / 3 + 4
self.assertTrue(compare_expressions(e, e2))
self.assertFalse(compare_expressions(e, e3))
def test_sympy(self):
m = pyo.ConcreteModel()
m.x = pyo.Var(initialize=0.23)
m.y = pyo.Var(initialize=0.88)
ddx = differentiate(m.x**2, wrt=m.x, mode='sympy')
self.assertTrue(compare_expressions(ddx, 2 * m.x))
self.assertAlmostEqual(ddx(), 0.46)
ddy = differentiate(m.x**2, wrt=m.y, mode='sympy')
self.assertEqual(ddy, 0)
ddx = differentiate(m.x**2, wrt_list=[m.x, m.y], mode='sympy')
self.assertIsInstance(ddx, list)
self.assertEqual(len(ddx), 2)
self.assertTrue(compare_expressions(ddx[0], 2 * m.x))
self.assertAlmostEqual(ddx[0](), 0.46)
self.assertEqual(ddx[1], 0)
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))
