def test_transformed_components_on_parent_block(self):
m = ConcreteModel()
m.b = Block()
m.b.s = RangeSet(3)
m.b.Y = BooleanVar(m.b.s)
m.b.p = LogicalConstraint(
expr=m.b.Y[1].implies(lor(m.b.Y[2], m.b.Y[3])))
TransformationFactory('core.logical_to_linear').apply_to(m)
boolean_var = m.b.component("Y_asbinary")
self.assertIsInstance(boolean_var, Var)
notAVar = m.component("Y_asbinary")
self.assertIsNone(notAVar)
transBlock = m.b.component("logic_to_linear")
self.assertIsInstance(transBlock, Block)
notAThing = m.component("logic_to_linear")
self.assertIsNone(notAThing)
# check the constraints on the transBlock
_constrs_contained_within(
self, [
(1,
m.b.Y[2].get_associated_binary() + \
m.b.Y[3].get_associated_binary()
+ (1 - m.b.Y[1].get_associated_binary()),
None)
], m.b.logic_to_linear.transformed_constraints)
def test_longer_statement(self):
m = ConcreteModel()
m.s = RangeSet(3)
m.Y = BooleanVar(m.s)
m.p = LogicalConstraint(expr=m.Y[1].implies(lor(m.Y[2], m.Y[3])))
TransformationFactory('core.logical_to_linear').apply_to(m)
_constrs_contained_within(
self,
[(1,
m.Y[2].get_associated_binary() + m.Y[3].get_associated_binary() +
(1 - m.Y[1].get_associated_binary()), None)],
m.logic_to_linear.transformed_constraints)
def test_binary_or(self):
m = ConcreteModel()
m.Y1 = BooleanVar()
m.Y2 = BooleanVar()
op_static = lor(m.Y1, m.Y2)
op_class = m.Y1.lor(m.Y2)
# op_operator = 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 = any(truth_combination)
self.assertEqual(value(op_static), correct_value)
self.assertEqual(value(op_class), correct_value)
def test_nary_or(self):
nargs = 3
m = ConcreteModel()
m.s = RangeSet(nargs)
m.Y = BooleanVar(m.s)
op_static = lor(*(m.Y[i] for i in m.s))
op_class = BooleanConstant(False)
# op_operator = False
for y in m.Y.values():
op_class = op_class.lor(y)
# op_operator |= y
for truth_combination in _generate_possible_truth_inputs(nargs):
m.Y.set_values(dict(enumerate(truth_combination, 1)))
correct_value = any(truth_combination)
self.assertEqual(value(op_static), correct_value)
self.assertEqual(value(op_class), correct_value)
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_link_with_gdp_indicators(self):
m = _generate_boolean_model(4)
m.d1 = Disjunct()
m.d2 = Disjunct()
m.x = Var()
m.dd = Disjunct([1, 2])
m.d1.c = Constraint(expr=m.x >= 2)
m.d2.c = Constraint(expr=m.x <= 10)
m.dd[1].c = Constraint(expr=m.x >= 5)
m.dd[2].c = Constraint(expr=m.x <= 6)
m.Y[1].associate_binary_var(m.d1.indicator_var)
m.Y[2].associate_binary_var(m.d2.indicator_var)
m.Y[3].associate_binary_var(m.dd[1].indicator_var)
m.Y[4].associate_binary_var(m.dd[2].indicator_var)
m.p = LogicalConstraint(expr=m.Y[1].implies(lor(m.Y[3], m.Y[4])))
m.p2 = LogicalConstraint(expr=atmost(2, *m.Y[:]))
TransformationFactory('core.logical_to_linear').apply_to(m)
_constrs_contained_within(
self, [
(1, m.dd[1].indicator_var + m.dd[2].indicator_var + 1 - m.d1.indicator_var, None),
(None, m.d1.indicator_var + m.d2.indicator_var + m.dd[1].indicator_var + m.dd[2].indicator_var, 2)
], m.logic_to_linear.transformed_constraints)
def onState(m, g, t):
if t == m.TIME.first():
return pyo.LogicalConstraint.Skip
return m.GenOn[g, t].indicator_var.implies(
pyo.lor(m.GenOn[g, t - 1].indicator_var,
m.GenStartup[g, t - 1].indicator_var))
def make_indexed_logical_constraint_model(self):
m = _generate_boolean_model(3)
m.cons = LogicalConstraint([1, 2])
m.cons[1] = exactly(2, m.Y)
m.cons[2] = m.Y[1].implies(lor(m.Y[2], m.Y[3]))
return m