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