def test_cnf(self):
m = ConcreteModel()
m.Y1 = BooleanVar()
m.Y2 = BooleanVar()
implication = implies(m.Y1, m.Y2)
x = to_cnf(implication)[0]
_check_equivalent(self, implication, x)
atleast_expr = atleast(1, m.Y1, m.Y2)
x = to_cnf(atleast_expr)[0]
self.assertIs(atleast_expr, x) # should be no change
nestedatleast = implies(m.Y1, atleast_expr)
m.extraY = BooleanVarList()
indicator_map = ComponentMap()
x = to_cnf(nestedatleast, m.extraY, indicator_map)
self.assertEqual(str(x[0]), "extraY[1] ∨ ~Y1")
self.assertIs(indicator_map[m.extraY[1]], atleast_expr)
def test_binary_implies(self):
m = ConcreteModel()
m.Y1 = BooleanVar()
m.Y2 = BooleanVar()
op_static = implies(m.Y1, m.Y2)
op_class = m.Y1.implies(m.Y2)
# op_loperator = m.Y2 << m.Y1
# op_roperator = m.Y1 >> m.Y2
for truth_combination in _generate_possible_truth_inputs(2):
m.Y1.value, m.Y2.value = truth_combination[0], truth_combination[1]
correct_value = (not truth_combination[0]) or truth_combination[1]
self.assertEqual(value(op_static), correct_value)
self.assertEqual(value(op_class), correct_value)
# self.assertEqual(value(op_loperator), correct_value)
# self.assertEqual(value(op_roperator), correct_value)
nnf = lnot(m.Y1).lor(m.Y2)
self.assertEqual(value(op_static), value(nnf))
def test_to_string(self):
m = ConcreteModel()
m.Y1 = BooleanVar()
m.Y2 = BooleanVar()
m.Y3 = BooleanVar()
self.assertEqual(str(land(m.Y1, m.Y2, m.Y3)), "Y1 ∧ Y2 ∧ Y3")
self.assertEqual(str(lor(m.Y1, m.Y2, m.Y3)), "Y1 ∨ Y2 ∨ Y3")
self.assertEqual(str(equivalent(m.Y1, m.Y2)), "Y1 iff Y2")
self.assertEqual(str(implies(m.Y1, m.Y2)), "Y1 --> Y2")
self.assertEqual(str(xor(m.Y1, m.Y2)), "Y1 ⊻ Y2")
self.assertEqual(str(atleast(1, m.Y1, m.Y2)), "atleast(1: [Y1, Y2])")
self.assertEqual(str(atmost(1, m.Y1, m.Y2)), "atmost(1: [Y1, Y2])")
self.assertEqual(str(exactly(1, m.Y1, m.Y2)), "exactly(1: [Y1, Y2])")
# Precedence check
self.assertEqual(str(m.Y1.implies(m.Y2).lor(m.Y3)), "(Y1 --> Y2) ∨ Y3")
def test_logical_constraints_transformed(self):
"""It is expected that the result of this transformation is a MI(N)LP,
so check that LogicalConstraints are handeled correctly"""
m = ConcreteModel()
m.x = Var(bounds=(0, 10))
m.d1 = Disjunct()
m.d2 = Disjunct()
m.d2.c = Constraint()
m.d = Disjunction(expr=[m.d1, m.d2])
m.another = Disjunction(expr=[[m.x == 3], [m.x == 0]])
m.Y = BooleanVar()
m.global_logical = LogicalConstraint(expr=m.Y.xor(m.d1.indicator_var))
m.d1.logical = LogicalConstraint(
expr=implies(~m.Y, m.another.disjuncts[0].indicator_var))
m.obj = Objective(expr=m.x)
m.d1.indicator_var.set_value(True)
m.d2.indicator_var.set_value(False)
m.another.disjuncts[0].indicator_var.set_value(True)
m.another.disjuncts[1].indicator_var.set_value(False)
TransformationFactory('gdp.fix_disjuncts').apply_to(m)
# Make sure there are no active LogicalConstraints
self.assertEqual(
len(
list(
m.component_data_objects(LogicalConstraint,
active=True,
descend_into=(Block, Disjunct)))),
0)
# See that it solves as expected
SolverFactory('gurobi').solve(m)
self.assertTrue(value(m.d1.indicator_var))
self.assertFalse(value(m.d2.indicator_var))
self.assertTrue(value(m.another.disjuncts[0].indicator_var))
self.assertFalse(value(m.another.disjuncts[1].indicator_var))
self.assertEqual(value(m.Y.get_associated_binary()), 0)
self.assertEqual(value(m.x), 3)
