def test_simple_sum_rule(self):
m = ConcreteModel()
m.I = RangeSet(3)
m.J = RangeSet(3)
m.x = Var(m.I,m.J)
@m.Constraint(m.I)
def c(m, i):
return sum(m.x[i,j] for j in m.J) <= 0
template, indices = templatize_constraint(m.c)
self.assertEqual(len(indices), 1)
self.assertIs(indices[0]._set, m.I)
self.assertEqual(
template.to_string(verbose=True),
"templatesum(getitem(x, _1, _2), iter(_2, J)) <= 0.0"
)
self.assertEqual(
str(template),
"SUM(x[_1,_2] for _2 in J) <= 0.0"
)
# Evaluate the template
indices[0].set_value(2)
self.assertEqual(
str(resolve_template(template)),
'x[2,1] + x[2,2] + x[2,3] <= 0.0'
)
def test_multidim_nested_sum_rule(self):
m = ConcreteModel()
m.I = RangeSet(3)
m.J = RangeSet(3)
m.JI = m.J * m.I
m.K = Set(m.I, initialize={1: [10], 2: [10, 20], 3: [10, 20, 30]})
m.x = Var(m.I, m.J, [10, 20, 30])
@m.Constraint()
def c(m):
return sum(sum(m.x[i, j, k] for k in m.K[i]) for j, i in m.JI) <= 0
template, indices = templatize_constraint(m.c)
self.assertEqual(len(indices), 0)
self.assertEqual(
template.to_string(verbose=True), "templatesum("
"templatesum(getitem(x, _2, _1, _3), iter(_3, getitem(K, _2))), "
"iter(_1, _2, JI)) <= 0")
self.assertEqual(
str(template), "SUM(SUM(x[_2,_1,_3] for _3 in K[_2]) "
"for _1, _2 in JI) <= 0")
# Evaluate the template
self.assertEqual(
str(resolve_template(template)), 'x[1,1,10] + '
'(x[2,1,10] + x[2,1,20]) + '
'(x[3,1,10] + x[3,1,20] + x[3,1,30]) + '
'(x[1,2,10]) + '
'(x[2,2,10] + x[2,2,20]) + '
'(x[3,2,10] + x[3,2,20] + x[3,2,30]) + '
'(x[1,3,10]) + '
'(x[2,3,10] + x[2,3,20]) + '
'(x[3,3,10] + x[3,3,20] + x[3,3,30]) <= 0')
def test_template_scalar(self):
m = self.m
t = IndexTemplate(m.I)
e = m.x[t]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.args, (m.x, t))
self.assertFalse(e.is_constant())
self.assertFalse(e.is_fixed())
self.assertEqual(e.polynomial_degree(), 1)
self.assertEqual(str(e), "x[{I}]")
t.set_value(5)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 6)
self.assertIs(resolve_template(e), m.x[5])
t.set_value()
e = m.p[t, 10]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.args, (m.p, t, 10))
self.assertFalse(e.is_constant())
self.assertTrue(e.is_fixed())
self.assertEqual(e.polynomial_degree(), 0)
self.assertEqual(str(e), "p[{I},10]")
t.set_value(5)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 510)
self.assertIs(resolve_template(e), m.p[5, 10])
t.set_value()
e = m.p[5, t]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.args, (m.p, 5, t))
self.assertFalse(e.is_constant())
self.assertTrue(e.is_fixed())
self.assertEqual(e.polynomial_degree(), 0)
self.assertEqual(str(e), "p[5,{I}]")
t.set_value(10)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 510)
self.assertIs(resolve_template(e), m.p[5, 10])
t.set_value()
def test_IndexTemplate(self):
m = self.m
i = IndexTemplate(m.I)
with self.assertRaisesRegex(TemplateExpressionError,
"Evaluating uninitialized IndexTemplate"):
value(i)
self.assertEqual(str(i), "{I}")
i.set_value(5)
self.assertEqual(value(i), 5)
self.assertIs(resolve_template(i), 5)
def test_block_templates(self):
m = ConcreteModel()
m.T = RangeSet(3)
@m.Block(m.T)
def b(b, i):
b.x = Var(initialize=i)
@b.Block(m.T)
def bb(bb, j):
bb.I = RangeSet(i * j)
bb.y = Var(bb.I, initialize=lambda m, i: i)
t = IndexTemplate(m.T)
e = m.b[t].x
self.assertIs(type(e), EXPR.GetAttrExpression)
self.assertEqual(e.nargs(), 2)
self.assertIs(type(e.arg(0)), EXPR.GetItemExpression)
self.assertIs(e.arg(0).arg(0), m.b)
self.assertEqual(e.arg(0).nargs(), 2)
self.assertIs(e.arg(0).arg(1), t)
self.assertEqual(str(e), "b[{T}].x")
t.set_value(2)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 2)
self.assertIs(resolve_template(e), m.b[2].x)
t.set_value()
e = m.b[t].bb[t].y[1]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.nargs(), 2)
self.assertEqual(str(e), "b[{T}].bb[{T}].y[1]")
t.set_value(2)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 1)
self.assertIs(resolve_template(e), m.b[2].bb[2].y[1])
def test_simple_rule_nonfinite_set(self):
m = ConcreteModel()
m.x = Var(Integers, dense=False)
@m.Constraint(Integers)
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, Integers)
self.assertEqual(str(template), "x[_1] <= 0")
# Evaluate the template
indices[0].set_value(2)
self.assertEqual(str(resolve_template(template)), 'x[2] <= 0')
def test_template_scalar_with_set(self):
m = self.m
t = IndexTemplate(m.I)
e = m.s[t]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.args, (m.s, t))
self.assertFalse(e.is_constant())
self.assertTrue(e.is_fixed())
self.assertEqual(e.polynomial_degree(), 0)
self.assertEqual(str(e), "s[{I}]")
t.set_value(5)
v = e()
self.assertIs(v, m.s[5])
self.assertIs(resolve_template(e), m.s[5])
t.set_value()
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_nonTemplates(self):
m = self.m
self.assertIs(resolve_template(m.x[1]), m.x[1])
e = m.x[1] + m.x[2]
self.assertIs(resolve_template(e), e)
