def create_model(self, abstract=False):
if abstract is True:
model = AbstractModel()
else:
model = ConcreteModel()
model.x = BooleanVar()
model.y = BooleanVar()
model.z = BooleanVar()
return model
def test_implies(self):
m = ConcreteModel()
m.x = BooleanVar()
m.y = BooleanVar()
m.p = LogicalConstraint(expr=m.x.implies(m.y))
TransformationFactory('core.logical_to_linear').apply_to(m)
_constrs_contained_within(
self, [(1, (1 - m.x.get_associated_binary()) + m.y.get_associated_binary(), None)],
m.logic_to_linear.transformed_constraints)
def test_node_types(self):
m = ConcreteModel()
m.Y1 = BooleanVar()
m.Y2 = BooleanVar()
m.Y3 = BooleanVar()
self.assertFalse(m.Y1.is_expression_type())
self.assertTrue(lnot(m.Y1).is_expression_type())
self.assertTrue(equivalent(m.Y1, m.Y2).is_expression_type())
self.assertTrue(atmost(1, [m.Y1, m.Y2, m.Y3]).is_expression_type())
def test_binary_xor(self):
m = ConcreteModel()
m.Y1 = BooleanVar()
m.Y2 = BooleanVar()
op_static = xor(m.Y1, m.Y2)
op_class = m.Y1.xor(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 = operator.xor(*truth_combination)
self.assertEqual(value(op_static), correct_value)
self.assertEqual(value(op_class), correct_value)
def test_BooleanVar(self):
"""
Simple construction and value setting
"""
m = ConcreteModel()
m.Y1 = BooleanVar()
m.Y2 = BooleanVar()
self.assertIsNone(m.Y1.value)
m.Y1.set_value(False)
self.assertFalse(m.Y1.value)
m.Y1.set_value(True)
self.assertTrue(m.Y1.value)
def test_backmap_deprecated(self):
m = ConcreteModel()
m.s = RangeSet(3)
m.Y = BooleanVar(m.s)
TransformationFactory('core.logical_to_linear').apply_to(m)
output = StringIO()
with LoggingIntercept(output, 'pyomo.core.base', logging.WARNING):
y1 = m.Y[1].get_associated_binary()
self.assertIn(
"DEPRECATED: Relying on core.logical_to_linear to "
"transform BooleanVars that do not appear in "
"LogicalConstraints is deprecated. Please "
"associate your own binaries if you have BooleanVars "
"not used in logical expressions.",
output.getvalue().replace('\n', ' '))
output = StringIO()
with LoggingIntercept(output, 'pyomo.core.base', logging.WARNING):
y2 = m.Y[2].get_associated_binary()
self.assertIn(
"DEPRECATED: Relying on core.logical_to_linear to "
"transform BooleanVars that do not appear in "
"LogicalConstraints is deprecated. Please "
"associate your own binaries if you have BooleanVars "
"not used in logical expressions.",
output.getvalue().replace('\n', ' '))
y1.value = 1
y2.value = 0
update_boolean_vars_from_binary(m)
self.assertTrue(m.Y[1].value)
self.assertFalse(m.Y[2].value)
self.assertIsNone(m.Y[3].value)
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 _generate_boolean_model(nvars):
m = ConcreteModel()
m.s = RangeSet(nvars)
m.Y = BooleanVar(m.s)
# make sure all the variables are used in at least one logical constraint
m.constraint = LogicalConstraint(expr=exactly(2, m.Y))
return m
def test_literal(self):
m = ConcreteModel()
m.Y = BooleanVar()
m.p = LogicalConstraint(expr=m.Y)
TransformationFactory('core.logical_to_linear').apply_to(m)
_constrs_contained_within(self, [(1, m.Y.get_associated_binary(), 1)],
m.logic_to_linear.transformed_constraints)
def test_numeric_invalid(self):
m = ConcreteModel()
m.Y1 = BooleanVar()
m.Y2 = BooleanVar()
m.Y3 = BooleanVar()
def invalid_expression_generator():
yield lambda: m.Y1 + m.Y2
yield lambda: m.Y1 - m.Y2
yield lambda: m.Y1 * m.Y2
yield lambda: m.Y1 / m.Y2
yield lambda: m.Y1**m.Y2
yield lambda: 0 + m.Y2
yield lambda: 0 - m.Y2
yield lambda: 0 * m.Y2
yield lambda: 0 / m.Y2
yield lambda: 0**m.Y2
numeric_error_msg = "(?:(?:unsupported operand type)|(?:operands do not support))"
for invalid_expr_fcn in invalid_expression_generator():
with self.assertRaisesRegex(TypeError, numeric_error_msg):
_ = invalid_expr_fcn()
def invalid_unary_expression_generator():
yield lambda: -m.Y1
yield lambda: +m.Y1
for invalid_expr_fcn in invalid_unary_expression_generator():
with self.assertRaisesRegex(
TypeError, "(?:(?:bad operand type for unary)"
"|(?:unsupported operand type for unary))"):
_ = invalid_expr_fcn()
def invalid_comparison_generator():
yield lambda: m.Y1 >= 0
yield lambda: m.Y1 <= 0
yield lambda: m.Y1 > 0
yield lambda: m.Y1 < 0
# These errors differ between python versions, regrettably
comparison_error_msg = "(?:(?:unorderable types)|(?:not supported between instances of))"
if six.PY3:
for invalid_expr_fcn in invalid_comparison_generator():
with self.assertRaisesRegex(TypeError, comparison_error_msg):
_ = invalid_expr_fcn()
else: # Python 2
pass
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_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_unary_not(self):
m = ConcreteModel()
m.Y = BooleanVar()
op_static = lnot(m.Y)
op_operator = ~m.Y
for truth_combination in _generate_possible_truth_inputs(1):
m.Y.set_value(truth_combination[0])
correct_value = not truth_combination[0]
self.assertEqual(value(op_static), correct_value)
self.assertEqual(value(op_operator), correct_value)
def make_nested_block_model(self):
"""For the next two tests: Has BooleanVar on model, but
LogicalConstraints on a Block and a Block nested on that Block."""
m = ConcreteModel()
m.b = Block()
m.Y = BooleanVar([1, 2])
m.b.logical = LogicalConstraint(expr=~m.Y[1])
m.b.b = Block()
m.b.b.logical = LogicalConstraint(expr=m.Y[1].xor(m.Y[2]))
return m
def test_xfrm_exactly_statement(self):
m = ConcreteModel()
m.s = RangeSet(3)
m.Y = BooleanVar(m.s)
m.p = LogicalConstraint(expr=exactly(2, m.Y[1], m.Y[2], m.Y[3]))
TransformationFactory('core.logical_to_linear').apply_to(m)
_constrs_contained_within(self, [(2, m.Y[1].get_associated_binary() +
m.Y[2].get_associated_binary() +
m.Y[3].get_associated_binary(), 2)],
m.logic_to_linear.transformed_constraints)
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_invalid_conversion(self):
m = ConcreteModel()
m.Y1 = BooleanVar()
with self.assertRaisesRegex(TypeError,
"argument must be a string or a number"):
float(m.Y1)
with self.assertRaisesRegex(
TypeError, "argument must be a string"
"(?:, a bytes-like object)? or a number"):
int(m.Y1)
def test_can_associate_unused_boolean_after_transformation(self):
m = ConcreteModel()
m.Y = BooleanVar()
TransformationFactory('core.logical_to_linear').apply_to(m)
m.y = Var(domain=Binary)
output = StringIO()
with LoggingIntercept(output, 'pyomo.core.base', logging.WARNING):
m.Y.associate_binary_var(m.y)
y = m.Y.get_associated_binary()
self.assertIs(y, m.y)
# we didn't whine about this
self.assertEqual(output.getvalue(), '')
def test_nary_atleast(self):
nargs = 5
m = ConcreteModel()
m.s = RangeSet(nargs)
m.Y = BooleanVar(m.s)
for truth_combination in _generate_possible_truth_inputs(nargs):
for ntrue in range(nargs + 1):
m.Y.set_values(dict(enumerate(truth_combination, 1)))
correct_value = sum(truth_combination) >= ntrue
self.assertEqual(value(atleast(ntrue, *(m.Y[i] for i in m.s))),
correct_value)
self.assertEqual(value(atleast(ntrue, m.Y)), correct_value)
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_backmap_hierarchical_model(self):
m = _generate_boolean_model(3)
m.b = Block()
m.b.Y = BooleanVar()
m.b.lc = LogicalConstraint(expr=m.Y[1].lor(m.b.Y))
TransformationFactory('core.logical_to_linear').apply_to(m)
m.Y_asbinary[1].value = 1
m.Y_asbinary[2].value = 0
m.b.Y.get_associated_binary().value = 1
update_boolean_vars_from_binary(m)
self.assertTrue(m.Y[1].value)
self.assertFalse(m.Y[2].value)
self.assertIsNone(m.Y[3].value)
self.assertTrue(m.b.Y.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_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)
def build_model():
m = ConcreteModel()
seed(1) # Fix seed to generate same parameters and solution every time
m.T_max = randint(10, 10)
m.T = RangeSet(m.T_max)
# Variables
m.s = Var(m.T, domain=NonNegativeReals, bounds=(0, 10000), doc='stock')
m.x = Var(m.T, domain=NonNegativeReals, bounds=(0, 10000), doc='purchased')
m.c = Var(m.T, domain=NonNegativeReals, bounds=(0, 10000), doc='cost')
m.f = Var(m.T, domain=NonNegativeReals, bounds=(0, 10000), doc='feed')
m.max_q_idx = RangeSet(m.T_max)
# Randomly generated parameters
m.D = Param(m.T, doc='demand',
initialize=dict((t, randint(50, 100)) for t in m.T))
m.alpha = Param(m.T, doc='storage cost',
initialize=dict((t, randint(5, 20)) for t in m.T))
m.gamma = Param(m.T, doc='base buying cost',
initialize=dict((t, randint(10, 30)) for t in m.T))
m.beta_B = Param(m.T, doc='bulk discount',
initialize=dict((t, randint(50, 500)/1000) for t in m.T))
m.F_B_lo = Param(m.T, doc='bulk minimum purchase amount',
initialize=dict((t, randint(50, 100)) for t in m.T))
m.beta_L = Param(m.T, m.max_q_idx,
initialize=dict(((t, q), randint(10, 999)/1000)
for t in m.T for q in m.max_q_idx),
doc='long-term discount')
m.F_L_lo = Param(m.T, m.max_q_idx,
initialize=dict(((t, q), randint(50, 100))
for t in m.T for q in m.max_q_idx),
doc='long-term minimum purchase amount')
# Contract choices 'standard', 'bulk' and long term contracts '0','1',...
time_time_choices = [(t1, str(t2)) for t1, t2 in m.T * m.T if t2 <= m.T_max - t1]
time_special_choices = [(t, s) for t in m.T for s in {'S', 'B', '0'}]
m.contract_time_choices = Set(initialize=time_time_choices + time_special_choices)
m.disjunct_choices = Set(
initialize=['S', 'B', *[str(t) for t in range(m.T_max)]])
m.disjuncts = Disjunct(m.contract_time_choices)
m.Y = BooleanVar(m.contract_time_choices)
for t, c in m.contract_time_choices:
m.Y[t, c].associate_binary_var(m.disjuncts[t, c].indicator_var)
# Create disjuncts for contracts in each timeset
for t in m.T:
m.disjuncts[t, 'S'].cost = Constraint(expr=m.c[t] == m.gamma[t]*m.x[t])
m.disjuncts[t, 'B'].cost = Constraint(
expr=m.c[t] == (1-m.beta_B[t])*m.gamma[t]*m.x[t])
m.disjuncts[t, 'B'].amount = Constraint(
expr=m.x[t] >= m.F_B_lo[t])
m.disjuncts[t, '0'].c = Constraint(expr=0 <= m.c[t])
for q in range(1, m.T_max-t+1):
m.disjuncts[t, str(q)].t_idx = RangeSet(t, t+q)
m.disjuncts[t, str(q)].cost = Constraint(m.disjuncts[t, str(q)].t_idx)
m.disjuncts[t, str(q)].amount = Constraint(m.disjuncts[t, str(q)].t_idx)
for t_ in m.disjuncts[t, str(q)].t_idx:
m.disjuncts[t, str(q)].cost[t_] =\
m.c[t_] == (1-m.beta_L[t, q])*m.gamma[t]*m.x[t_]
m.disjuncts[t, str(q)].amount[t_] =\
m.x[t_] >= m.F_L_lo[t, q]
# Create disjunctions
@m.Disjunction(m.T, xor=True)
def disjunctions(m, t):
return [m.disjuncts[t, 'S'], m.disjuncts[t, 'B'], m.disjuncts[t, '0'],
*[m.disjuncts[t, str(q)] for q in range(1, m.T_max-t+1)]]
# Connect the disjuncts indicator variables using logical expressions
m.logical_blocks = Block(range(1, m.T_max+1))
# Enforce absence of existing long-term contract
m.logical_blocks[1].not_y_1_0 = LogicalConstraint(expr=~m.Y[1, '0'], doc="no pre-existing long-term contract")
# Long-term contract implies '0'-disjunct in following timesteps
for t in range(2, m.T_max+1):
m.logical_blocks[t].equiv = LogicalConstraint(
expr=m.Y[t, '0'].equivalent_to(lor(m.Y[t_, str(q)] for t_ in range(1, t) for q in range(t - t_, m.T_max - t_ + 1)))
)
# Objective function
m.objective = Objective(expr=sum(m.alpha[t]*m.s[t]+m.c[t] for t in m.T))
# Global constraints
m.demand_satisfaction = Constraint(m.T)
for t in m.T:
m.demand_satisfaction[t] = m.f[t] >= m.D[t]
m.material_balance = Constraint(m.T)
for t in m.T:
m.material_balance[t]=m.s[t] == (m.s[t-1] if t>1 else 0) + m.x[t] - m.f[t]
return m
def _generate_boolean_model(nvars):
m = ConcreteModel()
m.s = RangeSet(nvars)
m.Y = BooleanVar(m.s)
return m
def test_xfrm_special_atoms_nonroot(self):
m = ConcreteModel()
m.s = RangeSet(3)
m.Y = BooleanVar(m.s)
m.p = LogicalConstraint(
expr=m.Y[1].implies(atleast(2, m.Y[1], m.Y[2], m.Y[3])))
TransformationFactory('core.logical_to_linear').apply_to(m)
Y_aug = m.logic_to_linear.augmented_vars
self.assertEqual(len(Y_aug), 1)
self.assertEqual(Y_aug[1].domain, BooleanSet)
_constrs_contained_within(
self, [(None, sum(m.Y[:].get_associated_binary()) -
(1 + 2 * Y_aug[1].get_associated_binary()), 0),
(1, (1 - m.Y[1].get_associated_binary()) +
Y_aug[1].get_associated_binary(), None),
(None, 2 - 2 * (1 - Y_aug[1].get_associated_binary()) -
sum(m.Y[:].get_associated_binary()), 0)],
m.logic_to_linear.transformed_constraints)
m = ConcreteModel()
m.s = RangeSet(3)
m.Y = BooleanVar(m.s)
m.p = LogicalConstraint(
expr=m.Y[1].implies(atmost(2, m.Y[1], m.Y[2], m.Y[3])))
TransformationFactory('core.logical_to_linear').apply_to(m)
Y_aug = m.logic_to_linear.augmented_vars
self.assertEqual(len(Y_aug), 1)
self.assertEqual(Y_aug[1].domain, BooleanSet)
_constrs_contained_within(
self, [(None, sum(m.Y[:].get_associated_binary()) -
(1 - Y_aug[1].get_associated_binary() + 2), 0),
(1, (1 - m.Y[1].get_associated_binary()) +
Y_aug[1].get_associated_binary(), None),
(None, 3 - 3 * Y_aug[1].get_associated_binary() -
sum(m.Y[:].get_associated_binary()), 0)],
m.logic_to_linear.transformed_constraints)
m = ConcreteModel()
m.s = RangeSet(3)
m.Y = BooleanVar(m.s)
m.p = LogicalConstraint(
expr=m.Y[1].implies(exactly(2, m.Y[1], m.Y[2], m.Y[3])))
TransformationFactory('core.logical_to_linear').apply_to(m)
Y_aug = m.logic_to_linear.augmented_vars
self.assertEqual(len(Y_aug), 3)
self.assertEqual(Y_aug[1].domain, BooleanSet)
_constrs_contained_within(self, [
(1, (1 - m.Y[1].get_associated_binary()) +
Y_aug[1].get_associated_binary(), None),
(None, sum(m.Y[:].get_associated_binary()) -
(1 - Y_aug[1].get_associated_binary() + 2), 0),
(None, 2 - 2 * (1 - Y_aug[1].get_associated_binary()) -
sum(m.Y[:].get_associated_binary()), 0),
(1, sum(Y_aug[:].get_associated_binary()), None),
(None, sum(m.Y[:].get_associated_binary()) -
(1 + 2 * (1 - Y_aug[2].get_associated_binary())), 0),
(None, 3 - 3 * (1 - Y_aug[3].get_associated_binary()) -
sum(m.Y[:].get_associated_binary()), 0),
], m.logic_to_linear.transformed_constraints)
# Note: x is now a variable
m = ConcreteModel()
m.s = RangeSet(3)
m.Y = BooleanVar(m.s)
m.x = Var(bounds=(1, 3))
m.p = LogicalConstraint(
expr=m.Y[1].implies(exactly(m.x, m.Y[1], m.Y[2], m.Y[3])))
TransformationFactory('core.logical_to_linear').apply_to(m)
Y_aug = m.logic_to_linear.augmented_vars
self.assertEqual(len(Y_aug), 3)
self.assertEqual(Y_aug[1].domain, BooleanSet)
_constrs_contained_within(self, [
(1, (1 - m.Y[1].get_associated_binary()) +
Y_aug[1].get_associated_binary(), None),
(None, sum(m.Y[:].get_associated_binary()) -
(m.x + 2 * (1 - Y_aug[1].get_associated_binary())), 0),
(None, m.x - 3 * (1 - Y_aug[1].get_associated_binary()) -
sum(m.Y[:].get_associated_binary()), 0),
(1, sum(Y_aug[:].get_associated_binary()), None),
(None, sum(m.Y[:].get_associated_binary()) -
(m.x - 1 + 3 * (1 - Y_aug[2].get_associated_binary())), 0),
(None, m.x + 1 - 4 * (1 - Y_aug[3].get_associated_binary()) -
sum(m.Y[:].get_associated_binary()), 0),
], m.logic_to_linear.transformed_constraints)
def test_as_quantity_scalar(self):
_pint = units._pint_registry
Quantity = _pint.Quantity
m = ConcreteModel()
m.x = Var(initialize=1)
m.y = Var(initialize=2, units=units.g)
m.p = Param(initialize=3)
m.q = Param(initialize=4, units=1 / units.s)
m.b = BooleanVar(initialize=True)
q = as_quantity(0)
self.assertIs(q.__class__, Quantity)
self.assertEqual(q, 0 * _pint.dimensionless)
q = as_quantity(None)
self.assertIs(q.__class__, None.__class__)
self.assertEqual(q, None)
q = as_quantity(str('aaa'))
self.assertIs(q.__class__, Quantity)
self.assertEqual(q, 'aaa' * _pint.dimensionless)
q = as_quantity(True)
self.assertIs(q.__class__, bool)
self.assertEqual(q, True)
q = as_quantity(units.kg)
self.assertIs(q.__class__, Quantity)
self.assertEqual(q, 1 * _pint.kg)
q = as_quantity(NumericConstant(5))
self.assertIs(q.__class__, Quantity)
self.assertEqual(q, 5 * _pint.dimensionless)
q = as_quantity(m.x)
self.assertIs(q.__class__, Quantity)
self.assertEqual(q, 1 * _pint.dimensionless)
q = as_quantity(m.y)
self.assertIs(q.__class__, Quantity)
self.assertEqual(q, 2 * _pint.g)
q = as_quantity(m.p)
self.assertIs(q.__class__, Quantity)
self.assertEqual(q, 3 * _pint.dimensionless)
q = as_quantity(m.q)
self.assertIs(q.__class__, Quantity)
self.assertEqual(q, 4 / _pint.s)
q = as_quantity(m.b)
self.assertIs(q.__class__, bool)
self.assertEqual(q, True)
class UnknownPyomoType(object):
def is_expression_type(self):
return False
def is_numeric_type(self):
return False
def is_logical_type(self):
return False
other = UnknownPyomoType()
q = as_quantity(other)
self.assertIs(q.__class__, UnknownPyomoType)
self.assertIs(q, other)