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)