diff --git a/examples/pyomobook/blocks-ch/blocks_gen.txt b/examples/pyomobook/blocks-ch/blocks_gen.txt index 1636f7e4590..4e9ac672020 100644 --- a/examples/pyomobook/blocks-ch/blocks_gen.txt +++ b/examples/pyomobook/blocks-ch/blocks_gen.txt @@ -22,11 +22,11 @@ 2 Var Declarations Power : Size=5, Index=TIME Key : Lower : Value : Upper : Fixed : Stale : Domain - 0 : 0 : 120.0 : 500.0 : False : False : Reals - 1 : 0 : 145.0 : 500.0 : False : False : Reals - 2 : 0 : 119.0 : 500.0 : False : False : Reals - 3 : 0 : 42.0 : 500.0 : False : False : Reals - 4 : 0 : 190.0 : 500.0 : False : False : Reals + 0 : 0 : 120.0 : 500 : False : False : Reals + 1 : 0 : 145.0 : 500 : False : False : Reals + 2 : 0 : 119.0 : 500 : False : False : Reals + 3 : 0 : 42.0 : 500 : False : False : Reals + 4 : 0 : 190.0 : 500 : False : False : Reals UnitOn : Size=5, Index=TIME Key : Lower : Value : Upper : Fixed : Stale : Domain 0 : 0 : None : 1 : False : True : Binary @@ -46,11 +46,11 @@ 1 Constraint Declarations limit_ramp : Size=4, Index=TIME, Active=True - Key : Lower : Body : Upper : Active - 1 : -50.0 : Generator[G_EAST].Power[1] - Generator[G_EAST].Power[0] : Generator[G_EAST].RampLimit : True - 2 : -50.0 : Generator[G_EAST].Power[2] - Generator[G_EAST].Power[1] : Generator[G_EAST].RampLimit : True - 3 : -50.0 : Generator[G_EAST].Power[3] - Generator[G_EAST].Power[2] : Generator[G_EAST].RampLimit : True - 4 : -50.0 : Generator[G_EAST].Power[4] - Generator[G_EAST].Power[3] : Generator[G_EAST].RampLimit : True + Key : Lower : Body : Upper : Active + 1 : -50.0 : Generator[G_EAST].Power[1] - Generator[G_EAST].Power[0] : 50.0 : True + 2 : -50.0 : Generator[G_EAST].Power[2] - Generator[G_EAST].Power[1] : 50.0 : True + 3 : -50.0 : Generator[G_EAST].Power[3] - Generator[G_EAST].Power[2] : 50.0 : True + 4 : -50.0 : Generator[G_EAST].Power[4] - Generator[G_EAST].Power[3] : 50.0 : True 7 Declarations: MaxPower RampLimit Power UnitOn limit_ramp CostCoef Cost Generator[G_MAIN] : Active=True @@ -67,11 +67,11 @@ 2 Var Declarations Power : Size=5, Index=TIME Key : Lower : Value : Upper : Fixed : Stale : Domain - 0 : 0 : 120.0 : 500.0 : False : False : Reals - 1 : 0 : 145.0 : 500.0 : False : False : Reals - 2 : 0 : 119.0 : 500.0 : False : False : Reals - 3 : 0 : 42.0 : 500.0 : False : False : Reals - 4 : 0 : 190.0 : 500.0 : False : False : Reals + 0 : 0 : 120.0 : 500 : False : False : Reals + 1 : 0 : 145.0 : 500 : False : False : Reals + 2 : 0 : 119.0 : 500 : False : False : Reals + 3 : 0 : 42.0 : 500 : False : False : Reals + 4 : 0 : 190.0 : 500 : False : False : Reals UnitOn : Size=5, Index=TIME Key : Lower : Value : Upper : Fixed : Stale : Domain 0 : 0 : None : 1 : False : True : Binary @@ -91,11 +91,11 @@ 1 Constraint Declarations limit_ramp : Size=4, Index=TIME, Active=True - Key : Lower : Body : Upper : Active - 1 : -50.0 : Generator[G_MAIN].Power[1] - Generator[G_MAIN].Power[0] : Generator[G_MAIN].RampLimit : True - 2 : -50.0 : Generator[G_MAIN].Power[2] - Generator[G_MAIN].Power[1] : Generator[G_MAIN].RampLimit : True - 3 : -50.0 : Generator[G_MAIN].Power[3] - Generator[G_MAIN].Power[2] : Generator[G_MAIN].RampLimit : True - 4 : -50.0 : Generator[G_MAIN].Power[4] - Generator[G_MAIN].Power[3] : Generator[G_MAIN].RampLimit : True + Key : Lower : Body : Upper : Active + 1 : -50.0 : Generator[G_MAIN].Power[1] - Generator[G_MAIN].Power[0] : 50.0 : True + 2 : -50.0 : Generator[G_MAIN].Power[2] - Generator[G_MAIN].Power[1] : 50.0 : True + 3 : -50.0 : Generator[G_MAIN].Power[3] - Generator[G_MAIN].Power[2] : 50.0 : True + 4 : -50.0 : Generator[G_MAIN].Power[4] - Generator[G_MAIN].Power[3] : 50.0 : True 7 Declarations: MaxPower RampLimit Power UnitOn limit_ramp CostCoef Cost @@ -124,11 +124,11 @@ 2 Var Declarations Power : Size=5, Index=TIME Key : Lower : Value : Upper : Fixed : Stale : Domain - 0 : 0 : 120.0 : 500.0 : False : False : Reals - 1 : 0 : 145.0 : 500.0 : False : False : Reals - 2 : 0 : 119.0 : 500.0 : False : False : Reals - 3 : 0 : 42.0 : 500.0 : False : False : Reals - 4 : 0 : 190.0 : 500.0 : False : False : Reals + 0 : 0 : 120.0 : 500 : False : False : Reals + 1 : 0 : 145.0 : 500 : False : False : Reals + 2 : 0 : 119.0 : 500 : False : False : Reals + 3 : 0 : 42.0 : 500 : False : False : Reals + 4 : 0 : 190.0 : 500 : False : False : Reals UnitOn : Size=5, Index=TIME Key : Lower : Value : Upper : Fixed : Stale : Domain 0 : 0 : None : 1 : False : True : Binary @@ -148,11 +148,11 @@ 1 Constraint Declarations limit_ramp : Size=4, Index=TIME, Active=True - Key : Lower : Body : Upper : Active - 1 : -50.0 : Generator[G_EAST].Power[1] - Generator[G_EAST].Power[0] : Generator[G_EAST].RampLimit : True - 2 : -50.0 : Generator[G_EAST].Power[2] - Generator[G_EAST].Power[1] : Generator[G_EAST].RampLimit : True - 3 : -50.0 : Generator[G_EAST].Power[3] - Generator[G_EAST].Power[2] : Generator[G_EAST].RampLimit : True - 4 : -50.0 : Generator[G_EAST].Power[4] - Generator[G_EAST].Power[3] : Generator[G_EAST].RampLimit : True + Key : Lower : Body : Upper : Active + 1 : -50.0 : Generator[G_EAST].Power[1] - Generator[G_EAST].Power[0] : 50.0 : True + 2 : -50.0 : Generator[G_EAST].Power[2] - Generator[G_EAST].Power[1] : 50.0 : True + 3 : -50.0 : Generator[G_EAST].Power[3] - Generator[G_EAST].Power[2] : 50.0 : True + 4 : -50.0 : Generator[G_EAST].Power[4] - Generator[G_EAST].Power[3] : 50.0 : True 7 Declarations: MaxPower RampLimit Power UnitOn limit_ramp CostCoef Cost Generator[G_MAIN] : Active=True @@ -169,11 +169,11 @@ 2 Var Declarations Power : Size=5, Index=TIME Key : Lower : Value : Upper : Fixed : Stale : Domain - 0 : 0 : 120.0 : 500.0 : False : False : Reals - 1 : 0 : 145.0 : 500.0 : False : False : Reals - 2 : 0 : 119.0 : 500.0 : False : False : Reals - 3 : 0 : 42.0 : 500.0 : False : False : Reals - 4 : 0 : 190.0 : 500.0 : False : False : Reals + 0 : 0 : 120.0 : 500 : False : False : Reals + 1 : 0 : 145.0 : 500 : False : False : Reals + 2 : 0 : 119.0 : 500 : False : False : Reals + 3 : 0 : 42.0 : 500 : False : False : Reals + 4 : 0 : 190.0 : 500 : False : False : Reals UnitOn : Size=5, Index=TIME Key : Lower : Value : Upper : Fixed : Stale : Domain 0 : 0 : None : 1 : False : True : Binary @@ -193,11 +193,11 @@ 1 Constraint Declarations limit_ramp : Size=4, Index=TIME, Active=True - Key : Lower : Body : Upper : Active - 1 : -50.0 : Generator[G_MAIN].Power[1] - Generator[G_MAIN].Power[0] : Generator[G_MAIN].RampLimit : True - 2 : -50.0 : Generator[G_MAIN].Power[2] - Generator[G_MAIN].Power[1] : Generator[G_MAIN].RampLimit : True - 3 : -50.0 : Generator[G_MAIN].Power[3] - Generator[G_MAIN].Power[2] : Generator[G_MAIN].RampLimit : True - 4 : -50.0 : Generator[G_MAIN].Power[4] - Generator[G_MAIN].Power[3] : Generator[G_MAIN].RampLimit : True + Key : Lower : Body : Upper : Active + 1 : -50.0 : Generator[G_MAIN].Power[1] - Generator[G_MAIN].Power[0] : 50.0 : True + 2 : -50.0 : Generator[G_MAIN].Power[2] - Generator[G_MAIN].Power[1] : 50.0 : True + 3 : -50.0 : Generator[G_MAIN].Power[3] - Generator[G_MAIN].Power[2] : 50.0 : True + 4 : -50.0 : Generator[G_MAIN].Power[4] - Generator[G_MAIN].Power[3] : 50.0 : True 7 Declarations: MaxPower RampLimit Power UnitOn limit_ramp CostCoef Cost diff --git a/pyomo/core/base/constraint.py b/pyomo/core/base/constraint.py index bbd5f1e9c31..528d42c2281 100644 --- a/pyomo/core/base/constraint.py +++ b/pyomo/core/base/constraint.py @@ -37,7 +37,10 @@ RangedExpression, ) from pyomo.core.expr.expr_common import _type_check_exception_arg -from pyomo.core.expr.relational_expr import TrivialRelationalExpression +from pyomo.core.expr.relational_expr import ( + TrivialRelationalExpression, + tuple_to_relational_expr, +) from pyomo.core.expr.template_expr import templatize_constraint from pyomo.core.base.component import ActiveComponentData, ModelComponentFactory from pyomo.core.base.global_set import UnindexedComponent_index @@ -355,10 +358,24 @@ def equality(self): if expr.__class__ is EqualityExpression: return True elif expr.__class__ is RangedExpression: - # TODO: this is a very restrictive form of structural equality. lb = expr.arg(0) - if lb is not None and lb is expr.arg(2): - return True + if lb is not None: + # Note that checking native_types is sufficient: + # constant expressions should have already been + # simplified by the expression system. If the user + # explicitly created relational expressions with + # constant arguments, then we assume they knew what they + # were doing. + if lb.__class__ in native_types: + ub = expr.arg(2) + if ub.__class__ in native_types: + return lb == ub + else: + # TBD: this is a very restrictive form of structural + # equality. In the future it might be "nice" to + # look for mathematical equivalence - but that is + # expensive and likely not worth the effort. + return lb is expr.arg(2) return False @property @@ -401,61 +418,15 @@ def set_value(self, expr): "using '<=', '>=', or '=='." % (self.name,) ) self._expr = expr - return elif expr.__class__ is tuple: # or expr_type is list: - for arg in expr: - if ( - arg is None - or arg.__class__ in native_numeric_types - or isinstance(arg, NumericValue) - ): - continue - raise ValueError( - "Constraint '%s' does not have a proper value. " - "Constraint expressions expressed as tuples must " - "contain native numeric types or Pyomo NumericValue " - "objects. Tuple %s contained invalid type, %s" - % (self.name, expr, type(arg).__name__) - ) - if len(expr) == 2: - # - # Form equality expression - # - if expr[0] is None or expr[1] is None: - raise ValueError( - "Constraint '%s' does not have a proper value. " - "Equality Constraints expressed as 2-tuples " - "cannot contain None [received %s]" % (self.name, expr) - ) - self._expr = EqualityExpression(expr) - return - elif len(expr) == 3: - # - # Form (ranged) inequality expression - # - if expr[0] is None: - self._expr = InequalityExpression(expr[1:], False) - elif expr[2] is None: - self._expr = InequalityExpression(expr[:2], False) - else: - self._expr = RangedExpression(expr, False) - return - else: - raise ValueError( - "Constraint '%s' does not have a proper value. " - "Found a tuple of length %d. Expecting a tuple of " - "length 2 or 3:\n" - " Equality: (left, right)\n" - " Inequality: (lower, expression, upper)" - % (self.name, len(expr)) - ) - # - # Ignore an 'empty' constraint - # - if expr is Constraint.Skip: + self.set_value(tuple_to_relational_expr(expr)) + + elif expr is Constraint.Skip: + # + # Ignore (and remove) an 'empty' constraint + # del self.parent_component()[self.index()] - return elif expr is None: raise ValueError(_rule_returned_none_error % (self.name,)) @@ -478,14 +449,14 @@ def set_value(self, expr): except AttributeError: pass - raise ValueError( - "Constraint '%s' does not have a proper " - "value. Found %s '%s'\nExpecting a tuple or " - "relational expression. Examples:" - "\n sum(model.costs) == model.income" - "\n (0, model.price[item], 50)" - % (self.name, type(expr).__name__, str(expr)) - ) + raise ValueError( + "Constraint '%s' does not have a proper " + "value. Found %s '%s'\nExpecting a tuple or " + "relational expression. Examples:" + "\n sum(model.costs) == model.income" + "\n (0, model.price[item], 50)" + % (self.name, type(expr).__name__, str(expr)) + ) def lslack(self): """ diff --git a/pyomo/core/expr/relational_expr.py b/pyomo/core/expr/relational_expr.py index d4726a4f5b3..521944c39c3 100644 --- a/pyomo/core/expr/relational_expr.py +++ b/pyomo/core/expr/relational_expr.py @@ -340,52 +340,116 @@ def _to_string(self, values, verbose, smap): def inequality(lower=None, body=None, upper=None, strict=False): - """ - A utility function that can be used to declare inequality and - ranged inequality expressions. The expression:: + r"""A utility function that can be used to declare inequality and + ranged inequality expressions. + + The expression:: inequality(2, model.x) - is equivalent to the expression:: + is equivalent to: - 2 <= model.x + .. math:: - The expression:: + 2 \leq x + + and the expression:: inequality(2, model.x, 3) - is equivalent to the expression:: + is equivalent to: - 2 <= model.x <= 3 + .. math:: - .. note:: This ranged inequality syntax is deprecated in Pyomo. - This function provides a mechanism for expressing - ranged inequalities without chained inequalities. + 2 \leq x \leq 3 + + .. note:: Pyomo does not support constructing + :class:`RangedExpression` objects using Python's chained + comparison syntax (``lb <= body <= ub``). + + Python relies on the pairwise comparisons returning intermediates + that are convertible to :class:`bool`, which is incompatible with + Pyomo's operator overloading. Instead, :class:`RangedExpression` + objects should be created using this function. + + :func:`inequality` allows for any (or all) of `lower`, `body`, and + `upper` to be ``None``. What gets returned from the function + depends on the number and type of values provided: + + No arguments are ``None`` + If `lower`, `body`, and `upper` are all non-``None``, then the + function will return a :class:`RangedExpression`, unless two + adjacent arguments (either `lower` and `body`, or `body` and + `upper`) are both constants (e.g., native numeric types or + immutable :class:`Param` objects). If there are two adjacent + constant values, then that pair is evaluated. If the result is + ``False``, then the constraint is known to be trivially + infeasible and :func:`inequality` will return ``False``. If the + result is ``True``, then the return value is as if the "outer" + (`lower` or `upper`) argument had been ``None`` (see the following). + + One argument is ``None`` + If one of `lower`, `body`, or `upper` is ``None``, then + :func:`inequality` will return an :class:`InequalityExpression` + object, unless both arguments are constants (e.g., native numeric + types or immutable :class:`Param` objects), in which case the + expression will be evaluated and the resulting :class:`bool` + returned. + + Two arguments are ``None`` + If two of `lower`, `body`, or `upper` are ``None``, then the + remaining argument is returned from :func:`inequality`. + + All None + If all arguments are ``None``, then ``None`` is returned + + + Parameters + ---------- + + lower : int | float | NumericValue | None + The expression for the lower bound + + body : int | float | NumericValue | None + The expression for the body of a ranged constraint + + upper : int | float | NumericValue | None + The expression for the upper bound + + strict : bool + If ``True``, construct strict inequalities (``<``); otherwise + use ``<=``. + + Returns + ------- + RangedExpression | InequalityExpression | NumericValue | int | float | None - args: - lower: an expression defines a lower bound - body: an expression defines the body of a ranged constraint - upper: an expression defines an upper bound - strict (bool): A boolean value that indicates whether the inequality - is strict. Default is :const:`False`. - - Returns: - A relational expression. The expression is an inequality - if any of the values :attr:`lower`, :attr:`body` or - :attr:`upper` is :const:`None`. Otherwise, the expression - is a ranged inequality. """ - if lower is None: - if body is None or upper is None: - raise ValueError("Invalid inequality expression.") - return InequalityExpression((body, upper), strict) + _genexpr = _lt_dispatcher if strict else _le_dispatcher if body is None: - if lower is None or upper is None: - raise ValueError("Invalid inequality expression.") - return InequalityExpression((lower, upper), strict) - if upper is None: - return InequalityExpression((lower, body), strict) - return RangedExpression((lower, body, upper), strict) + lower, body = body, lower + expr = body + if lower is not None: + expr = _genexpr[lower.__class__, body.__class__](lower, body) + # If the LHS of the ranged inequality evaluated to a bool, we + # need to do some special processing: + # - False: the LHS is trivially infeasible. Return False. + # - True: the LHS is trivially feasible. Leave body unchanged + # so that it can be compared to the RHS + # + # ...otherwise, "replace" body with the resulting inequality and + # then process the RHS + if expr.__class__ is bool: + if not expr: + return False + else: + body = expr + if upper is not None: + if body is not None: + expr = _genexpr[body.__class__, upper.__class__](body, upper) + else: + expr = upper + return expr class EqualityExpression(RelationalExpression): @@ -442,10 +506,24 @@ def _to_string(self, values, verbose, smap): def tuple_to_relational_expr(args): - if len(args) == 2: - return EqualityExpression(args) - else: - return inequality(*args) + if len(args) == 3: + return inequality(*args, strict=False) + elif len(args) == 2: + lhs, rhs = args + ans = _eq_dispatcher[lhs.__class__, rhs.__class__](lhs, rhs) + if ans is NotImplemented: + raise ValueError( + "Cannot create EqualityExpression from argument types " + f"'{type(lhs).__name__}' and '{type(rhs).__name__}'" + ) + return ans + raise ValueError( + "Cannot convert tuple to relational expression. " + f"Found a tuple of length {len(args)}. Expecting a tuple of " + "length 2 or 3:\n" + " Equality: (left, right)\n" + " Inequality: (lower, expression, upper)" + ) def _invalid_relational(op_type, op_str, a, b): @@ -579,9 +657,28 @@ def _le_expr_ineq(a, b): return RangedExpression((a,) + b.args, (False, b._strict)) +def _le_native_ineq(a, b): + b0, b1 = b.args + lhs = _le_dispatcher[a.__class__, b0.__class__](a, b0) + if lhs.__class__ is InequalityExpression: + bounds = (_lt_dispatcher if b.strict else _le_dispatcher)[ + a.__class__, b1.__class__ + ](a, b1) + if bounds.__class__ is bool and not bounds: + # Trivial infeasible bounds + return False + return RangedExpression((a, b0, b1), (False, b._strict)) + elif lhs: + # Trivial (feasible) LHS + return b + else: + # Trivial infeasible LHS + return False + + def _le_param_ineq(a, b): if a.is_constant(): - a = a.value + return _le_native_ineq(a.value, b) return RangedExpression((a,) + b.args, (False, b._strict)) @@ -589,9 +686,28 @@ def _le_ineq_expr(a, b): return RangedExpression(a.args + (b,), (a._strict, False)) +def _le_ineq_native(a, b): + a0, a1 = a.args + rhs = _le_dispatcher[a1.__class__, b.__class__](a1, b) + if rhs.__class__ is InequalityExpression: + bounds = (_lt_dispatcher if a.strict else _le_dispatcher)[ + a0.__class__, b.__class__ + ](a0, b) + if bounds.__class__ is bool and not bounds: + # Trivial infeasible bounds + return False + return RangedExpression((a0, a1, b), (a._strict, False)) + elif rhs: + # Trivial (feasible) RHS + return a + else: + # Trivial infeasible RHS + return False + + def _le_ineq_param(a, b): if b.is_constant(): - b = b.value + return _le_ineq_native(a, b.value) return RangedExpression(a.args + (b,), (a._strict, False)) @@ -634,7 +750,7 @@ def _register_new_le_handler(a, b): (ARG_TYPE.NATIVE, ARG_TYPE.NATIVE): _le_native, (ARG_TYPE.NATIVE, ARG_TYPE.PARAM): _le_any_param, (ARG_TYPE.NATIVE, ARG_TYPE.OTHER): _le_expr, - (ARG_TYPE.NATIVE, ARG_TYPE.INEQUALITY): _le_expr_ineq, + (ARG_TYPE.NATIVE, ARG_TYPE.INEQUALITY): _le_native_ineq, (ARG_TYPE.NATIVE, ARG_TYPE.INVALID_RELATIONAL): _le_invalid, (ARG_TYPE.PARAM, ARG_TYPE.NATIVE): _le_param_any, (ARG_TYPE.PARAM, ARG_TYPE.PARAM): _le_param_param, @@ -646,7 +762,7 @@ def _register_new_le_handler(a, b): (ARG_TYPE.OTHER, ARG_TYPE.OTHER): _le_expr, (ARG_TYPE.OTHER, ARG_TYPE.INEQUALITY): _le_expr_ineq, (ARG_TYPE.OTHER, ARG_TYPE.INVALID_RELATIONAL): _le_invalid, - (ARG_TYPE.INEQUALITY, ARG_TYPE.NATIVE): _le_ineq_expr, + (ARG_TYPE.INEQUALITY, ARG_TYPE.NATIVE): _le_ineq_native, (ARG_TYPE.INEQUALITY, ARG_TYPE.PARAM): _le_ineq_param, (ARG_TYPE.INEQUALITY, ARG_TYPE.OTHER): _le_ineq_expr, (ARG_TYPE.INEQUALITY, ARG_TYPE.INEQUALITY): _le_invalid, @@ -677,9 +793,26 @@ def _lt_expr_ineq(a, b): return RangedExpression((a,) + b.args, (True, b._strict)) +def _lt_native_ineq(a, b): + b0, b1 = b.args + lhs = _lt_dispatcher[a.__class__, b0.__class__](a, b0) + if lhs.__class__ is InequalityExpression: + bounds = _lt_dispatcher[a.__class__, b1.__class__](a, b1) + if bounds.__class__ is bool and not bounds: + # Trivial infeasible bounds + return False + return RangedExpression((a, b0, b1), (True, b._strict)) + elif lhs: + # Trivial (feasible) LHS + return b + else: + # Trivial infeasible LHS + return False + + def _lt_param_ineq(a, b): if a.is_constant(): - a = a.value + return _lt_native_ineq(a.value, b) return RangedExpression((a,) + b.args, (True, b._strict)) @@ -687,9 +820,26 @@ def _lt_ineq_expr(a, b): return RangedExpression(a.args + (b,), (a._strict, True)) +def _lt_ineq_native(a, b): + a0, a1 = a.args + rhs = _lt_dispatcher[a1.__class__, b.__class__](a1, b) + if rhs.__class__ is InequalityExpression: + bounds = _lt_dispatcher[a0.__class__, b.__class__](a0, b) + if bounds.__class__ is bool and not bounds: + # Trivial infeasible bounds + return False + return RangedExpression((a0, a1, b), (a._strict, True)) + elif rhs: + # Trivial (feasible) RHS + return a + else: + # Trivial infeasible RHS + return False + + def _lt_ineq_param(a, b): if b.is_constant(): - b = b.value + return _lt_ineq_native(a, b.value) return RangedExpression(a.args + (b,), (a._strict, True)) @@ -732,7 +882,7 @@ def _register_new_lt_handler(a, b): (ARG_TYPE.NATIVE, ARG_TYPE.NATIVE): _lt_native, (ARG_TYPE.NATIVE, ARG_TYPE.PARAM): _lt_any_param, (ARG_TYPE.NATIVE, ARG_TYPE.OTHER): _lt_expr, - (ARG_TYPE.NATIVE, ARG_TYPE.INEQUALITY): _lt_expr_ineq, + (ARG_TYPE.NATIVE, ARG_TYPE.INEQUALITY): _lt_native_ineq, (ARG_TYPE.NATIVE, ARG_TYPE.INVALID_RELATIONAL): _lt_invalid, (ARG_TYPE.PARAM, ARG_TYPE.NATIVE): _lt_param_any, (ARG_TYPE.PARAM, ARG_TYPE.PARAM): _lt_param_param, @@ -744,7 +894,7 @@ def _register_new_lt_handler(a, b): (ARG_TYPE.OTHER, ARG_TYPE.OTHER): _lt_expr, (ARG_TYPE.OTHER, ARG_TYPE.INEQUALITY): _lt_expr_ineq, (ARG_TYPE.OTHER, ARG_TYPE.INVALID_RELATIONAL): _lt_invalid, - (ARG_TYPE.INEQUALITY, ARG_TYPE.NATIVE): _lt_ineq_expr, + (ARG_TYPE.INEQUALITY, ARG_TYPE.NATIVE): _lt_ineq_native, (ARG_TYPE.INEQUALITY, ARG_TYPE.PARAM): _lt_ineq_param, (ARG_TYPE.INEQUALITY, ARG_TYPE.OTHER): _lt_ineq_expr, (ARG_TYPE.INEQUALITY, ARG_TYPE.INEQUALITY): _lt_invalid, diff --git a/pyomo/core/plugins/transform/nonnegative_transform.py b/pyomo/core/plugins/transform/nonnegative_transform.py index e33b8e871eb..7a16467ae57 100644 --- a/pyomo/core/plugins/transform/nonnegative_transform.py +++ b/pyomo/core/plugins/transform/nonnegative_transform.py @@ -433,6 +433,8 @@ def boundsConstraintRule(lb, ub, attr, vars, model): and so attr='X', and 1 is a key of vars. """ + if lb is None and ub is None: + return Constraint.Skip return ( lb, sum(c * model.__getattribute__(attr)[v] for (v, c) in vars.items()), diff --git a/pyomo/core/tests/transform/test_add_slacks.py b/pyomo/core/tests/transform/test_add_slacks.py index bd089dd3735..2390add94cb 100644 --- a/pyomo/core/tests/transform/test_add_slacks.py +++ b/pyomo/core/tests/transform/test_add_slacks.py @@ -183,7 +183,10 @@ def test_new_obj_created(self): def test_badModel_err(self): model = ConcreteModel() model.x = Var(within=NonNegativeReals) - model.rule1 = Constraint(expr=inequality(6, model.x, 5)) + model.p = Param(initialize=5, mutable=True) + # Note: use a mutable param so expression generation doesn't + # immediately recognize the infeasibility + model.rule1 = Constraint(expr=inequality(6, model.x, model.p)) self.assertRaisesRegex( RuntimeError, "Lower bound exceeds upper bound in constraint rule1*", diff --git a/pyomo/core/tests/unit/test_con.py b/pyomo/core/tests/unit/test_con.py index 6c92aa63f54..71fec6039f1 100644 --- a/pyomo/core/tests/unit/test_con.py +++ b/pyomo/core/tests/unit/test_con.py @@ -190,15 +190,28 @@ def rule(model): def test_tuple_construct_unbounded_inequality(self): model = self.create_model() + # Note: inequality with only a single non-None returns the non-None value + def rule(model): return (None, model.y, None) - model.c = Constraint(rule=rule) + with self.assertRaisesRegex( + ValueError, + "Constraint 'c' does not have a proper value. Found ScalarVar 'y'", + ): + model.c = Constraint(rule=rule) - self.assertEqual(model.c.equality, False) - self.assertEqual(model.c.lower, None) - self.assertIs(model.c.body, model.y) - self.assertEqual(model.c.upper, None) + with self.assertRaisesRegex( + ValueError, + "Constraint 'c' does not have a proper value. Found ScalarVar 'y'", + ): + model.c = (model.y, None, None) + + with self.assertRaisesRegex( + ValueError, + "Constraint 'c' does not have a proper value. Found ScalarVar 'y'", + ): + model.c = (None, None, model.y) model = self.create_model() @@ -254,6 +267,44 @@ def rule(model): self.assertIs(model.c.body, model.y) self.assertEqual(model.c.upper, 1) + def rule(model): + return (float(0), model.y, float(0)) + + model.d = Constraint(rule=rule) + + self.assertEqual(model.d.equality, True) + self.assertEqual(model.d.lower, 0) + self.assertIs(model.d.body, model.y) + self.assertEqual(model.d.upper, 0) + + model.p = Param(mutable=True) + e = model.p * 2 + 1 + + def rule(model): + return (e, model.y, e) + + model.e = Constraint(rule=rule) + + self.assertEqual(model.e.equality, True) + self.assertIs(model.e.lower, e) + self.assertIs(model.e.body, model.y) + self.assertIs(model.e.upper, e) + + # + # Note: because we do not test for symbolic equivalence, the + # following will be seen as a ranged inequality and not an + # equality: + # + def rule(model): + return (e, model.y, model.p * 2 + 1) + + model.f = Constraint(rule=rule) + + self.assertEqual(model.f.equality, False) + self.assertIs(model.f.lower, e) + self.assertIs(model.f.body, model.y) + self.assertIsNot(model.f.upper, e) + def test_tuple_construct_invalid_2sided_inequality(self): model = self.create_model(abstract=True) @@ -1374,16 +1425,24 @@ def f(model): class MiscConTests(unittest.TestCase): def test_infeasible(self): m = ConcreteModel() + m.x = Var() m.c = Constraint(expr=Constraint.Infeasible) self.assertIn(None, m.c._data) self.assertEqual(m.c.lb, None) self.assertEqual(m.c.body, 1) self.assertEqual(m.c.ub, 0) - m.c = (0, 1, 2) + with self.assertRaisesRegex( + ValueError, + "Invalid constraint expression. The constraint expression resolved " + r"to a trivial Boolean \(True\) instead of a Pyomo object.", + ): + m.c = (0, 1, 2) + + m.c = (0, m.x, 2) self.assertIn(None, m.c._data) self.assertEqual(m.c.lb, 0) - self.assertEqual(m.c.body, 1) + self.assertEqual(m.c.body, m.x) self.assertEqual(m.c.ub, 2) m.c = Constraint.Infeasible @@ -1394,16 +1453,24 @@ def test_infeasible(self): def test_feasible(self): m = ConcreteModel() + m.x = Var() m.c = Constraint(expr=Constraint.Feasible) self.assertIn(None, m.c._data) self.assertEqual(m.c.lb, None) self.assertEqual(m.c.body, 0) self.assertEqual(m.c.ub, 0) - m.c = (0, 1, 2) + with self.assertRaisesRegex( + ValueError, + "Invalid constraint expression. The constraint expression resolved " + r"to a trivial Boolean \(True\) instead of a Pyomo object.", + ): + m.c = (0, 1, 2) + + m.c = (0, m.x, 2) self.assertIn(None, m.c._data) self.assertEqual(m.c.lb, 0) - self.assertEqual(m.c.body, 1) + self.assertEqual(m.c.body, m.x) self.assertEqual(m.c.ub, 2) m.c = Constraint.Feasible @@ -1806,7 +1873,11 @@ def rule1(model): model.x = Var() model.L = Param(initialize=0) model.U = Param(initialize=1) - model.o = Constraint(rule=rule1) + with self.assertRaisesRegex( + ValueError, + r"The constraint expression resolved to a trivial Boolean \(False\)", + ): + model.o = Constraint(rule=rule1) # def rule1(model): @@ -2019,9 +2090,8 @@ def test_tuple_expression(self): with self.assertRaisesRegex( ValueError, - "Constraint 'c' does not have a proper value. " - "Equality Constraints expressed as 2-tuples cannot " - "contain None", + "Cannot create EqualityExpression from argument types " + "'ScalarVar' and 'NoneType'", ): m.c = (m.x, None) diff --git a/pyomo/core/tests/unit/test_relational_expr.py b/pyomo/core/tests/unit/test_relational_expr.py index 2497ae0a246..5164068eb7f 100644 --- a/pyomo/core/tests/unit/test_relational_expr.py +++ b/pyomo/core/tests/unit/test_relational_expr.py @@ -197,17 +197,11 @@ def test_simpleInequality2(self): # self.assertEqual(len(e._strict), 1) self.assertEqual(e._strict, False) - try: - inequality(None, None) - self.fail("expected invalid inequality error.") - except ValueError: - pass - - try: - inequality(m.a, None) - self.fail("expected invalid inequality error.") - except ValueError: - pass + # Trivial cases that do not result in inequalities... + self.assertEqual(inequality(m.a, None, None), m.a) + self.assertEqual(inequality(None, m.a, None), m.a) + self.assertEqual(inequality(None, None, m.a), m.a) + self.assertEqual(inequality(None, None, None), None) class TestGenerate_RangedExpression(unittest.TestCase): @@ -230,7 +224,7 @@ def test_compoundInequality(self): # < c # / \ # a b - e = inequality(m.a, m.b, m.c, strict=True) + e = (m.a < m.b) < m.c self.assertIs(type(e), RangedExpression) self.assertEqual(e.nargs(), 3) self.assertIs(e.arg(0), m.a) @@ -245,7 +239,7 @@ def test_compoundInequality(self): # <= c # / \ # a b - e = inequality(m.a, m.b, m.c) + e = (m.a <= m.b) <= m.c self.assertIs(type(e), RangedExpression) self.assertEqual(e.nargs(), 3) self.assertIs(e.arg(0), m.a) @@ -260,37 +254,29 @@ def test_compoundInequality(self): # > c # / \ # a b - e = inequality(upper=m.c, body=m.b, lower=m.a, strict=True) + e = (m.a > m.b) > m.c self.assertIs(type(e), RangedExpression) self.assertEqual(e.nargs(), 3) - self.assertIs(e.arg(2), m.c) - self.assertIs(e.arg(1), m.b) - self.assertIs(e.arg(0), m.a) - # self.assertEqual(len(e._strict), 2) - self.assertEqual(e._strict[0], True) - self.assertEqual(e._strict[1], True) + self.assertEqual(e.args, (m.c, m.b, m.a)) + self.assertEqual(e.strict, (True, True)) # >= # / \ # >= c # / \ # a b - e = inequality(upper=m.c, body=m.b, lower=m.a) + e = (m.a >= m.b) >= m.c self.assertIs(type(e), RangedExpression) self.assertEqual(e.nargs(), 3) - self.assertIs(e.arg(2), m.c) - self.assertIs(e.arg(1), m.b) - self.assertIs(e.arg(0), m.a) - # self.assertEqual(len(e._strict), 2) - self.assertEqual(e._strict[0], False) - self.assertEqual(e._strict[1], False) + self.assertEqual(e.args, (m.c, m.b, m.a)) + self.assertEqual(e.strict, (False, False)) # <= # / \ # <= 0 # / \ # 0 a - e = inequality(0, m.a, 0) + e = (0 <= m.a) <= 0 self.assertIs(type(e), RangedExpression) self.assertEqual(e.nargs(), 3) self.assertIs(e.arg(2), 0) @@ -305,15 +291,126 @@ def test_compoundInequality(self): # < 0 # / \ # 0 a - e = inequality(0, m.a, 0, True) + e = (0 < m.a) < 0 + self.assertIs(e, False) + + def test_inequality_fcn(self): + m = self.m + + self.assertEqual(inequality(None, None, None), None) + + self.assertEqual(inequality(0, None, None), 0) + self.assertEqual(inequality(None, 0, None), 0) + self.assertEqual(inequality(None, None, 0), 0) + + self.assertEqual(inequality(m.a, None, None), m.a) + self.assertEqual(inequality(None, m.a, None), m.a) + self.assertEqual(inequality(None, None, m.a), m.a) + + self.assertEqual(inequality(None, 0, 0), True) + self.assertEqual(inequality(0, None, 0), True) + self.assertEqual(inequality(0, 0, None), True) + self.assertEqual(inequality(None, 0, 1), True) + self.assertEqual(inequality(0, None, 1), True) + self.assertEqual(inequality(0, 1, None), True) + self.assertEqual(inequality(None, 1, 0), False) + self.assertEqual(inequality(1, None, 0), False) + self.assertEqual(inequality(1, 0, None), False) + + self.assertEqual(inequality(0, 0, 0), True) + self.assertEqual(inequality(0, 1, 2), True) + + e = inequality(m.a, 0, 1) + self.assertIs(type(e), InequalityExpression) + self.assertEqual(e.args, (m.a, 0)) + self.assertEqual(e.strict, False) + + e = inequality(0, m.a, 1) self.assertIs(type(e), RangedExpression) - self.assertEqual(e.nargs(), 3) - self.assertIs(e.arg(2), 0) - self.assertIs(e.arg(1), m.a) - self.assertIs(e.arg(0), 0) - # self.assertEqual(len(e._strict), 2) - self.assertEqual(e._strict[0], True) - self.assertEqual(e._strict[1], True) + self.assertEqual(e.args, (0, m.a, 1)) + self.assertEqual(e.strict, (False, False)) + + e = inequality(0, 1, m.a) + self.assertIs(type(e), InequalityExpression) + self.assertEqual(e.args, (1, m.a)) + self.assertEqual(e.strict, False) + + e = inequality(m.a, 0, 0) + self.assertIs(type(e), InequalityExpression) + self.assertEqual(e.args, (m.a, 0)) + self.assertEqual(e.strict, False) + + e = inequality(0, m.a, 0) + self.assertIs(type(e), RangedExpression) + self.assertEqual(e.args, (0, m.a, 0)) + self.assertEqual(e.strict, (False, False)) + + e = inequality(0, 0, m.a) + self.assertIs(type(e), InequalityExpression) + self.assertEqual(e.args, (0, m.a)) + self.assertEqual(e.strict, False) + + self.assertEqual(inequality(m.a, 1, 0), False) + self.assertEqual(inequality(1, m.a, 0), False) + self.assertEqual(inequality(1, 0, m.a), False) + + e = inequality(m.a, m.b, m.c) + self.assertIs(type(e), RangedExpression) + self.assertEqual(e.args, (m.a, m.b, m.c)) + self.assertEqual(e.strict, (False, False)) + + def test_strict_inequality_fcn(self): + m = self.m + + self.assertEqual(inequality(None, None, None, True), None) + + self.assertEqual(inequality(0, None, None, True), 0) + self.assertEqual(inequality(None, 0, None, True), 0) + self.assertEqual(inequality(None, None, 0, True), 0) + + self.assertEqual(inequality(m.a, None, None, True), m.a) + self.assertEqual(inequality(None, m.a, None, True), m.a) + self.assertEqual(inequality(None, None, m.a, True), m.a) + + self.assertEqual(inequality(None, 0, 0, True), False) + self.assertEqual(inequality(0, None, 0, True), False) + self.assertEqual(inequality(0, 0, None, True), False) + self.assertEqual(inequality(None, 0, 1, True), True) + self.assertEqual(inequality(0, None, 1, True), True) + self.assertEqual(inequality(0, 1, None, True), True) + self.assertEqual(inequality(None, 1, 0, True), False) + self.assertEqual(inequality(1, None, 0, True), False) + self.assertEqual(inequality(1, 0, None, True), False) + + self.assertEqual(inequality(0, 0, 0, True), False) + self.assertEqual(inequality(0, 1, 2, True), True) + + e = inequality(m.a, 0, 1, True) + self.assertIs(type(e), InequalityExpression) + self.assertEqual(e.args, (m.a, 0)) + self.assertEqual(e.strict, True) + + e = inequality(0, m.a, 1, True) + self.assertIs(type(e), RangedExpression) + self.assertEqual(e.args, (0, m.a, 1)) + self.assertEqual(e.strict, (True, True)) + + e = inequality(0, 1, m.a, True) + self.assertIs(type(e), InequalityExpression) + self.assertEqual(e.args, (1, m.a)) + self.assertEqual(e.strict, True) + + self.assertEqual(inequality(m.a, 0, 0, True), False) + self.assertEqual(inequality(0, m.a, 0, True), False) + self.assertEqual(inequality(0, 0, m.a, True), False) + self.assertEqual(inequality(m.a, 1, 0, True), False) + self.assertEqual(inequality(1, m.a, 0, True), False) + self.assertEqual(inequality(1, 0, m.a, True), False) + + e = inequality(m.a, m.b, m.c, True) + self.assertIs(type(e), RangedExpression) + self.assertEqual(e.args, (m.a, m.b, m.c)) + self.assertEqual(e.strict, (True, True)) def test_val1(self): m = ConcreteModel() diff --git a/pyomo/core/tests/unit/test_relational_expr_dispatcher.py b/pyomo/core/tests/unit/test_relational_expr_dispatcher.py index 99b85ebe4ce..8028dbdf3f2 100644 --- a/pyomo/core/tests/unit/test_relational_expr_dispatcher.py +++ b/pyomo/core/tests/unit/test_relational_expr_dispatcher.py @@ -27,7 +27,7 @@ class BaseRelational(Base): - NUM_TESTS = 25 + NUM_TESTS = 28 def tearDown(self): pass @@ -62,9 +62,12 @@ def setUp(self): # self.m.d = Disjunct() # self.bin = self.m.d.indicator_var.as_numeric() + self.native2 = 8 self.eq = self.m.x == self.m.q self.le = self.m.x <= self.m.q self.lt = self.m.x < self.m.p + self.le2 = self.m.q <= self.m.x + self.lt2 = self.m.p < self.m.x self.ranged = inequality(self.m.p, self.m.x, self.m.q) # self.TEMPLATE = [ @@ -101,7 +104,11 @@ def setUp(self): self.eq, self.le, self.lt, + # 24: self.ranged, + self.native2, + self.le2, + self.lt2, ] ) @@ -151,6 +158,9 @@ def test_eq_invalid(self): (self.invalid, self.lt, False), # 24: (self.invalid, self.ranged, False), + (self.invalid, self.native2, False), + (self.invalid, self.le2, False), + (self.invalid, self.lt2, False), ] self._run_cases(tests, operator.eq) @@ -212,13 +222,26 @@ def test_eq_asbinary(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.asbinary, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.asbinary, self.native2, EqualityExpression((self.bin, 8))), + ( + self.asbinary, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.asbinary, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -268,13 +291,26 @@ def test_eq_zero(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.zero, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.zero, self.native2, False), + ( + self.zero, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.zero, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -324,13 +360,26 @@ def test_eq_one(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.one, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.one, self.native2, False), + ( + self.one, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.one, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -380,13 +429,26 @@ def test_eq_native(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.native, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.native, self.native2, False), + ( + self.native, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.native, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -440,13 +502,26 @@ def test_eq_npv(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.npv, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.npv, self.native2, EqualityExpression((self.npv, 8))), + ( + self.npv, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.npv, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -496,13 +571,26 @@ def test_eq_param(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.param, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param, self.native2, False), + ( + self.param, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.param, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -596,13 +684,26 @@ def test_eq_param_mut(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.param_mut, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param_mut, self.native2, EqualityExpression((self.param_mut, 8))), + ( + self.param_mut, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.param_mut, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -656,13 +757,26 @@ def test_eq_var(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.var, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.var, self.native2, EqualityExpression((self.var, 8))), + ( + self.var, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.var, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -768,13 +882,26 @@ def test_eq_mon_native(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.mon_native, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mon_native, self.native2, EqualityExpression((self.mon_native, 8))), + ( + self.mon_native, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.mon_native, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -868,13 +995,26 @@ def test_eq_mon_param(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.mon_param, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mon_param, self.native2, EqualityExpression((self.mon_param, 8))), + ( + self.mon_param, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.mon_param, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -960,13 +1100,26 @@ def test_eq_mon_npv(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.mon_npv, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mon_npv, self.native2, EqualityExpression((self.mon_npv, 8))), + ( + self.mon_npv, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.mon_npv, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1032,13 +1185,26 @@ def test_eq_linear(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.linear, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.linear, self.native2, EqualityExpression((self.linear, 8))), + ( + self.linear, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.linear, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1092,13 +1258,26 @@ def test_eq_sum(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.sum, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.sum, self.native2, EqualityExpression((self.sum, 8))), + ( + self.sum, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.sum, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1160,13 +1339,26 @@ def test_eq_other(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.other, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.other, self.native2, EqualityExpression((self.other, 8))), + ( + self.other, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.other, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1232,13 +1424,26 @@ def test_eq_mutable_l0(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.mutable_l0, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l0, self.native2, False), + ( + self.mutable_l0, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.mutable_l0, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1304,13 +1509,26 @@ def test_eq_mutable_l1(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.mutable_l1, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l1, self.native2, EqualityExpression((self.l1, 8))), + ( + self.mutable_l1, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.mutable_l1, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1376,13 +1594,26 @@ def test_eq_mutable_l2(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.mutable_l2, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l2, self.native2, EqualityExpression((self.l2, 8))), + ( + self.mutable_l2, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.mutable_l2, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1432,13 +1663,26 @@ def test_eq_param0(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.param0, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param0, self.native2, False), + ( + self.param0, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.param0, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1488,13 +1732,26 @@ def test_eq_param1(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.param1, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param1, self.native2, False), + ( + self.param1, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.param1, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1560,13 +1817,26 @@ def test_eq_mutable_l3(self): "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), - # 24 + # 24: ( self.mutable_l3, self.ranged, "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l3, self.native2, EqualityExpression((self.l3, 8))), + ( + self.mutable_l3, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.mutable_l3, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] self._run_cases(tests, operator.eq) @@ -1716,13 +1986,31 @@ def test_eq_eq(self): "Cannot create an EqualityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( self.eq, self.ranged, "Cannot create an EqualityExpression where both " "sub-expressions are relational expressions", ), + ( + self.eq, + self.native2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, + self.le2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.eq, + self.lt2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), ] self._run_cases(tests, operator.eq) @@ -1872,13 +2160,31 @@ def test_eq_le(self): "Cannot create an EqualityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( self.le, self.ranged, "Cannot create an EqualityExpression where both " "sub-expressions are relational expressions", ), + ( + self.le, + self.native2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.le, + self.le2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le, + self.lt2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), ] self._run_cases(tests, operator.eq) @@ -2028,16 +2334,34 @@ def test_eq_lt(self): "Cannot create an EqualityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( self.lt, self.ranged, "Cannot create an EqualityExpression where both " "sub-expressions are relational expressions", ), - ] - self._run_cases(tests, operator.eq) - + ( + self.lt, + self.native2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt, + self.le2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt, + self.lt2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ] + self._run_cases(tests, operator.eq) + def test_eq_ranged(self): tests = [ (self.ranged, self.invalid, False), @@ -2184,2563 +2508,3602 @@ def test_eq_ranged(self): "Cannot create an EqualityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: + ( + self.ranged, + self.ranged, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.ranged, + self.native2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ( self.ranged, + self.le2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( self.ranged, + self.lt2, "Cannot create an EqualityExpression where both " "sub-expressions are relational expressions", ), ] self._run_cases(tests, operator.eq) - -# -# -# INEQUALITY (non-strict) -# -# - - -class TestInequality(BaseRelational, unittest.TestCase): - - def test_le_invalid(self): + def test_eq_native2(self): tests = [ - # "invalid(str) == invalid(str)" is a legitimate Python - # operation and should never hit the Pyomo expression - # system - (self.invalid, self.invalid, True), - (self.invalid, self.asbinary, NotImplemented), - (self.invalid, self.zero, NotImplemented), - (self.invalid, self.one, NotImplemented), + (self.native2, self.invalid, False), + (self.native2, self.asbinary, EqualityExpression((self.bin, 8))), + (self.native2, self.zero, False), + (self.native2, self.one, False), # 4: - (self.invalid, self.native, NotImplemented), - (self.invalid, self.npv, NotImplemented), - (self.invalid, self.param, NotImplemented), - (self.invalid, self.param_mut, NotImplemented), + (self.native2, self.native, False), + (self.native2, self.npv, EqualityExpression((self.npv, 8))), + (self.native2, self.param, False), + (self.native2, self.param_mut, EqualityExpression((self.param_mut, 8))), # 8: - (self.invalid, self.var, NotImplemented), - (self.invalid, self.mon_native, NotImplemented), - (self.invalid, self.mon_param, NotImplemented), - (self.invalid, self.mon_npv, NotImplemented), + (self.native2, self.var, EqualityExpression((self.var, 8))), + (self.native2, self.mon_native, EqualityExpression((self.mon_native, 8))), + (self.native2, self.mon_param, EqualityExpression((self.mon_param, 8))), + (self.native2, self.mon_npv, EqualityExpression((self.mon_npv, 8))), # 12: - (self.invalid, self.linear, NotImplemented), - (self.invalid, self.sum, NotImplemented), - (self.invalid, self.other, NotImplemented), - (self.invalid, self.mutable_l0, NotImplemented), + (self.native2, self.linear, EqualityExpression((self.linear, 8))), + (self.native2, self.sum, EqualityExpression((self.sum, 8))), + (self.native2, self.other, EqualityExpression((self.other, 8))), + (self.native2, self.mutable_l0, False), # 16: - (self.invalid, self.mutable_l1, NotImplemented), - (self.invalid, self.mutable_l2, NotImplemented), - (self.invalid, self.param0, NotImplemented), - (self.invalid, self.param1, NotImplemented), + (self.native2, self.mutable_l1, EqualityExpression((self.l1, 8))), + (self.native2, self.mutable_l2, EqualityExpression((self.l2, 8))), + (self.native2, self.param0, False), + (self.native2, self.param1, False), # 20: - (self.invalid, self.mutable_l3, NotImplemented), - (self.invalid, self.eq, NotImplemented), - (self.invalid, self.le, NotImplemented), - (self.invalid, self.lt, NotImplemented), + (self.native2, self.mutable_l3, EqualityExpression((self.l3, 8))), + ( + self.native2, + self.eq, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.native2, + self.le, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.native2, + self.lt, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), # 24: - (self.invalid, self.ranged, NotImplemented), + ( + self.native2, + self.ranged, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + (self.native2, self.native2, True), + ( + self.native2, + self.le2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.native2, + self.lt2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), ] - self._run_cases(tests, operator.le) + self._run_cases(tests, operator.eq) - def test_le_asbinary(self): + def test_eq_le2(self): tests = [ - (self.asbinary, self.invalid, NotImplemented), + (self.le2, self.invalid, False), ( + self.le2, self.asbinary, - self.asbinary, - InequalityExpression((self.bin, self.bin), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.le2, + self.zero, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.le2, + self.one, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), - (self.asbinary, self.zero, InequalityExpression((self.bin, 0), False)), - (self.asbinary, self.one, InequalityExpression((self.bin, 1), False)), # 4: - (self.asbinary, self.native, InequalityExpression((self.bin, 5), False)), ( - self.asbinary, + self.le2, + self.native, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.le2, self.npv, - InequalityExpression((self.bin, self.npv), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), - (self.asbinary, self.param, InequalityExpression((self.bin, 6), False)), ( - self.asbinary, + self.le2, + self.param, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.le2, self.param_mut, - InequalityExpression((self.bin, self.param_mut), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), # 8: ( - self.asbinary, + self.le2, self.var, - InequalityExpression((self.bin, self.var), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.asbinary, + self.le2, self.mon_native, - InequalityExpression((self.bin, self.mon_native), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.asbinary, + self.le2, self.mon_param, - InequalityExpression((self.bin, self.mon_param), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.asbinary, + self.le2, self.mon_npv, - InequalityExpression((self.bin, self.mon_npv), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), # 12: ( - self.asbinary, + self.le2, self.linear, - InequalityExpression((self.bin, self.linear), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.asbinary, + self.le2, self.sum, - InequalityExpression((self.bin, self.sum), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.asbinary, + self.le2, self.other, - InequalityExpression((self.bin, self.other), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.asbinary, + self.le2, self.mutable_l0, - InequalityExpression((self.bin, self.l0), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), # 16: ( - self.asbinary, + self.le2, self.mutable_l1, - InequalityExpression((self.bin, self.l1), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.asbinary, + self.le2, self.mutable_l2, - InequalityExpression((self.bin, self.l2), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.le2, + self.param0, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.le2, + self.param1, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), - (self.asbinary, self.param0, InequalityExpression((self.bin, 0), False)), - (self.asbinary, self.param1, InequalityExpression((self.bin, 1), False)), # 20: ( - self.asbinary, + self.le2, self.mutable_l3, - InequalityExpression((self.bin, self.l3), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.asbinary, + self.le2, self.eq, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", ), ( - self.asbinary, + self.le2, self.le, - RangedExpression((self.bin,) + self.le.args, (False, False)), + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", ), ( - self.asbinary, + self.le2, self.lt, - RangedExpression((self.bin,) + self.lt.args, (False, True)), + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", ), - # 24 + # 24: ( - self.asbinary, + self.le2, self.ranged, - "Cannot create an InequalityExpression where one of the " + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le2, + self.native2, + "Cannot create an EqualityExpression where one of the " "sub-expressions is a relational expression", ), + ( + self.le2, + self.le2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le2, + self.lt2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), ] - self._run_cases(tests, operator.le) + self._run_cases(tests, operator.eq) - def test_le_zero(self): + def test_eq_lt2(self): tests = [ - (self.zero, self.invalid, NotImplemented), - (self.zero, self.asbinary, InequalityExpression((0, self.bin), False)), - (self.zero, self.zero, True), - (self.zero, self.one, True), - # 4: - (self.zero, self.native, True), - (self.zero, self.npv, InequalityExpression((0, self.npv), False)), - (self.zero, self.param, True), + (self.lt2, self.invalid, False), ( - self.zero, - self.param_mut, - InequalityExpression((0, self.param_mut), False), + self.lt2, + self.asbinary, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), - # 8: - (self.zero, self.var, InequalityExpression((0, self.var), False)), ( + self.lt2, self.zero, - self.mon_native, - InequalityExpression((0, self.mon_native), False), + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.zero, - self.mon_param, - InequalityExpression((0, self.mon_param), False), + self.lt2, + self.one, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + # 4: + ( + self.lt2, + self.native, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.npv, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.param, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.param_mut, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + # 8: + ( + self.lt2, + self.var, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.mon_native, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.mon_param, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.mon_npv, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + # 12: + ( + self.lt2, + self.linear, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.sum, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.other, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.mutable_l0, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + # 16: + ( + self.lt2, + self.mutable_l1, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.mutable_l2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.param0, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.param1, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + # 20: + ( + self.lt2, + self.mutable_l3, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.eq, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.le, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.lt, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + # 24: + ( + self.lt2, + self.ranged, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.native2, + "Cannot create an EqualityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.lt2, + self.le2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.lt2, + "Cannot create an EqualityExpression where both " + "sub-expressions are relational expressions", + ), + ] + self._run_cases(tests, operator.eq) + + +# +# +# INEQUALITY (non-strict) +# +# + + +class TestInequality(BaseRelational, unittest.TestCase): + + def test_le_invalid(self): + tests = [ + # "invalid(str) == invalid(str)" is a legitimate Python + # operation and should never hit the Pyomo expression + # system + (self.invalid, self.invalid, True), + (self.invalid, self.asbinary, NotImplemented), + (self.invalid, self.zero, NotImplemented), + (self.invalid, self.one, NotImplemented), + # 4: + (self.invalid, self.native, NotImplemented), + (self.invalid, self.npv, NotImplemented), + (self.invalid, self.param, NotImplemented), + (self.invalid, self.param_mut, NotImplemented), + # 8: + (self.invalid, self.var, NotImplemented), + (self.invalid, self.mon_native, NotImplemented), + (self.invalid, self.mon_param, NotImplemented), + (self.invalid, self.mon_npv, NotImplemented), + # 12: + (self.invalid, self.linear, NotImplemented), + (self.invalid, self.sum, NotImplemented), + (self.invalid, self.other, NotImplemented), + (self.invalid, self.mutable_l0, NotImplemented), + # 16: + (self.invalid, self.mutable_l1, NotImplemented), + (self.invalid, self.mutable_l2, NotImplemented), + (self.invalid, self.param0, NotImplemented), + (self.invalid, self.param1, NotImplemented), + # 20: + (self.invalid, self.mutable_l3, NotImplemented), + (self.invalid, self.eq, NotImplemented), + (self.invalid, self.le, NotImplemented), + (self.invalid, self.lt, NotImplemented), + # 24: + (self.invalid, self.ranged, NotImplemented), + (self.invalid, self.native2, NotImplemented), + (self.invalid, self.le2, NotImplemented), + (self.invalid, self.lt2, NotImplemented), + ] + self._run_cases(tests, operator.le) + + def test_le_asbinary(self): + tests = [ + (self.asbinary, self.invalid, NotImplemented), + ( + self.asbinary, + self.asbinary, + InequalityExpression((self.bin, self.bin), False), + ), + (self.asbinary, self.zero, InequalityExpression((self.bin, 0), False)), + (self.asbinary, self.one, InequalityExpression((self.bin, 1), False)), + # 4: + (self.asbinary, self.native, InequalityExpression((self.bin, 5), False)), + ( + self.asbinary, + self.npv, + InequalityExpression((self.bin, self.npv), False), + ), + (self.asbinary, self.param, InequalityExpression((self.bin, 6), False)), + ( + self.asbinary, + self.param_mut, + InequalityExpression((self.bin, self.param_mut), False), + ), + # 8: + ( + self.asbinary, + self.var, + InequalityExpression((self.bin, self.var), False), + ), + ( + self.asbinary, + self.mon_native, + InequalityExpression((self.bin, self.mon_native), False), + ), + ( + self.asbinary, + self.mon_param, + InequalityExpression((self.bin, self.mon_param), False), + ), + ( + self.asbinary, + self.mon_npv, + InequalityExpression((self.bin, self.mon_npv), False), + ), + # 12: + ( + self.asbinary, + self.linear, + InequalityExpression((self.bin, self.linear), False), + ), + ( + self.asbinary, + self.sum, + InequalityExpression((self.bin, self.sum), False), + ), + ( + self.asbinary, + self.other, + InequalityExpression((self.bin, self.other), False), + ), + ( + self.asbinary, + self.mutable_l0, + InequalityExpression((self.bin, self.l0), False), + ), + # 16: + ( + self.asbinary, + self.mutable_l1, + InequalityExpression((self.bin, self.l1), False), + ), + ( + self.asbinary, + self.mutable_l2, + InequalityExpression((self.bin, self.l2), False), + ), + (self.asbinary, self.param0, InequalityExpression((self.bin, 0), False)), + (self.asbinary, self.param1, InequalityExpression((self.bin, 1), False)), + # 20: + ( + self.asbinary, + self.mutable_l3, + InequalityExpression((self.bin, self.l3), False), + ), + ( + self.asbinary, + self.eq, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.asbinary, + self.le, + RangedExpression((self.bin,) + self.le.args, (False, False)), + ), + ( + self.asbinary, + self.lt, + RangedExpression((self.bin,) + self.lt.args, (False, True)), + ), + # 24: + ( + self.asbinary, + self.ranged, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + (self.asbinary, self.native2, InequalityExpression((self.bin, 8), False)), + ( + self.asbinary, + self.le2, + RangedExpression((self.bin,) + self.le2.args, (False, False)), + ), + ( + self.asbinary, + self.lt2, + RangedExpression((self.bin,) + self.lt2.args, (False, True)), + ), + ] + self._run_cases(tests, operator.le) + + def test_le_zero(self): + tests = [ + (self.zero, self.invalid, NotImplemented), + (self.zero, self.asbinary, InequalityExpression((0, self.bin), False)), + (self.zero, self.zero, True), + (self.zero, self.one, True), + # 4: + (self.zero, self.native, True), + (self.zero, self.npv, InequalityExpression((0, self.npv), False)), + (self.zero, self.param, True), + ( + self.zero, + self.param_mut, + InequalityExpression((0, self.param_mut), False), + ), + # 8: + (self.zero, self.var, InequalityExpression((0, self.var), False)), + ( + self.zero, + self.mon_native, + InequalityExpression((0, self.mon_native), False), + ), + ( + self.zero, + self.mon_param, + InequalityExpression((0, self.mon_param), False), + ), + (self.zero, self.mon_npv, InequalityExpression((0, self.mon_npv), False)), + # 12: + (self.zero, self.linear, InequalityExpression((0, self.linear), False)), + (self.zero, self.sum, InequalityExpression((0, self.sum), False)), + (self.zero, self.other, InequalityExpression((0, self.other), False)), + (self.zero, self.mutable_l0, True), + # 16: + (self.zero, self.mutable_l1, InequalityExpression((0, self.l1), False)), + (self.zero, self.mutable_l2, InequalityExpression((0, self.l2), False)), + (self.zero, self.param0, True), + (self.zero, self.param1, True), + # 20: + (self.zero, self.mutable_l3, InequalityExpression((0, self.l3), False)), + ( + self.zero, + self.eq, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + (self.zero, self.le, RangedExpression((0,) + self.le.args, (False, False))), + (self.zero, self.lt, RangedExpression((0,) + self.lt.args, (False, True))), + # 24: + ( + self.zero, + self.ranged, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + (self.zero, self.native2, True), + ( + self.zero, + self.le2, + RangedExpression((0,) + self.le2.args, (False, False)), + ), + (self.zero, self.lt2, self.lt2), + ] + self._run_cases(tests, operator.le) + + def test_le_one(self): + tests = [ + (self.one, self.invalid, NotImplemented), + (self.one, self.asbinary, InequalityExpression((1, self.bin), False)), + (self.one, self.zero, False), + (self.one, self.one, True), + # 4: + (self.one, self.native, True), + (self.one, self.npv, InequalityExpression((1, self.npv), False)), + (self.one, self.param, True), + ( + self.one, + self.param_mut, + InequalityExpression((1, self.param_mut), False), + ), + # 8: + (self.one, self.var, InequalityExpression((1, self.var), False)), + ( + self.one, + self.mon_native, + InequalityExpression((1, self.mon_native), False), + ), + ( + self.one, + self.mon_param, + InequalityExpression((1, self.mon_param), False), + ), + (self.one, self.mon_npv, InequalityExpression((1, self.mon_npv), False)), + # 12: + (self.one, self.linear, InequalityExpression((1, self.linear), False)), + (self.one, self.sum, InequalityExpression((1, self.sum), False)), + (self.one, self.other, InequalityExpression((1, self.other), False)), + (self.one, self.mutable_l0, False), + # 16: + (self.one, self.mutable_l1, InequalityExpression((1, self.l1), False)), + (self.one, self.mutable_l2, InequalityExpression((1, self.l2), False)), + (self.one, self.param0, False), + (self.one, self.param1, True), + # 20: + (self.one, self.mutable_l3, InequalityExpression((1, self.l3), False)), + ( + self.one, + self.eq, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + (self.one, self.le, RangedExpression((1,) + self.le.args, (False, False))), + (self.one, self.lt, RangedExpression((1,) + self.lt.args, (False, True))), + # 24: + ( + self.one, + self.ranged, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + (self.one, self.native2, True), + ( + self.one, + self.le2, + RangedExpression((1,) + self.le2.args, (False, False)), + ), + (self.one, self.lt2, self.lt2), + ] + self._run_cases(tests, operator.le) + + def test_le_native(self): + tests = [ + (self.native, self.invalid, NotImplemented), + (self.native, self.asbinary, InequalityExpression((5, self.bin), False)), + (self.native, self.zero, False), + (self.native, self.one, False), + # 4: + (self.native, self.native, True), + (self.native, self.npv, InequalityExpression((5, self.npv), False)), + (self.native, self.param, True), + ( + self.native, + self.param_mut, + InequalityExpression((5, self.param_mut), False), + ), + # 8: + (self.native, self.var, InequalityExpression((5, self.var), False)), + ( + self.native, + self.mon_native, + InequalityExpression((5, self.mon_native), False), + ), + ( + self.native, + self.mon_param, + InequalityExpression((5, self.mon_param), False), + ), + (self.native, self.mon_npv, InequalityExpression((5, self.mon_npv), False)), + # 12: + (self.native, self.linear, InequalityExpression((5, self.linear), False)), + (self.native, self.sum, InequalityExpression((5, self.sum), False)), + (self.native, self.other, InequalityExpression((5, self.other), False)), + (self.native, self.mutable_l0, False), + # 16: + (self.native, self.mutable_l1, InequalityExpression((5, self.l1), False)), + (self.native, self.mutable_l2, InequalityExpression((5, self.l2), False)), + (self.native, self.param0, False), + (self.native, self.param1, False), + # 20: + (self.native, self.mutable_l3, InequalityExpression((5, self.l3), False)), + ( + self.native, + self.eq, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.native, + self.le, + RangedExpression((5,) + self.le.args, (False, False)), + ), + ( + self.native, + self.lt, + RangedExpression((5,) + self.lt.args, (False, True)), + ), + # 24: + ( + self.native, + self.ranged, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + (self.native, self.native2, True), + ( + self.native, + self.le2, + RangedExpression((5,) + self.le2.args, (False, False)), + ), + (self.native, self.lt2, self.lt2), + ] + self._run_cases(tests, operator.le) + + def test_le_npv(self): + tests = [ + (self.npv, self.invalid, NotImplemented), + ( + self.npv, + self.asbinary, + InequalityExpression((self.npv, self.bin), False), + ), + (self.npv, self.zero, InequalityExpression((self.npv, 0), False)), + (self.npv, self.one, InequalityExpression((self.npv, 1), False)), + # 4: + (self.npv, self.native, InequalityExpression((self.npv, 5), False)), + (self.npv, self.npv, InequalityExpression((self.npv, self.npv), False)), + (self.npv, self.param, InequalityExpression((self.npv, 6), False)), + ( + self.npv, + self.param_mut, + InequalityExpression((self.npv, self.param_mut), False), + ), + # 8: + (self.npv, self.var, InequalityExpression((self.npv, self.var), False)), + ( + self.npv, + self.mon_native, + InequalityExpression((self.npv, self.mon_native), False), + ), + ( + self.npv, + self.mon_param, + InequalityExpression((self.npv, self.mon_param), False), + ), + ( + self.npv, + self.mon_npv, + InequalityExpression((self.npv, self.mon_npv), False), ), - (self.zero, self.mon_npv, InequalityExpression((0, self.mon_npv), False)), # 12: - (self.zero, self.linear, InequalityExpression((0, self.linear), False)), - (self.zero, self.sum, InequalityExpression((0, self.sum), False)), - (self.zero, self.other, InequalityExpression((0, self.other), False)), - (self.zero, self.mutable_l0, True), + ( + self.npv, + self.linear, + InequalityExpression((self.npv, self.linear), False), + ), + (self.npv, self.sum, InequalityExpression((self.npv, self.sum), False)), + (self.npv, self.other, InequalityExpression((self.npv, self.other), False)), + ( + self.npv, + self.mutable_l0, + InequalityExpression((self.npv, self.l0), False), + ), # 16: - (self.zero, self.mutable_l1, InequalityExpression((0, self.l1), False)), - (self.zero, self.mutable_l2, InequalityExpression((0, self.l2), False)), - (self.zero, self.param0, True), - (self.zero, self.param1, True), + ( + self.npv, + self.mutable_l1, + InequalityExpression((self.npv, self.l1), False), + ), + ( + self.npv, + self.mutable_l2, + InequalityExpression((self.npv, self.l2), False), + ), + (self.npv, self.param0, InequalityExpression((self.npv, 0), False)), + (self.npv, self.param1, InequalityExpression((self.npv, 1), False)), # 20: - (self.zero, self.mutable_l3, InequalityExpression((0, self.l3), False)), ( - self.zero, + self.npv, + self.mutable_l3, + InequalityExpression((self.npv, self.l3), False), + ), + ( + self.npv, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), - (self.zero, self.le, RangedExpression((0,) + self.le.args, (False, False))), - (self.zero, self.lt, RangedExpression((0,) + self.lt.args, (False, True))), - # 24 ( - self.zero, + self.npv, + self.le, + RangedExpression((self.npv,) + self.le.args, (False, False)), + ), + ( + self.npv, + self.lt, + RangedExpression((self.npv,) + self.lt.args, (False, True)), + ), + # 24: + ( + self.npv, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.npv, self.native2, InequalityExpression((self.npv, 8), False)), + ( + self.npv, + self.le2, + RangedExpression((self.npv,) + self.le2.args, (False, False)), + ), + ( + self.npv, + self.lt2, + RangedExpression((self.npv,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_one(self): + def test_le_param(self): tests = [ - (self.one, self.invalid, NotImplemented), - (self.one, self.asbinary, InequalityExpression((1, self.bin), False)), - (self.one, self.zero, False), - (self.one, self.one, True), + (self.param, self.invalid, NotImplemented), + (self.param, self.asbinary, InequalityExpression((6, self.bin), False)), + (self.param, self.zero, False), + (self.param, self.one, False), # 4: - (self.one, self.native, True), - (self.one, self.npv, InequalityExpression((1, self.npv), False)), - (self.one, self.param, True), + (self.param, self.native, False), + (self.param, self.npv, InequalityExpression((6, self.npv), False)), + (self.param, self.param, True), ( - self.one, + self.param, self.param_mut, - InequalityExpression((1, self.param_mut), False), + InequalityExpression((6, self.param_mut), False), ), # 8: - (self.one, self.var, InequalityExpression((1, self.var), False)), + (self.param, self.var, InequalityExpression((6, self.var), False)), ( - self.one, + self.param, self.mon_native, - InequalityExpression((1, self.mon_native), False), + InequalityExpression((6, self.mon_native), False), ), ( - self.one, + self.param, self.mon_param, - InequalityExpression((1, self.mon_param), False), + InequalityExpression((6, self.mon_param), False), ), - (self.one, self.mon_npv, InequalityExpression((1, self.mon_npv), False)), + (self.param, self.mon_npv, InequalityExpression((6, self.mon_npv), False)), # 12: - (self.one, self.linear, InequalityExpression((1, self.linear), False)), - (self.one, self.sum, InequalityExpression((1, self.sum), False)), - (self.one, self.other, InequalityExpression((1, self.other), False)), - (self.one, self.mutable_l0, False), + (self.param, self.linear, InequalityExpression((6, self.linear), False)), + (self.param, self.sum, InequalityExpression((6, self.sum), False)), + (self.param, self.other, InequalityExpression((6, self.other), False)), + (self.param, self.mutable_l0, False), # 16: - (self.one, self.mutable_l1, InequalityExpression((1, self.l1), False)), - (self.one, self.mutable_l2, InequalityExpression((1, self.l2), False)), - (self.one, self.param0, False), - (self.one, self.param1, True), + (self.param, self.mutable_l1, InequalityExpression((6, self.l1), False)), + (self.param, self.mutable_l2, InequalityExpression((6, self.l2), False)), + (self.param, self.param0, False), + (self.param, self.param1, False), # 20: - (self.one, self.mutable_l3, InequalityExpression((1, self.l3), False)), + (self.param, self.mutable_l3, InequalityExpression((6, self.l3), False)), ( - self.one, + self.param, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), - (self.one, self.le, RangedExpression((1,) + self.le.args, (False, False))), - (self.one, self.lt, RangedExpression((1,) + self.lt.args, (False, True))), - # 24 ( - self.one, + self.param, + self.le, + RangedExpression((6,) + self.le.args, (False, False)), + ), + (self.param, self.lt, False), + # 24: + ( + self.param, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param, self.native2, True), + ( + self.param, + self.le2, + RangedExpression((6,) + self.le2.args, (False, False)), + ), + (self.param, self.lt2, self.lt2), ] self._run_cases(tests, operator.le) - def test_le_native(self): + def test_le_param_mut(self): tests = [ - (self.native, self.invalid, NotImplemented), - (self.native, self.asbinary, InequalityExpression((5, self.bin), False)), - (self.native, self.zero, False), - (self.native, self.one, False), + (self.param_mut, self.invalid, NotImplemented), + ( + self.param_mut, + self.asbinary, + InequalityExpression((self.param_mut, self.bin), False), + ), + ( + self.param_mut, + self.zero, + InequalityExpression((self.param_mut, 0), False), + ), + ( + self.param_mut, + self.one, + InequalityExpression((self.param_mut, 1), False), + ), # 4: - (self.native, self.native, True), - (self.native, self.npv, InequalityExpression((5, self.npv), False)), - (self.native, self.param, True), ( - self.native, self.param_mut, - InequalityExpression((5, self.param_mut), False), + self.native, + InequalityExpression((self.param_mut, 5), False), + ), + ( + self.param_mut, + self.npv, + InequalityExpression((self.param_mut, self.npv), False), + ), + ( + self.param_mut, + self.param, + InequalityExpression((self.param_mut, 6), False), + ), + ( + self.param_mut, + self.param_mut, + InequalityExpression((self.param_mut, self.param_mut), False), + ), + # 8: + ( + self.param_mut, + self.var, + InequalityExpression((self.param_mut, self.var), False), + ), + ( + self.param_mut, + self.mon_native, + InequalityExpression((self.param_mut, self.mon_native), False), + ), + ( + self.param_mut, + self.mon_param, + InequalityExpression((self.param_mut, self.mon_param), False), + ), + ( + self.param_mut, + self.mon_npv, + InequalityExpression((self.param_mut, self.mon_npv), False), + ), + # 12: + ( + self.param_mut, + self.linear, + InequalityExpression((self.param_mut, self.linear), False), + ), + ( + self.param_mut, + self.sum, + InequalityExpression((self.param_mut, self.sum), False), + ), + ( + self.param_mut, + self.other, + InequalityExpression((self.param_mut, self.other), False), + ), + ( + self.param_mut, + self.mutable_l0, + InequalityExpression((self.param_mut, self.l0), False), + ), + # 16: + ( + self.param_mut, + self.mutable_l1, + InequalityExpression((self.param_mut, self.l1), False), + ), + ( + self.param_mut, + self.mutable_l2, + InequalityExpression((self.param_mut, self.l2), False), ), - # 8: - (self.native, self.var, InequalityExpression((5, self.var), False)), ( - self.native, - self.mon_native, - InequalityExpression((5, self.mon_native), False), + self.param_mut, + self.param0, + InequalityExpression((self.param_mut, 0), False), ), ( - self.native, - self.mon_param, - InequalityExpression((5, self.mon_param), False), + self.param_mut, + self.param1, + InequalityExpression((self.param_mut, 1), False), ), - (self.native, self.mon_npv, InequalityExpression((5, self.mon_npv), False)), - # 12: - (self.native, self.linear, InequalityExpression((5, self.linear), False)), - (self.native, self.sum, InequalityExpression((5, self.sum), False)), - (self.native, self.other, InequalityExpression((5, self.other), False)), - (self.native, self.mutable_l0, False), - # 16: - (self.native, self.mutable_l1, InequalityExpression((5, self.l1), False)), - (self.native, self.mutable_l2, InequalityExpression((5, self.l2), False)), - (self.native, self.param0, False), - (self.native, self.param1, False), # 20: - (self.native, self.mutable_l3, InequalityExpression((5, self.l3), False)), ( - self.native, + self.param_mut, + self.mutable_l3, + InequalityExpression((self.param_mut, self.l3), False), + ), + ( + self.param_mut, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.native, + self.param_mut, self.le, - RangedExpression((5,) + self.le.args, (False, False)), + RangedExpression((self.param_mut,) + self.le.args, (False, False)), ), ( - self.native, + self.param_mut, self.lt, - RangedExpression((5,) + self.lt.args, (False, True)), + RangedExpression((self.param_mut,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.native, + self.param_mut, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + ( + self.param_mut, + self.native2, + InequalityExpression((self.param_mut, 8), False), + ), + ( + self.param_mut, + self.le2, + RangedExpression((self.param_mut,) + self.le2.args, (False, False)), + ), + ( + self.param_mut, + self.lt2, + RangedExpression((self.param_mut,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_npv(self): + def test_le_var(self): tests = [ - (self.npv, self.invalid, NotImplemented), + (self.var, self.invalid, NotImplemented), ( - self.npv, + self.var, self.asbinary, - InequalityExpression((self.npv, self.bin), False), + InequalityExpression((self.var, self.bin), False), ), - (self.npv, self.zero, InequalityExpression((self.npv, 0), False)), - (self.npv, self.one, InequalityExpression((self.npv, 1), False)), + (self.var, self.zero, InequalityExpression((self.var, 0), False)), + (self.var, self.one, InequalityExpression((self.var, 1), False)), # 4: - (self.npv, self.native, InequalityExpression((self.npv, 5), False)), - (self.npv, self.npv, InequalityExpression((self.npv, self.npv), False)), - (self.npv, self.param, InequalityExpression((self.npv, 6), False)), + (self.var, self.native, InequalityExpression((self.var, 5), False)), + (self.var, self.npv, InequalityExpression((self.var, self.npv), False)), + (self.var, self.param, InequalityExpression((self.var, 6), False)), ( - self.npv, + self.var, self.param_mut, - InequalityExpression((self.npv, self.param_mut), False), + InequalityExpression((self.var, self.param_mut), False), ), # 8: - (self.npv, self.var, InequalityExpression((self.npv, self.var), False)), + (self.var, self.var, InequalityExpression((self.var, self.var), False)), ( - self.npv, + self.var, self.mon_native, - InequalityExpression((self.npv, self.mon_native), False), + InequalityExpression((self.var, self.mon_native), False), ), ( - self.npv, + self.var, self.mon_param, - InequalityExpression((self.npv, self.mon_param), False), + InequalityExpression((self.var, self.mon_param), False), ), ( - self.npv, + self.var, self.mon_npv, - InequalityExpression((self.npv, self.mon_npv), False), + InequalityExpression((self.var, self.mon_npv), False), ), # 12: ( - self.npv, + self.var, self.linear, - InequalityExpression((self.npv, self.linear), False), + InequalityExpression((self.var, self.linear), False), ), - (self.npv, self.sum, InequalityExpression((self.npv, self.sum), False)), - (self.npv, self.other, InequalityExpression((self.npv, self.other), False)), + (self.var, self.sum, InequalityExpression((self.var, self.sum), False)), + (self.var, self.other, InequalityExpression((self.var, self.other), False)), ( - self.npv, + self.var, self.mutable_l0, - InequalityExpression((self.npv, self.l0), False), + InequalityExpression((self.var, self.l0), False), ), # 16: ( - self.npv, + self.var, self.mutable_l1, - InequalityExpression((self.npv, self.l1), False), + InequalityExpression((self.var, self.l1), False), ), ( - self.npv, + self.var, self.mutable_l2, - InequalityExpression((self.npv, self.l2), False), + InequalityExpression((self.var, self.l2), False), ), - (self.npv, self.param0, InequalityExpression((self.npv, 0), False)), - (self.npv, self.param1, InequalityExpression((self.npv, 1), False)), + (self.var, self.param0, InequalityExpression((self.var, 0), False)), + (self.var, self.param1, InequalityExpression((self.var, 1), False)), # 20: ( - self.npv, + self.var, self.mutable_l3, - InequalityExpression((self.npv, self.l3), False), + InequalityExpression((self.var, self.l3), False), ), ( - self.npv, + self.var, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.npv, + self.var, self.le, - RangedExpression((self.npv,) + self.le.args, (False, False)), + RangedExpression((self.var,) + self.le.args, (False, False)), ), ( - self.npv, + self.var, self.lt, - RangedExpression((self.npv,) + self.lt.args, (False, True)), + RangedExpression((self.var,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.npv, + self.var, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.var, self.native2, InequalityExpression((self.var, 8), False)), + ( + self.var, + self.le2, + RangedExpression((self.var,) + self.le2.args, (False, False)), + ), + ( + self.var, + self.lt2, + RangedExpression((self.var,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_param(self): + def test_le_mon_native(self): tests = [ - (self.param, self.invalid, NotImplemented), - (self.param, self.asbinary, InequalityExpression((6, self.bin), False)), - (self.param, self.zero, False), - (self.param, self.one, False), + (self.mon_native, self.invalid, NotImplemented), + ( + self.mon_native, + self.asbinary, + InequalityExpression((self.mon_native, self.bin), False), + ), + ( + self.mon_native, + self.zero, + InequalityExpression((self.mon_native, 0), False), + ), + ( + self.mon_native, + self.one, + InequalityExpression((self.mon_native, 1), False), + ), # 4: - (self.param, self.native, False), - (self.param, self.npv, InequalityExpression((6, self.npv), False)), - (self.param, self.param, True), ( + self.mon_native, + self.native, + InequalityExpression((self.mon_native, 5), False), + ), + ( + self.mon_native, + self.npv, + InequalityExpression((self.mon_native, self.npv), False), + ), + ( + self.mon_native, self.param, + InequalityExpression((self.mon_native, 6), False), + ), + ( + self.mon_native, self.param_mut, - InequalityExpression((6, self.param_mut), False), + InequalityExpression((self.mon_native, self.param_mut), False), ), # 8: - (self.param, self.var, InequalityExpression((6, self.var), False)), ( - self.param, self.mon_native, - InequalityExpression((6, self.mon_native), False), + self.var, + InequalityExpression((self.mon_native, self.var), False), ), ( - self.param, + self.mon_native, + self.mon_native, + InequalityExpression((self.mon_native, self.mon_native), False), + ), + ( + self.mon_native, self.mon_param, - InequalityExpression((6, self.mon_param), False), + InequalityExpression((self.mon_native, self.mon_param), False), + ), + ( + self.mon_native, + self.mon_npv, + InequalityExpression((self.mon_native, self.mon_npv), False), ), - (self.param, self.mon_npv, InequalityExpression((6, self.mon_npv), False)), # 12: - (self.param, self.linear, InequalityExpression((6, self.linear), False)), - (self.param, self.sum, InequalityExpression((6, self.sum), False)), - (self.param, self.other, InequalityExpression((6, self.other), False)), - (self.param, self.mutable_l0, False), + ( + self.mon_native, + self.linear, + InequalityExpression((self.mon_native, self.linear), False), + ), + ( + self.mon_native, + self.sum, + InequalityExpression((self.mon_native, self.sum), False), + ), + ( + self.mon_native, + self.other, + InequalityExpression((self.mon_native, self.other), False), + ), + ( + self.mon_native, + self.mutable_l0, + InequalityExpression((self.mon_native, self.l0), False), + ), # 16: - (self.param, self.mutable_l1, InequalityExpression((6, self.l1), False)), - (self.param, self.mutable_l2, InequalityExpression((6, self.l2), False)), - (self.param, self.param0, False), - (self.param, self.param1, False), + ( + self.mon_native, + self.mutable_l1, + InequalityExpression((self.mon_native, self.l1), False), + ), + ( + self.mon_native, + self.mutable_l2, + InequalityExpression((self.mon_native, self.l2), False), + ), + ( + self.mon_native, + self.param0, + InequalityExpression((self.mon_native, 0), False), + ), + ( + self.mon_native, + self.param1, + InequalityExpression((self.mon_native, 1), False), + ), # 20: - (self.param, self.mutable_l3, InequalityExpression((6, self.l3), False)), ( - self.param, + self.mon_native, + self.mutable_l3, + InequalityExpression((self.mon_native, self.l3), False), + ), + ( + self.mon_native, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.param, + self.mon_native, self.le, - RangedExpression((6,) + self.le.args, (False, False)), + RangedExpression((self.mon_native,) + self.le.args, (False, False)), ), - (self.param, self.lt, RangedExpression((6,) + self.lt.args, (False, True))), - # 24 ( - self.param, + self.mon_native, + self.lt, + RangedExpression((self.mon_native,) + self.lt.args, (False, True)), + ), + # 24: + ( + self.mon_native, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + ( + self.mon_native, + self.native2, + InequalityExpression((self.mon_native, 8), False), + ), + ( + self.mon_native, + self.le2, + RangedExpression((self.mon_native,) + self.le2.args, (False, False)), + ), + ( + self.mon_native, + self.lt2, + RangedExpression((self.mon_native,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_param_mut(self): + def test_le_mon_param(self): tests = [ - (self.param_mut, self.invalid, NotImplemented), + (self.mon_param, self.invalid, NotImplemented), ( - self.param_mut, + self.mon_param, self.asbinary, - InequalityExpression((self.param_mut, self.bin), False), + InequalityExpression((self.mon_param, self.bin), False), ), ( - self.param_mut, + self.mon_param, self.zero, - InequalityExpression((self.param_mut, 0), False), + InequalityExpression((self.mon_param, 0), False), ), ( - self.param_mut, + self.mon_param, self.one, - InequalityExpression((self.param_mut, 1), False), + InequalityExpression((self.mon_param, 1), False), ), # 4: ( - self.param_mut, + self.mon_param, self.native, - InequalityExpression((self.param_mut, 5), False), + InequalityExpression((self.mon_param, 5), False), ), ( - self.param_mut, + self.mon_param, self.npv, - InequalityExpression((self.param_mut, self.npv), False), + InequalityExpression((self.mon_param, self.npv), False), ), ( - self.param_mut, + self.mon_param, self.param, - InequalityExpression((self.param_mut, 6), False), + InequalityExpression((self.mon_param, 6), False), ), ( + self.mon_param, self.param_mut, - self.param_mut, - InequalityExpression((self.param_mut, self.param_mut), False), + InequalityExpression((self.mon_param, self.param_mut), False), ), # 8: ( - self.param_mut, + self.mon_param, self.var, - InequalityExpression((self.param_mut, self.var), False), + InequalityExpression((self.mon_param, self.var), False), ), ( - self.param_mut, + self.mon_param, self.mon_native, - InequalityExpression((self.param_mut, self.mon_native), False), + InequalityExpression((self.mon_param, self.mon_native), False), ), ( - self.param_mut, self.mon_param, - InequalityExpression((self.param_mut, self.mon_param), False), + self.mon_param, + InequalityExpression((self.mon_param, self.mon_param), False), ), ( - self.param_mut, + self.mon_param, self.mon_npv, - InequalityExpression((self.param_mut, self.mon_npv), False), + InequalityExpression((self.mon_param, self.mon_npv), False), ), # 12: ( - self.param_mut, + self.mon_param, self.linear, - InequalityExpression((self.param_mut, self.linear), False), + InequalityExpression((self.mon_param, self.linear), False), ), ( - self.param_mut, + self.mon_param, self.sum, - InequalityExpression((self.param_mut, self.sum), False), + InequalityExpression((self.mon_param, self.sum), False), ), ( - self.param_mut, + self.mon_param, self.other, - InequalityExpression((self.param_mut, self.other), False), + InequalityExpression((self.mon_param, self.other), False), ), ( - self.param_mut, + self.mon_param, self.mutable_l0, - InequalityExpression((self.param_mut, self.l0), False), + InequalityExpression((self.mon_param, self.l0), False), ), # 16: ( - self.param_mut, + self.mon_param, self.mutable_l1, - InequalityExpression((self.param_mut, self.l1), False), + InequalityExpression((self.mon_param, self.l1), False), ), ( - self.param_mut, + self.mon_param, self.mutable_l2, - InequalityExpression((self.param_mut, self.l2), False), + InequalityExpression((self.mon_param, self.l2), False), ), ( - self.param_mut, + self.mon_param, self.param0, - InequalityExpression((self.param_mut, 0), False), + InequalityExpression((self.mon_param, 0), False), ), ( - self.param_mut, + self.mon_param, self.param1, - InequalityExpression((self.param_mut, 1), False), + InequalityExpression((self.mon_param, 1), False), ), # 20: ( - self.param_mut, + self.mon_param, self.mutable_l3, - InequalityExpression((self.param_mut, self.l3), False), + InequalityExpression((self.mon_param, self.l3), False), ), ( - self.param_mut, + self.mon_param, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.param_mut, + self.mon_param, self.le, - RangedExpression((self.param_mut,) + self.le.args, (False, False)), + RangedExpression((self.mon_param,) + self.le.args, (False, False)), ), ( - self.param_mut, + self.mon_param, self.lt, - RangedExpression((self.param_mut,) + self.lt.args, (False, True)), + RangedExpression((self.mon_param,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.param_mut, + self.mon_param, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + ( + self.mon_param, + self.native2, + InequalityExpression((self.mon_param, 8), False), + ), + ( + self.mon_param, + self.le2, + RangedExpression((self.mon_param,) + self.le2.args, (False, False)), + ), + ( + self.mon_param, + self.lt2, + RangedExpression((self.mon_param,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_var(self): + def test_le_mon_npv(self): tests = [ - (self.var, self.invalid, NotImplemented), + (self.mon_npv, self.invalid, NotImplemented), ( - self.var, + self.mon_npv, self.asbinary, - InequalityExpression((self.var, self.bin), False), + InequalityExpression((self.mon_npv, self.bin), False), ), - (self.var, self.zero, InequalityExpression((self.var, 0), False)), - (self.var, self.one, InequalityExpression((self.var, 1), False)), + (self.mon_npv, self.zero, InequalityExpression((self.mon_npv, 0), False)), + (self.mon_npv, self.one, InequalityExpression((self.mon_npv, 1), False)), # 4: - (self.var, self.native, InequalityExpression((self.var, 5), False)), - (self.var, self.npv, InequalityExpression((self.var, self.npv), False)), - (self.var, self.param, InequalityExpression((self.var, 6), False)), + (self.mon_npv, self.native, InequalityExpression((self.mon_npv, 5), False)), ( - self.var, + self.mon_npv, + self.npv, + InequalityExpression((self.mon_npv, self.npv), False), + ), + (self.mon_npv, self.param, InequalityExpression((self.mon_npv, 6), False)), + ( + self.mon_npv, self.param_mut, - InequalityExpression((self.var, self.param_mut), False), + InequalityExpression((self.mon_npv, self.param_mut), False), ), # 8: - (self.var, self.var, InequalityExpression((self.var, self.var), False)), ( + self.mon_npv, self.var, + InequalityExpression((self.mon_npv, self.var), False), + ), + ( + self.mon_npv, self.mon_native, - InequalityExpression((self.var, self.mon_native), False), + InequalityExpression((self.mon_npv, self.mon_native), False), ), ( - self.var, + self.mon_npv, self.mon_param, - InequalityExpression((self.var, self.mon_param), False), + InequalityExpression((self.mon_npv, self.mon_param), False), ), ( - self.var, self.mon_npv, - InequalityExpression((self.var, self.mon_npv), False), + self.mon_npv, + InequalityExpression((self.mon_npv, self.mon_npv), False), ), # 12: ( - self.var, + self.mon_npv, self.linear, - InequalityExpression((self.var, self.linear), False), + InequalityExpression((self.mon_npv, self.linear), False), ), - (self.var, self.sum, InequalityExpression((self.var, self.sum), False)), - (self.var, self.other, InequalityExpression((self.var, self.other), False)), ( - self.var, + self.mon_npv, + self.sum, + InequalityExpression((self.mon_npv, self.sum), False), + ), + ( + self.mon_npv, + self.other, + InequalityExpression((self.mon_npv, self.other), False), + ), + ( + self.mon_npv, self.mutable_l0, - InequalityExpression((self.var, self.l0), False), + InequalityExpression((self.mon_npv, self.l0), False), ), # 16: ( - self.var, + self.mon_npv, self.mutable_l1, - InequalityExpression((self.var, self.l1), False), + InequalityExpression((self.mon_npv, self.l1), False), ), ( - self.var, + self.mon_npv, self.mutable_l2, - InequalityExpression((self.var, self.l2), False), + InequalityExpression((self.mon_npv, self.l2), False), ), - (self.var, self.param0, InequalityExpression((self.var, 0), False)), - (self.var, self.param1, InequalityExpression((self.var, 1), False)), + (self.mon_npv, self.param0, InequalityExpression((self.mon_npv, 0), False)), + (self.mon_npv, self.param1, InequalityExpression((self.mon_npv, 1), False)), # 20: ( - self.var, + self.mon_npv, self.mutable_l3, - InequalityExpression((self.var, self.l3), False), + InequalityExpression((self.mon_npv, self.l3), False), ), ( - self.var, + self.mon_npv, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.var, + self.mon_npv, self.le, - RangedExpression((self.var,) + self.le.args, (False, False)), + RangedExpression((self.mon_npv,) + self.le.args, (False, False)), ), ( - self.var, + self.mon_npv, self.lt, - RangedExpression((self.var,) + self.lt.args, (False, True)), + RangedExpression((self.mon_npv,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.var, + self.mon_npv, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), - ] - self._run_cases(tests, operator.le) - - def test_le_mon_native(self): - tests = [ - (self.mon_native, self.invalid, NotImplemented), - ( - self.mon_native, - self.asbinary, - InequalityExpression((self.mon_native, self.bin), False), - ), ( - self.mon_native, - self.zero, - InequalityExpression((self.mon_native, 0), False), + self.mon_npv, + self.native2, + InequalityExpression((self.mon_npv, 8), False), ), ( - self.mon_native, - self.one, - InequalityExpression((self.mon_native, 1), False), + self.mon_npv, + self.le2, + RangedExpression((self.mon_npv,) + self.le2.args, (False, False)), ), - # 4: ( - self.mon_native, - self.native, - InequalityExpression((self.mon_native, 5), False), + self.mon_npv, + self.lt2, + RangedExpression((self.mon_npv,) + self.lt2.args, (False, True)), ), + ] + self._run_cases(tests, operator.le) + + def test_le_linear(self): + tests = [ + (self.linear, self.invalid, NotImplemented), ( - self.mon_native, - self.npv, - InequalityExpression((self.mon_native, self.npv), False), + self.linear, + self.asbinary, + InequalityExpression((self.linear, self.bin), False), ), + (self.linear, self.zero, InequalityExpression((self.linear, 0), False)), + (self.linear, self.one, InequalityExpression((self.linear, 1), False)), + # 4: + (self.linear, self.native, InequalityExpression((self.linear, 5), False)), ( - self.mon_native, - self.param, - InequalityExpression((self.mon_native, 6), False), + self.linear, + self.npv, + InequalityExpression((self.linear, self.npv), False), ), + (self.linear, self.param, InequalityExpression((self.linear, 6), False)), ( - self.mon_native, + self.linear, self.param_mut, - InequalityExpression((self.mon_native, self.param_mut), False), + InequalityExpression((self.linear, self.param_mut), False), ), # 8: ( - self.mon_native, + self.linear, self.var, - InequalityExpression((self.mon_native, self.var), False), + InequalityExpression((self.linear, self.var), False), ), ( + self.linear, self.mon_native, - self.mon_native, - InequalityExpression((self.mon_native, self.mon_native), False), + InequalityExpression((self.linear, self.mon_native), False), ), ( - self.mon_native, + self.linear, self.mon_param, - InequalityExpression((self.mon_native, self.mon_param), False), + InequalityExpression((self.linear, self.mon_param), False), ), ( - self.mon_native, + self.linear, self.mon_npv, - InequalityExpression((self.mon_native, self.mon_npv), False), + InequalityExpression((self.linear, self.mon_npv), False), ), # 12: ( - self.mon_native, self.linear, - InequalityExpression((self.mon_native, self.linear), False), + self.linear, + InequalityExpression((self.linear, self.linear), False), ), ( - self.mon_native, + self.linear, self.sum, - InequalityExpression((self.mon_native, self.sum), False), + InequalityExpression((self.linear, self.sum), False), ), ( - self.mon_native, + self.linear, self.other, - InequalityExpression((self.mon_native, self.other), False), + InequalityExpression((self.linear, self.other), False), ), ( - self.mon_native, + self.linear, self.mutable_l0, - InequalityExpression((self.mon_native, self.l0), False), + InequalityExpression((self.linear, self.l0), False), ), # 16: ( - self.mon_native, + self.linear, self.mutable_l1, - InequalityExpression((self.mon_native, self.l1), False), + InequalityExpression((self.linear, self.l1), False), ), ( - self.mon_native, + self.linear, self.mutable_l2, - InequalityExpression((self.mon_native, self.l2), False), - ), - ( - self.mon_native, - self.param0, - InequalityExpression((self.mon_native, 0), False), - ), - ( - self.mon_native, - self.param1, - InequalityExpression((self.mon_native, 1), False), + InequalityExpression((self.linear, self.l2), False), ), + (self.linear, self.param0, InequalityExpression((self.linear, 0), False)), + (self.linear, self.param1, InequalityExpression((self.linear, 1), False)), # 20: ( - self.mon_native, + self.linear, self.mutable_l3, - InequalityExpression((self.mon_native, self.l3), False), + InequalityExpression((self.linear, self.l3), False), ), ( - self.mon_native, + self.linear, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.mon_native, + self.linear, self.le, - RangedExpression((self.mon_native,) + self.le.args, (False, False)), + RangedExpression(((self.linear,) + self.le.args), (False, False)), ), ( - self.mon_native, + self.linear, self.lt, - RangedExpression((self.mon_native,) + self.lt.args, (False, True)), + RangedExpression(((self.linear,) + self.lt.args), (False, True)), ), - # 24 + # 24: ( - self.mon_native, + self.linear, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.linear, self.native2, InequalityExpression((self.linear, 8), False)), + ( + self.linear, + self.le2, + RangedExpression(((self.linear,) + self.le2.args), (False, False)), + ), + ( + self.linear, + self.lt2, + RangedExpression(((self.linear,) + self.lt2.args), (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_mon_param(self): + def test_le_sum(self): tests = [ - (self.mon_param, self.invalid, NotImplemented), + (self.sum, self.invalid, NotImplemented), ( - self.mon_param, + self.sum, self.asbinary, - InequalityExpression((self.mon_param, self.bin), False), - ), - ( - self.mon_param, - self.zero, - InequalityExpression((self.mon_param, 0), False), - ), - ( - self.mon_param, - self.one, - InequalityExpression((self.mon_param, 1), False), + InequalityExpression((self.sum, self.bin), False), ), + (self.sum, self.zero, InequalityExpression((self.sum, 0), False)), + (self.sum, self.one, InequalityExpression((self.sum, 1), False)), # 4: + (self.sum, self.native, InequalityExpression((self.sum, 5), False)), + (self.sum, self.npv, InequalityExpression((self.sum, self.npv), False)), + (self.sum, self.param, InequalityExpression((self.sum, 6), False)), ( - self.mon_param, - self.native, - InequalityExpression((self.mon_param, 5), False), - ), - ( - self.mon_param, - self.npv, - InequalityExpression((self.mon_param, self.npv), False), - ), - ( - self.mon_param, - self.param, - InequalityExpression((self.mon_param, 6), False), - ), - ( - self.mon_param, + self.sum, self.param_mut, - InequalityExpression((self.mon_param, self.param_mut), False), + InequalityExpression((self.sum, self.param_mut), False), ), # 8: + (self.sum, self.var, InequalityExpression((self.sum, self.var), False)), ( - self.mon_param, - self.var, - InequalityExpression((self.mon_param, self.var), False), - ), - ( - self.mon_param, + self.sum, self.mon_native, - InequalityExpression((self.mon_param, self.mon_native), False), + InequalityExpression((self.sum, self.mon_native), False), ), ( + self.sum, self.mon_param, - self.mon_param, - InequalityExpression((self.mon_param, self.mon_param), False), + InequalityExpression((self.sum, self.mon_param), False), ), ( - self.mon_param, + self.sum, self.mon_npv, - InequalityExpression((self.mon_param, self.mon_npv), False), + InequalityExpression((self.sum, self.mon_npv), False), ), # 12: ( - self.mon_param, + self.sum, self.linear, - InequalityExpression((self.mon_param, self.linear), False), + InequalityExpression((self.sum, self.linear), False), ), + (self.sum, self.sum, InequalityExpression((self.sum, self.sum), False)), + (self.sum, self.other, InequalityExpression((self.sum, self.other), False)), ( - self.mon_param, self.sum, - InequalityExpression((self.mon_param, self.sum), False), - ), - ( - self.mon_param, - self.other, - InequalityExpression((self.mon_param, self.other), False), - ), - ( - self.mon_param, self.mutable_l0, - InequalityExpression((self.mon_param, self.l0), False), + InequalityExpression((self.sum, self.l0), False), ), # 16: ( - self.mon_param, + self.sum, self.mutable_l1, - InequalityExpression((self.mon_param, self.l1), False), + InequalityExpression((self.sum, self.l1), False), ), ( - self.mon_param, + self.sum, self.mutable_l2, - InequalityExpression((self.mon_param, self.l2), False), - ), - ( - self.mon_param, - self.param0, - InequalityExpression((self.mon_param, 0), False), - ), - ( - self.mon_param, - self.param1, - InequalityExpression((self.mon_param, 1), False), + InequalityExpression((self.sum, self.l2), False), ), + (self.sum, self.param0, InequalityExpression((self.sum, 0), False)), + (self.sum, self.param1, InequalityExpression((self.sum, 1), False)), # 20: ( - self.mon_param, + self.sum, self.mutable_l3, - InequalityExpression((self.mon_param, self.l3), False), + InequalityExpression((self.sum, self.l3), False), ), ( - self.mon_param, + self.sum, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.mon_param, + self.sum, self.le, - RangedExpression((self.mon_param,) + self.le.args, (False, False)), + RangedExpression((self.sum,) + self.le.args, (False, False)), ), ( - self.mon_param, + self.sum, self.lt, - RangedExpression((self.mon_param,) + self.lt.args, (False, True)), + RangedExpression((self.sum,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.mon_param, + self.sum, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.sum, self.native2, InequalityExpression((self.sum, 8), False)), + ( + self.sum, + self.le2, + RangedExpression((self.sum,) + self.le2.args, (False, False)), + ), + ( + self.sum, + self.lt2, + RangedExpression((self.sum,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_mon_npv(self): + def test_le_other(self): tests = [ - (self.mon_npv, self.invalid, NotImplemented), + (self.other, self.invalid, NotImplemented), ( - self.mon_npv, + self.other, self.asbinary, - InequalityExpression((self.mon_npv, self.bin), False), + InequalityExpression((self.other, self.bin), False), ), - (self.mon_npv, self.zero, InequalityExpression((self.mon_npv, 0), False)), - (self.mon_npv, self.one, InequalityExpression((self.mon_npv, 1), False)), + (self.other, self.zero, InequalityExpression((self.other, 0), False)), + (self.other, self.one, InequalityExpression((self.other, 1), False)), # 4: - (self.mon_npv, self.native, InequalityExpression((self.mon_npv, 5), False)), - ( - self.mon_npv, - self.npv, - InequalityExpression((self.mon_npv, self.npv), False), - ), - (self.mon_npv, self.param, InequalityExpression((self.mon_npv, 6), False)), + (self.other, self.native, InequalityExpression((self.other, 5), False)), + (self.other, self.npv, InequalityExpression((self.other, self.npv), False)), + (self.other, self.param, InequalityExpression((self.other, 6), False)), ( - self.mon_npv, + self.other, self.param_mut, - InequalityExpression((self.mon_npv, self.param_mut), False), + InequalityExpression((self.other, self.param_mut), False), ), # 8: + (self.other, self.var, InequalityExpression((self.other, self.var), False)), ( - self.mon_npv, - self.var, - InequalityExpression((self.mon_npv, self.var), False), - ), - ( - self.mon_npv, + self.other, self.mon_native, - InequalityExpression((self.mon_npv, self.mon_native), False), + InequalityExpression((self.other, self.mon_native), False), ), ( - self.mon_npv, + self.other, self.mon_param, - InequalityExpression((self.mon_npv, self.mon_param), False), - ), - ( - self.mon_npv, - self.mon_npv, - InequalityExpression((self.mon_npv, self.mon_npv), False), + InequalityExpression((self.other, self.mon_param), False), ), - # 12: ( + self.other, self.mon_npv, - self.linear, - InequalityExpression((self.mon_npv, self.linear), False), + InequalityExpression((self.other, self.mon_npv), False), ), + # 12: ( - self.mon_npv, - self.sum, - InequalityExpression((self.mon_npv, self.sum), False), + self.other, + self.linear, + InequalityExpression((self.other, self.linear), False), ), + (self.other, self.sum, InequalityExpression((self.other, self.sum), False)), ( - self.mon_npv, self.other, - InequalityExpression((self.mon_npv, self.other), False), + self.other, + InequalityExpression((self.other, self.other), False), ), ( - self.mon_npv, + self.other, self.mutable_l0, - InequalityExpression((self.mon_npv, self.l0), False), + InequalityExpression((self.other, self.l0), False), ), # 16: ( - self.mon_npv, + self.other, self.mutable_l1, - InequalityExpression((self.mon_npv, self.l1), False), + InequalityExpression((self.other, self.l1), False), ), ( - self.mon_npv, + self.other, self.mutable_l2, - InequalityExpression((self.mon_npv, self.l2), False), + InequalityExpression((self.other, self.l2), False), ), - (self.mon_npv, self.param0, InequalityExpression((self.mon_npv, 0), False)), - (self.mon_npv, self.param1, InequalityExpression((self.mon_npv, 1), False)), + (self.other, self.param0, InequalityExpression((self.other, 0), False)), + (self.other, self.param1, InequalityExpression((self.other, 1), False)), # 20: ( - self.mon_npv, + self.other, self.mutable_l3, - InequalityExpression((self.mon_npv, self.l3), False), + InequalityExpression((self.other, self.l3), False), ), ( - self.mon_npv, + self.other, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.mon_npv, + self.other, self.le, - RangedExpression((self.mon_npv,) + self.le.args, (False, False)), + RangedExpression((self.other,) + self.le.args, (False, False)), ), ( - self.mon_npv, + self.other, self.lt, - RangedExpression((self.mon_npv,) + self.lt.args, (False, True)), + RangedExpression((self.other,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.mon_npv, + self.other, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.other, self.native2, InequalityExpression((self.other, 8), False)), + ( + self.other, + self.le2, + RangedExpression((self.other,) + self.le2.args, (False, False)), + ), + ( + self.other, + self.lt2, + RangedExpression((self.other,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_linear(self): + def test_le_mutable_l0(self): tests = [ - (self.linear, self.invalid, NotImplemented), + (self.mutable_l0, self.invalid, NotImplemented), ( - self.linear, + self.mutable_l0, self.asbinary, - InequalityExpression((self.linear, self.bin), False), + InequalityExpression((self.l0, self.bin), False), ), - (self.linear, self.zero, InequalityExpression((self.linear, 0), False)), - (self.linear, self.one, InequalityExpression((self.linear, 1), False)), + (self.mutable_l0, self.zero, True), + (self.mutable_l0, self.one, True), # 4: - (self.linear, self.native, InequalityExpression((self.linear, 5), False)), + (self.mutable_l0, self.native, True), ( - self.linear, + self.mutable_l0, self.npv, - InequalityExpression((self.linear, self.npv), False), + InequalityExpression((self.l0, self.npv), False), ), - (self.linear, self.param, InequalityExpression((self.linear, 6), False)), + (self.mutable_l0, self.param, True), ( - self.linear, + self.mutable_l0, self.param_mut, - InequalityExpression((self.linear, self.param_mut), False), + InequalityExpression((self.l0, self.param_mut), False), ), # 8: ( - self.linear, + self.mutable_l0, self.var, - InequalityExpression((self.linear, self.var), False), + InequalityExpression((self.l0, self.var), False), ), ( - self.linear, + self.mutable_l0, self.mon_native, - InequalityExpression((self.linear, self.mon_native), False), + InequalityExpression((self.l0, self.mon_native), False), ), ( - self.linear, + self.mutable_l0, self.mon_param, - InequalityExpression((self.linear, self.mon_param), False), + InequalityExpression((self.l0, self.mon_param), False), ), ( - self.linear, + self.mutable_l0, self.mon_npv, - InequalityExpression((self.linear, self.mon_npv), False), + InequalityExpression((self.l0, self.mon_npv), False), ), # 12: ( + self.mutable_l0, self.linear, - self.linear, - InequalityExpression((self.linear, self.linear), False), + InequalityExpression((self.l0, self.linear), False), ), ( - self.linear, + self.mutable_l0, self.sum, - InequalityExpression((self.linear, self.sum), False), - ), - ( - self.linear, - self.other, - InequalityExpression((self.linear, self.other), False), + InequalityExpression((self.l0, self.sum), False), ), ( - self.linear, self.mutable_l0, - InequalityExpression((self.linear, self.l0), False), + self.other, + InequalityExpression((self.l0, self.other), False), ), + (self.mutable_l0, self.mutable_l0, True), # 16: ( - self.linear, + self.mutable_l0, self.mutable_l1, - InequalityExpression((self.linear, self.l1), False), + InequalityExpression((self.l0, self.l1), False), ), ( - self.linear, + self.mutable_l0, self.mutable_l2, - InequalityExpression((self.linear, self.l2), False), + InequalityExpression((self.l0, self.l2), False), ), - (self.linear, self.param0, InequalityExpression((self.linear, 0), False)), - (self.linear, self.param1, InequalityExpression((self.linear, 1), False)), + (self.mutable_l0, self.param0, True), + (self.mutable_l0, self.param1, True), # 20: ( - self.linear, + self.mutable_l0, self.mutable_l3, - InequalityExpression((self.linear, self.l3), False), + InequalityExpression((self.l0, self.l3), False), ), ( - self.linear, + self.mutable_l0, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.linear, + self.mutable_l0, self.le, - RangedExpression(((self.linear,) + self.le.args), (False, False)), + RangedExpression((self.l0,) + self.le.args, (False, False)), ), ( - self.linear, + self.mutable_l0, self.lt, - RangedExpression(((self.linear,) + self.lt.args), (False, True)), + RangedExpression((self.l0,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.linear, + self.mutable_l0, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l0, self.native2, True), + ( + self.mutable_l0, + self.le2, + RangedExpression((self.l0,) + self.le2.args, (False, False)), + ), + (self.mutable_l0, self.lt2, self.lt2), ] self._run_cases(tests, operator.le) - def test_le_sum(self): + def test_le_mutable_l1(self): tests = [ - (self.sum, self.invalid, NotImplemented), + (self.mutable_l1, self.invalid, NotImplemented), ( - self.sum, + self.mutable_l1, self.asbinary, - InequalityExpression((self.sum, self.bin), False), + InequalityExpression((self.l1, self.bin), False), ), - (self.sum, self.zero, InequalityExpression((self.sum, 0), False)), - (self.sum, self.one, InequalityExpression((self.sum, 1), False)), + (self.mutable_l1, self.zero, InequalityExpression((self.l1, 0), False)), + (self.mutable_l1, self.one, InequalityExpression((self.l1, 1), False)), # 4: - (self.sum, self.native, InequalityExpression((self.sum, 5), False)), - (self.sum, self.npv, InequalityExpression((self.sum, self.npv), False)), - (self.sum, self.param, InequalityExpression((self.sum, 6), False)), + (self.mutable_l1, self.native, InequalityExpression((self.l1, 5), False)), ( - self.sum, + self.mutable_l1, + self.npv, + InequalityExpression((self.l1, self.npv), False), + ), + (self.mutable_l1, self.param, InequalityExpression((self.l1, 6), False)), + ( + self.mutable_l1, self.param_mut, - InequalityExpression((self.sum, self.param_mut), False), + InequalityExpression((self.l1, self.param_mut), False), ), # 8: - (self.sum, self.var, InequalityExpression((self.sum, self.var), False)), ( - self.sum, + self.mutable_l1, + self.var, + InequalityExpression((self.l1, self.var), False), + ), + ( + self.mutable_l1, self.mon_native, - InequalityExpression((self.sum, self.mon_native), False), + InequalityExpression((self.l1, self.mon_native), False), ), ( - self.sum, + self.mutable_l1, self.mon_param, - InequalityExpression((self.sum, self.mon_param), False), + InequalityExpression((self.l1, self.mon_param), False), ), ( - self.sum, + self.mutable_l1, self.mon_npv, - InequalityExpression((self.sum, self.mon_npv), False), + InequalityExpression((self.l1, self.mon_npv), False), ), # 12: ( - self.sum, + self.mutable_l1, self.linear, - InequalityExpression((self.sum, self.linear), False), + InequalityExpression((self.l1, self.linear), False), ), - (self.sum, self.sum, InequalityExpression((self.sum, self.sum), False)), - (self.sum, self.other, InequalityExpression((self.sum, self.other), False)), ( + self.mutable_l1, self.sum, + InequalityExpression((self.l1, self.sum), False), + ), + ( + self.mutable_l1, + self.other, + InequalityExpression((self.l1, self.other), False), + ), + ( + self.mutable_l1, self.mutable_l0, - InequalityExpression((self.sum, self.l0), False), + InequalityExpression((self.l1, self.l0), False), ), # 16: ( - self.sum, self.mutable_l1, - InequalityExpression((self.sum, self.l1), False), + self.mutable_l1, + InequalityExpression((self.l1, self.l1), False), ), ( - self.sum, + self.mutable_l1, self.mutable_l2, - InequalityExpression((self.sum, self.l2), False), + InequalityExpression((self.l1, self.l2), False), ), - (self.sum, self.param0, InequalityExpression((self.sum, 0), False)), - (self.sum, self.param1, InequalityExpression((self.sum, 1), False)), + (self.mutable_l1, self.param0, InequalityExpression((self.l1, 0), False)), + (self.mutable_l1, self.param1, InequalityExpression((self.l1, 1), False)), # 20: ( - self.sum, + self.mutable_l1, self.mutable_l3, - InequalityExpression((self.sum, self.l3), False), + InequalityExpression((self.l1, self.l3), False), ), ( - self.sum, + self.mutable_l1, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.sum, + self.mutable_l1, self.le, - RangedExpression((self.sum,) + self.le.args, (False, False)), + RangedExpression((self.l1,) + self.le.args, (False, False)), ), ( - self.sum, + self.mutable_l1, self.lt, - RangedExpression((self.sum,) + self.lt.args, (False, True)), + RangedExpression((self.l1,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.sum, + self.mutable_l1, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l1, self.native2, InequalityExpression((self.l1, 8), False)), + ( + self.mutable_l1, + self.le2, + RangedExpression((self.l1,) + self.le2.args, (False, False)), + ), + ( + self.mutable_l1, + self.lt2, + RangedExpression((self.l1,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_other(self): + def test_le_mutable_l2(self): tests = [ - (self.other, self.invalid, NotImplemented), + (self.mutable_l2, self.invalid, NotImplemented), + ( + self.mutable_l2, + self.asbinary, + InequalityExpression((self.l2, self.bin), False), + ), + (self.mutable_l2, self.zero, InequalityExpression((self.l2, 0), False)), + (self.mutable_l2, self.one, InequalityExpression((self.l2, 1), False)), + # 4: + (self.mutable_l2, self.native, InequalityExpression((self.l2, 5), False)), ( - self.other, - self.asbinary, - InequalityExpression((self.other, self.bin), False), + self.mutable_l2, + self.npv, + InequalityExpression((self.l2, self.npv), False), ), - (self.other, self.zero, InequalityExpression((self.other, 0), False)), - (self.other, self.one, InequalityExpression((self.other, 1), False)), - # 4: - (self.other, self.native, InequalityExpression((self.other, 5), False)), - (self.other, self.npv, InequalityExpression((self.other, self.npv), False)), - (self.other, self.param, InequalityExpression((self.other, 6), False)), + (self.mutable_l2, self.param, InequalityExpression((self.l2, 6), False)), ( - self.other, + self.mutable_l2, self.param_mut, - InequalityExpression((self.other, self.param_mut), False), + InequalityExpression((self.l2, self.param_mut), False), ), # 8: - (self.other, self.var, InequalityExpression((self.other, self.var), False)), ( - self.other, + self.mutable_l2, + self.var, + InequalityExpression((self.l2, self.var), False), + ), + ( + self.mutable_l2, self.mon_native, - InequalityExpression((self.other, self.mon_native), False), + InequalityExpression((self.l2, self.mon_native), False), ), ( - self.other, + self.mutable_l2, self.mon_param, - InequalityExpression((self.other, self.mon_param), False), + InequalityExpression((self.l2, self.mon_param), False), ), ( - self.other, + self.mutable_l2, self.mon_npv, - InequalityExpression((self.other, self.mon_npv), False), + InequalityExpression((self.l2, self.mon_npv), False), ), # 12: ( - self.other, + self.mutable_l2, self.linear, - InequalityExpression((self.other, self.linear), False), + InequalityExpression((self.l2, self.linear), False), ), - (self.other, self.sum, InequalityExpression((self.other, self.sum), False)), ( - self.other, - self.other, - InequalityExpression((self.other, self.other), False), + self.mutable_l2, + self.sum, + InequalityExpression((self.l2, self.sum), False), ), ( + self.mutable_l2, self.other, + InequalityExpression((self.l2, self.other), False), + ), + ( + self.mutable_l2, self.mutable_l0, - InequalityExpression((self.other, self.l0), False), + InequalityExpression((self.l2, self.l0), False), ), # 16: ( - self.other, + self.mutable_l2, self.mutable_l1, - InequalityExpression((self.other, self.l1), False), + InequalityExpression((self.l2, self.l1), False), ), ( - self.other, self.mutable_l2, - InequalityExpression((self.other, self.l2), False), + self.mutable_l2, + InequalityExpression((self.l2, self.l2), False), ), - (self.other, self.param0, InequalityExpression((self.other, 0), False)), - (self.other, self.param1, InequalityExpression((self.other, 1), False)), + (self.mutable_l2, self.param0, InequalityExpression((self.l2, 0), False)), + (self.mutable_l2, self.param1, InequalityExpression((self.l2, 1), False)), # 20: ( - self.other, + self.mutable_l2, self.mutable_l3, - InequalityExpression((self.other, self.l3), False), + InequalityExpression((self.l2, self.l3), False), ), ( - self.other, + self.mutable_l2, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.other, + self.mutable_l2, self.le, - RangedExpression((self.other,) + self.le.args, (False, False)), + RangedExpression((self.l2,) + self.le.args, (False, False)), ), ( - self.other, + self.mutable_l2, self.lt, - RangedExpression((self.other,) + self.lt.args, (False, True)), + RangedExpression((self.l2,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.other, + self.mutable_l2, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l2, self.native2, InequalityExpression((self.l2, 8), False)), + ( + self.mutable_l2, + self.le2, + RangedExpression((self.l2,) + self.le2.args, (False, False)), + ), + ( + self.mutable_l2, + self.lt2, + RangedExpression((self.l2,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_mutable_l0(self): + def test_le_param0(self): tests = [ - (self.mutable_l0, self.invalid, NotImplemented), - ( - self.mutable_l0, - self.asbinary, - InequalityExpression((self.l0, self.bin), False), - ), - (self.mutable_l0, self.zero, True), - (self.mutable_l0, self.one, True), + (self.param0, self.invalid, NotImplemented), + (self.param0, self.asbinary, InequalityExpression((0, self.bin), False)), + (self.param0, self.zero, True), + (self.param0, self.one, True), # 4: - (self.mutable_l0, self.native, True), - ( - self.mutable_l0, - self.npv, - InequalityExpression((self.l0, self.npv), False), - ), - (self.mutable_l0, self.param, True), + (self.param0, self.native, True), + (self.param0, self.npv, InequalityExpression((0, self.npv), False)), + (self.param0, self.param, True), ( - self.mutable_l0, + self.param0, self.param_mut, - InequalityExpression((self.l0, self.param_mut), False), + InequalityExpression((0, self.param_mut), False), ), # 8: + (self.param0, self.var, InequalityExpression((0, self.var), False)), ( - self.mutable_l0, - self.var, - InequalityExpression((self.l0, self.var), False), - ), - ( - self.mutable_l0, + self.param0, self.mon_native, - InequalityExpression((self.l0, self.mon_native), False), + InequalityExpression((0, self.mon_native), False), ), ( - self.mutable_l0, + self.param0, self.mon_param, - InequalityExpression((self.l0, self.mon_param), False), + InequalityExpression((0, self.mon_param), False), ), + (self.param0, self.mon_npv, InequalityExpression((0, self.mon_npv), False)), + # 12: + (self.param0, self.linear, InequalityExpression((0, self.linear), False)), + (self.param0, self.sum, InequalityExpression((0, self.sum), False)), + (self.param0, self.other, InequalityExpression((0, self.other), False)), + (self.param0, self.mutable_l0, True), + # 16: + (self.param0, self.mutable_l1, InequalityExpression((0, self.l1), False)), + (self.param0, self.mutable_l2, InequalityExpression((0, self.l2), False)), + (self.param0, self.param0, True), + (self.param0, self.param1, True), + # 20: + (self.param0, self.mutable_l3, InequalityExpression((0, self.l3), False)), ( - self.mutable_l0, - self.mon_npv, - InequalityExpression((self.l0, self.mon_npv), False), + self.param0, + self.eq, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), - # 12: ( - self.mutable_l0, - self.linear, - InequalityExpression((self.l0, self.linear), False), + self.param0, + self.le, + RangedExpression((0,) + self.le.args, (False, False)), ), ( - self.mutable_l0, - self.sum, - InequalityExpression((self.l0, self.sum), False), + self.param0, + self.lt, + RangedExpression((0,) + self.lt.args, (False, True)), ), + # 24: ( - self.mutable_l0, - self.other, - InequalityExpression((self.l0, self.other), False), + self.param0, + self.ranged, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), - (self.mutable_l0, self.mutable_l0, True), - # 16: + (self.param0, self.native2, True), ( - self.mutable_l0, - self.mutable_l1, - InequalityExpression((self.l0, self.l1), False), + self.param0, + self.le2, + RangedExpression((0,) + self.le2.args, (False, False)), ), + (self.param0, self.lt2, self.lt2), + ] + self._run_cases(tests, operator.le) + + def test_le_param1(self): + tests = [ + (self.param1, self.invalid, NotImplemented), + (self.param1, self.asbinary, InequalityExpression((1, self.bin), False)), + (self.param1, self.zero, False), + (self.param1, self.one, True), + # 4: + (self.param1, self.native, True), + (self.param1, self.npv, InequalityExpression((1, self.npv), False)), + (self.param1, self.param, True), ( - self.mutable_l0, - self.mutable_l2, - InequalityExpression((self.l0, self.l2), False), + self.param1, + self.param_mut, + InequalityExpression((1, self.param_mut), False), ), - (self.mutable_l0, self.param0, True), - (self.mutable_l0, self.param1, True), - # 20: + # 8: + (self.param1, self.var, InequalityExpression((1, self.var), False)), ( - self.mutable_l0, - self.mutable_l3, - InequalityExpression((self.l0, self.l3), False), + self.param1, + self.mon_native, + InequalityExpression((1, self.mon_native), False), ), ( - self.mutable_l0, + self.param1, + self.mon_param, + InequalityExpression((1, self.mon_param), False), + ), + (self.param1, self.mon_npv, InequalityExpression((1, self.mon_npv), False)), + # 12: + (self.param1, self.linear, InequalityExpression((1, self.linear), False)), + (self.param1, self.sum, InequalityExpression((1, self.sum), False)), + (self.param1, self.other, InequalityExpression((1, self.other), False)), + (self.param1, self.mutable_l0, False), + # 16: + (self.param1, self.mutable_l1, InequalityExpression((1, self.l1), False)), + (self.param1, self.mutable_l2, InequalityExpression((1, self.l2), False)), + (self.param1, self.param0, False), + (self.param1, self.param1, True), + # 20: + (self.param1, self.mutable_l3, InequalityExpression((1, self.l3), False)), + ( + self.param1, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.mutable_l0, + self.param1, self.le, - RangedExpression((self.l0,) + self.le.args, (False, False)), + RangedExpression((1,) + self.le.args, (False, False)), ), ( - self.mutable_l0, + self.param1, self.lt, - RangedExpression((self.l0,) + self.lt.args, (False, True)), + RangedExpression((1,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.mutable_l0, + self.param1, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param1, self.native2, True), + ( + self.param1, + self.le2, + RangedExpression((1,) + self.le2.args, (False, False)), + ), + (self.param1, self.lt2, self.lt2), ] self._run_cases(tests, operator.le) - def test_le_mutable_l1(self): + def test_le_mutable_l3(self): tests = [ - (self.mutable_l1, self.invalid, NotImplemented), + (self.mutable_l3, self.invalid, NotImplemented), ( - self.mutable_l1, + self.mutable_l3, self.asbinary, - InequalityExpression((self.l1, self.bin), False), + InequalityExpression((self.l3, self.bin), False), ), - (self.mutable_l1, self.zero, InequalityExpression((self.l1, 0), False)), - (self.mutable_l1, self.one, InequalityExpression((self.l1, 1), False)), + (self.mutable_l3, self.zero, InequalityExpression((self.l3, 0), False)), + (self.mutable_l3, self.one, InequalityExpression((self.l3, 1), False)), # 4: - (self.mutable_l1, self.native, InequalityExpression((self.l1, 5), False)), + (self.mutable_l3, self.native, InequalityExpression((self.l3, 5), False)), ( - self.mutable_l1, + self.mutable_l3, self.npv, - InequalityExpression((self.l1, self.npv), False), + InequalityExpression((self.l3, self.npv), False), ), - (self.mutable_l1, self.param, InequalityExpression((self.l1, 6), False)), + (self.mutable_l3, self.param, InequalityExpression((self.l3, 6), False)), ( - self.mutable_l1, + self.mutable_l3, self.param_mut, - InequalityExpression((self.l1, self.param_mut), False), + InequalityExpression((self.l3, self.param_mut), False), ), # 8: ( - self.mutable_l1, + self.mutable_l3, self.var, - InequalityExpression((self.l1, self.var), False), + InequalityExpression((self.l3, self.var), False), ), ( - self.mutable_l1, + self.mutable_l3, self.mon_native, - InequalityExpression((self.l1, self.mon_native), False), + InequalityExpression((self.l3, self.mon_native), False), ), ( - self.mutable_l1, + self.mutable_l3, self.mon_param, - InequalityExpression((self.l1, self.mon_param), False), + InequalityExpression((self.l3, self.mon_param), False), ), ( - self.mutable_l1, + self.mutable_l3, self.mon_npv, - InequalityExpression((self.l1, self.mon_npv), False), + InequalityExpression((self.l3, self.mon_npv), False), ), # 12: ( - self.mutable_l1, + self.mutable_l3, self.linear, - InequalityExpression((self.l1, self.linear), False), + InequalityExpression((self.l3, self.linear), False), ), ( - self.mutable_l1, + self.mutable_l3, self.sum, - InequalityExpression((self.l1, self.sum), False), + InequalityExpression((self.l3, self.sum), False), ), ( - self.mutable_l1, + self.mutable_l3, self.other, - InequalityExpression((self.l1, self.other), False), + InequalityExpression((self.l3, self.other), False), ), ( - self.mutable_l1, + self.mutable_l3, self.mutable_l0, - InequalityExpression((self.l1, self.l0), False), + InequalityExpression((self.l3, self.l0), False), ), # 16: ( + self.mutable_l3, self.mutable_l1, - self.mutable_l1, - InequalityExpression((self.l1, self.l1), False), + InequalityExpression((self.l3, self.l1), False), ), ( - self.mutable_l1, + self.mutable_l3, self.mutable_l2, - InequalityExpression((self.l1, self.l2), False), + InequalityExpression((self.l3, self.l2), False), ), - (self.mutable_l1, self.param0, InequalityExpression((self.l1, 0), False)), - (self.mutable_l1, self.param1, InequalityExpression((self.l1, 1), False)), + (self.mutable_l3, self.param0, InequalityExpression((self.l3, 0), False)), + (self.mutable_l3, self.param1, InequalityExpression((self.l3, 1), False)), # 20: ( - self.mutable_l1, self.mutable_l3, - InequalityExpression((self.l1, self.l3), False), + self.mutable_l3, + InequalityExpression((self.l3, self.l3), False), ), ( - self.mutable_l1, + self.mutable_l3, self.eq, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.mutable_l1, + self.mutable_l3, self.le, - RangedExpression((self.l1,) + self.le.args, (False, False)), + RangedExpression((self.l3,) + self.le.args, (False, False)), ), ( - self.mutable_l1, + self.mutable_l3, self.lt, - RangedExpression((self.l1,) + self.lt.args, (False, True)), + RangedExpression((self.l3,) + self.lt.args, (False, True)), ), - # 24 + # 24: ( - self.mutable_l1, + self.mutable_l3, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l3, self.native2, InequalityExpression((self.l3, 8), False)), + ( + self.mutable_l3, + self.le2, + RangedExpression((self.l3,) + self.le2.args, (False, False)), + ), + ( + self.mutable_l3, + self.lt2, + RangedExpression((self.l3,) + self.lt2.args, (False, True)), + ), ] self._run_cases(tests, operator.le) - def test_le_mutable_l2(self): + def test_le_eq(self): tests = [ - (self.mutable_l2, self.invalid, NotImplemented), + (self.eq, self.invalid, NotImplemented), ( - self.mutable_l2, + self.eq, self.asbinary, - InequalityExpression((self.l2, self.bin), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, + self.zero, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, + self.one, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), - (self.mutable_l2, self.zero, InequalityExpression((self.l2, 0), False)), - (self.mutable_l2, self.one, InequalityExpression((self.l2, 1), False)), # 4: - (self.mutable_l2, self.native, InequalityExpression((self.l2, 5), False)), ( - self.mutable_l2, + self.eq, + self.native, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, self.npv, - InequalityExpression((self.l2, self.npv), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), - (self.mutable_l2, self.param, InequalityExpression((self.l2, 6), False)), ( - self.mutable_l2, + self.eq, + self.param, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, self.param_mut, - InequalityExpression((self.l2, self.param_mut), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), # 8: ( - self.mutable_l2, + self.eq, self.var, - InequalityExpression((self.l2, self.var), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.mutable_l2, + self.eq, self.mon_native, - InequalityExpression((self.l2, self.mon_native), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.mutable_l2, + self.eq, self.mon_param, - InequalityExpression((self.l2, self.mon_param), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.mutable_l2, + self.eq, self.mon_npv, - InequalityExpression((self.l2, self.mon_npv), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), # 12: ( - self.mutable_l2, + self.eq, self.linear, - InequalityExpression((self.l2, self.linear), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.mutable_l2, + self.eq, self.sum, - InequalityExpression((self.l2, self.sum), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.mutable_l2, + self.eq, self.other, - InequalityExpression((self.l2, self.other), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.mutable_l2, + self.eq, self.mutable_l0, - InequalityExpression((self.l2, self.l0), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), # 16: ( - self.mutable_l2, + self.eq, self.mutable_l1, - InequalityExpression((self.l2, self.l1), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( + self.eq, self.mutable_l2, - self.mutable_l2, - InequalityExpression((self.l2, self.l2), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, + self.param0, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, + self.param1, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), - (self.mutable_l2, self.param0, InequalityExpression((self.l2, 0), False)), - (self.mutable_l2, self.param1, InequalityExpression((self.l2, 1), False)), # 20: ( - self.mutable_l2, + self.eq, self.mutable_l3, - InequalityExpression((self.l2, self.l3), False), + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, + self.eq, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.eq, + self.le, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.eq, + self.lt, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + # 24: + ( + self.eq, + self.ranged, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), ( - self.mutable_l2, self.eq, + self.native2, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.mutable_l2, + self.eq, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.eq, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ] + self._run_cases(tests, operator.le) + + def test_le_le(self): + tests = [ + (self.le, self.invalid, NotImplemented), + ( self.le, - RangedExpression((self.l2,) + self.le.args, (False, False)), + self.asbinary, + RangedExpression((self.le.args + (self.bin,)), (False, False)), ), ( - self.mutable_l2, - self.lt, - RangedExpression((self.l2,) + self.lt.args, (False, True)), + self.le, + self.zero, + RangedExpression((self.le.args + (0,)), (False, False)), + ), + ( + self.le, + self.one, + RangedExpression((self.le.args + (1,)), (False, False)), + ), + # 4: + ( + self.le, + self.native, + RangedExpression((self.le.args + (5,)), (False, False)), + ), + ( + self.le, + self.npv, + RangedExpression((self.le.args + (self.npv,)), (False, False)), ), - # 24 ( - self.mutable_l2, - self.ranged, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + self.le, + self.param, + RangedExpression((self.le.args + (6,)), (False, False)), ), - ] - self._run_cases(tests, operator.le) - - def test_le_param0(self): - tests = [ - (self.param0, self.invalid, NotImplemented), - (self.param0, self.asbinary, InequalityExpression((0, self.bin), False)), - (self.param0, self.zero, True), - (self.param0, self.one, True), - # 4: - (self.param0, self.native, True), - (self.param0, self.npv, InequalityExpression((0, self.npv), False)), - (self.param0, self.param, True), ( - self.param0, + self.le, self.param_mut, - InequalityExpression((0, self.param_mut), False), + RangedExpression((self.le.args + (self.param_mut,)), (False, False)), ), # 8: - (self.param0, self.var, InequalityExpression((0, self.var), False)), ( - self.param0, + self.le, + self.var, + RangedExpression((self.le.args + (self.var,)), (False, False)), + ), + ( + self.le, self.mon_native, - InequalityExpression((0, self.mon_native), False), + RangedExpression((self.le.args + (self.mon_native,)), (False, False)), ), ( - self.param0, + self.le, self.mon_param, - InequalityExpression((0, self.mon_param), False), + RangedExpression((self.le.args + (self.mon_param,)), (False, False)), + ), + ( + self.le, + self.mon_npv, + RangedExpression((self.le.args + (self.mon_npv,)), (False, False)), ), - (self.param0, self.mon_npv, InequalityExpression((0, self.mon_npv), False)), # 12: - (self.param0, self.linear, InequalityExpression((0, self.linear), False)), - (self.param0, self.sum, InequalityExpression((0, self.sum), False)), - (self.param0, self.other, InequalityExpression((0, self.other), False)), - (self.param0, self.mutable_l0, True), - # 16: - (self.param0, self.mutable_l1, InequalityExpression((0, self.l1), False)), - (self.param0, self.mutable_l2, InequalityExpression((0, self.l2), False)), - (self.param0, self.param0, True), - (self.param0, self.param1, True), - # 20: - (self.param0, self.mutable_l3, InequalityExpression((0, self.l3), False)), ( - self.param0, - self.eq, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + self.le, + self.linear, + RangedExpression((self.le.args + (self.linear,)), (False, False)), ), ( - self.param0, self.le, - RangedExpression((0,) + self.le.args, (False, False)), + self.sum, + RangedExpression((self.le.args + (self.sum,)), (False, False)), ), ( - self.param0, - self.lt, - RangedExpression((0,) + self.lt.args, (False, True)), + self.le, + self.other, + RangedExpression((self.le.args + (self.other,)), (False, False)), ), - # 24 ( - self.param0, - self.ranged, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + self.le, + self.mutable_l0, + RangedExpression((self.le.args + (self.l0,)), (False, False)), ), - ] - self._run_cases(tests, operator.le) - - def test_le_param1(self): - tests = [ - (self.param1, self.invalid, NotImplemented), - (self.param1, self.asbinary, InequalityExpression((1, self.bin), False)), - (self.param1, self.zero, False), - (self.param1, self.one, True), - # 4: - (self.param1, self.native, True), - (self.param1, self.npv, InequalityExpression((1, self.npv), False)), - (self.param1, self.param, True), + # 16: ( - self.param1, - self.param_mut, - InequalityExpression((1, self.param_mut), False), + self.le, + self.mutable_l1, + RangedExpression((self.le.args + (self.l1,)), (False, False)), ), - # 8: - (self.param1, self.var, InequalityExpression((1, self.var), False)), ( - self.param1, - self.mon_native, - InequalityExpression((1, self.mon_native), False), + self.le, + self.mutable_l2, + RangedExpression((self.le.args + (self.l2,)), (False, False)), + ), + ( + self.le, + self.param0, + RangedExpression((self.le.args + (0,)), (False, False)), ), ( + self.le, self.param1, - self.mon_param, - InequalityExpression((1, self.mon_param), False), + RangedExpression((self.le.args + (1,)), (False, False)), ), - (self.param1, self.mon_npv, InequalityExpression((1, self.mon_npv), False)), - # 12: - (self.param1, self.linear, InequalityExpression((1, self.linear), False)), - (self.param1, self.sum, InequalityExpression((1, self.sum), False)), - (self.param1, self.other, InequalityExpression((1, self.other), False)), - (self.param1, self.mutable_l0, False), - # 16: - (self.param1, self.mutable_l1, InequalityExpression((1, self.l1), False)), - (self.param1, self.mutable_l2, InequalityExpression((1, self.l2), False)), - (self.param1, self.param0, False), - (self.param1, self.param1, True), # 20: - (self.param1, self.mutable_l3, InequalityExpression((1, self.l3), False)), ( - self.param1, + self.le, + self.mutable_l3, + RangedExpression((self.le.args + (self.l3,)), (False, False)), + ), + ( + self.le, self.eq, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), ( - self.param1, self.le, - RangedExpression((1,) + self.le.args, (False, False)), + self.le, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), ( - self.param1, + self.le, self.lt, - RangedExpression((1,) + self.lt.args, (False, True)), + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), - # 24 + # 24: ( - self.param1, + self.le, self.ranged, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le, + self.native2, + RangedExpression((self.le.args + (8,)), (False, False)), + ), + ( + self.le, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), ] self._run_cases(tests, operator.le) - def test_le_mutable_l3(self): + def test_le_lt(self): tests = [ - (self.mutable_l3, self.invalid, NotImplemented), + (self.lt, self.invalid, NotImplemented), ( - self.mutable_l3, + self.lt, self.asbinary, - InequalityExpression((self.l3, self.bin), False), + RangedExpression((self.lt.args + (self.bin,)), (True, False)), ), - (self.mutable_l3, self.zero, InequalityExpression((self.l3, 0), False)), - (self.mutable_l3, self.one, InequalityExpression((self.l3, 1), False)), + (self.lt, self.zero, False), + (self.lt, self.one, False), # 4: - (self.mutable_l3, self.native, InequalityExpression((self.l3, 5), False)), + (self.lt, self.native, False), ( - self.mutable_l3, + self.lt, self.npv, - InequalityExpression((self.l3, self.npv), False), + RangedExpression((self.lt.args + (self.npv,)), (True, False)), ), - (self.mutable_l3, self.param, InequalityExpression((self.l3, 6), False)), + (self.lt, self.param, self.lt), ( - self.mutable_l3, + self.lt, self.param_mut, - InequalityExpression((self.l3, self.param_mut), False), + RangedExpression((self.lt.args + (self.param_mut,)), (True, False)), ), # 8: ( - self.mutable_l3, + self.lt, self.var, - InequalityExpression((self.l3, self.var), False), + RangedExpression((self.lt.args + (self.var,)), (True, False)), ), ( - self.mutable_l3, + self.lt, self.mon_native, - InequalityExpression((self.l3, self.mon_native), False), + RangedExpression((self.lt.args + (self.mon_native,)), (True, False)), ), ( - self.mutable_l3, + self.lt, self.mon_param, - InequalityExpression((self.l3, self.mon_param), False), + RangedExpression((self.lt.args + (self.mon_param,)), (True, False)), ), ( - self.mutable_l3, + self.lt, self.mon_npv, - InequalityExpression((self.l3, self.mon_npv), False), + RangedExpression((self.lt.args + (self.mon_npv,)), (True, False)), ), # 12: ( - self.mutable_l3, + self.lt, self.linear, - InequalityExpression((self.l3, self.linear), False), + RangedExpression((self.lt.args + (self.linear,)), (True, False)), ), ( - self.mutable_l3, + self.lt, self.sum, - InequalityExpression((self.l3, self.sum), False), + RangedExpression((self.lt.args + (self.sum,)), (True, False)), ), ( - self.mutable_l3, + self.lt, self.other, - InequalityExpression((self.l3, self.other), False), - ), - ( - self.mutable_l3, - self.mutable_l0, - InequalityExpression((self.l3, self.l0), False), + RangedExpression((self.lt.args + (self.other,)), (True, False)), ), + (self.lt, self.mutable_l0, False), # 16: ( - self.mutable_l3, + self.lt, self.mutable_l1, - InequalityExpression((self.l3, self.l1), False), + RangedExpression((self.lt.args + (self.l1,)), (True, False)), ), ( - self.mutable_l3, + self.lt, self.mutable_l2, - InequalityExpression((self.l3, self.l2), False), + RangedExpression((self.lt.args + (self.l2,)), (True, False)), ), - (self.mutable_l3, self.param0, InequalityExpression((self.l3, 0), False)), - (self.mutable_l3, self.param1, InequalityExpression((self.l3, 1), False)), + (self.lt, self.param0, False), + (self.lt, self.param1, False), # 20: ( + self.lt, self.mutable_l3, - self.mutable_l3, - InequalityExpression((self.l3, self.l3), False), + RangedExpression((self.lt.args + (self.l3,)), (True, False)), ), ( - self.mutable_l3, + self.lt, self.eq, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt, + self.le, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt, + self.lt, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), + # 24: ( - self.mutable_l3, - self.le, - RangedExpression((self.l3,) + self.le.args, (False, False)), + self.lt, + self.ranged, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), + (self.lt, self.native2, self.lt), ( - self.mutable_l3, self.lt, - RangedExpression((self.l3,) + self.lt.args, (False, True)), + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), - # 24 ( - self.mutable_l3, - self.ranged, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + self.lt, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), ] self._run_cases(tests, operator.le) - def test_le_eq(self): + def test_le_ranged(self): tests = [ - (self.eq, self.invalid, NotImplemented), + (self.ranged, self.invalid, NotImplemented), ( - self.eq, + self.ranged, self.asbinary, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.zero, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.one, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), # 4: ( - self.eq, + self.ranged, self.native, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.npv, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.param, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.param_mut, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), # 8: ( - self.eq, + self.ranged, self.var, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.mon_native, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.mon_param, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.mon_npv, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), # 12: ( - self.eq, + self.ranged, self.linear, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.sum, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.other, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.mutable_l0, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), # 16: ( - self.eq, + self.ranged, self.mutable_l1, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.mutable_l2, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.param0, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.param1, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), # 20: ( - self.eq, + self.ranged, self.mutable_l3, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), ( - self.eq, + self.ranged, self.eq, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), ( - self.eq, + self.ranged, self.le, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), ( - self.eq, + self.ranged, self.lt, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( - self.eq, + self.ranged, self.ranged, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), - ] - self._run_cases(tests, operator.le) - - def test_le_le(self): - tests = [ - (self.le, self.invalid, NotImplemented), ( - self.le, - self.asbinary, - RangedExpression((self.le.args + (self.bin,)), (False, False)), + self.ranged, + self.native2, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( - self.le, - self.zero, - RangedExpression((self.le.args + (0,)), (False, False)), + self.ranged, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), ( - self.le, - self.one, - RangedExpression((self.le.args + (1,)), (False, False)), + self.ranged, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), + ] + self._run_cases(tests, operator.le) + + def test_le_native2(self): + tests = [ + (self.native2, self.invalid, NotImplemented), + (self.native2, self.asbinary, InequalityExpression((8, self.bin), False)), + (self.native2, self.zero, False), + (self.native2, self.one, False), # 4: + (self.native2, self.native, False), + (self.native2, self.npv, InequalityExpression((8, self.npv), False)), + (self.native2, self.param, False), ( - self.le, - self.native, - RangedExpression((self.le.args + (5,)), (False, False)), - ), - ( - self.le, - self.npv, - RangedExpression((self.le.args + (self.npv,)), (False, False)), - ), - ( - self.le, - self.param, - RangedExpression((self.le.args + (6,)), (False, False)), - ), - ( - self.le, + self.native2, self.param_mut, - RangedExpression((self.le.args + (self.param_mut,)), (False, False)), + InequalityExpression((8, self.param_mut), False), ), # 8: + (self.native2, self.var, InequalityExpression((8, self.var), False)), ( - self.le, - self.var, - RangedExpression((self.le.args + (self.var,)), (False, False)), - ), - ( - self.le, + self.native2, self.mon_native, - RangedExpression((self.le.args + (self.mon_native,)), (False, False)), + InequalityExpression((8, self.mon_native), False), ), ( - self.le, + self.native2, self.mon_param, - RangedExpression((self.le.args + (self.mon_param,)), (False, False)), + InequalityExpression((8, self.mon_param), False), ), ( - self.le, + self.native2, self.mon_npv, - RangedExpression((self.le.args + (self.mon_npv,)), (False, False)), + InequalityExpression((8, self.mon_npv), False), ), # 12: - ( - self.le, - self.linear, - RangedExpression((self.le.args + (self.linear,)), (False, False)), - ), - ( - self.le, - self.sum, - RangedExpression((self.le.args + (self.sum,)), (False, False)), - ), - ( - self.le, - self.other, - RangedExpression((self.le.args + (self.other,)), (False, False)), - ), - ( - self.le, - self.mutable_l0, - RangedExpression((self.le.args + (self.l0,)), (False, False)), - ), + (self.native2, self.linear, InequalityExpression((8, self.linear), False)), + (self.native2, self.sum, InequalityExpression((8, self.sum), False)), + (self.native2, self.other, InequalityExpression((8, self.other), False)), + (self.native2, self.mutable_l0, False), # 16: - ( - self.le, - self.mutable_l1, - RangedExpression((self.le.args + (self.l1,)), (False, False)), - ), - ( - self.le, - self.mutable_l2, - RangedExpression((self.le.args + (self.l2,)), (False, False)), - ), - ( - self.le, - self.param0, - RangedExpression((self.le.args + (0,)), (False, False)), - ), - ( - self.le, - self.param1, - RangedExpression((self.le.args + (1,)), (False, False)), - ), + (self.native2, self.mutable_l1, InequalityExpression((8, self.l1), False)), + (self.native2, self.mutable_l2, InequalityExpression((8, self.l2), False)), + (self.native2, self.param0, False), + (self.native2, self.param1, False), # 20: + (self.native2, self.mutable_l3, InequalityExpression((8, self.l3), False)), ( - self.le, - self.mutable_l3, - RangedExpression((self.le.args + (self.l3,)), (False, False)), - ), - ( - self.le, + self.native2, self.eq, - "Cannot create an InequalityExpression where both " - "sub-expressions are relational expressions", + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), ( + self.native2, self.le, - self.le, - "Cannot create an InequalityExpression where both " - "sub-expressions are relational expressions", + RangedExpression((8,) + self.le.args, (False, False)), ), + (self.native2, self.lt, False), + # 24: ( - self.le, - self.lt, - "Cannot create an InequalityExpression where both " - "sub-expressions are relational expressions", + self.native2, + self.ranged, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", ), - # 24 + (self.native2, self.native2, True), ( - self.le, - self.ranged, - "Cannot create an InequalityExpression where both " - "sub-expressions are relational expressions", + self.native2, + self.le2, + RangedExpression((8,) + self.le2.args, (False, False)), ), + (self.native2, self.lt2, False), ] self._run_cases(tests, operator.le) - def test_le_lt(self): + def test_le_le2(self): tests = [ - (self.lt, self.invalid, NotImplemented), + (self.le2, self.invalid, NotImplemented), ( - self.lt, + self.le2, self.asbinary, - RangedExpression((self.lt.args + (self.bin,)), (True, False)), + RangedExpression((self.le2.args + (self.bin,)), (False, False)), ), ( - self.lt, + self.le2, self.zero, - RangedExpression((self.lt.args + (0,)), (True, False)), + RangedExpression((self.le2.args + (0,)), (False, False)), + ), + ( + self.le2, + self.one, + RangedExpression((self.le2.args + (1,)), (False, False)), ), - (self.lt, self.one, RangedExpression((self.lt.args + (1,)), (True, False))), # 4: ( - self.lt, + self.le2, self.native, - RangedExpression((self.lt.args + (5,)), (True, False)), + RangedExpression((self.le2.args + (5,)), (False, False)), ), ( - self.lt, + self.le2, self.npv, - RangedExpression((self.lt.args + (self.npv,)), (True, False)), + RangedExpression((self.le2.args + (self.npv,)), (False, False)), ), ( - self.lt, + self.le2, self.param, - RangedExpression((self.lt.args + (6,)), (True, False)), + RangedExpression((self.le2.args + (6,)), (False, False)), ), ( - self.lt, + self.le2, self.param_mut, - RangedExpression((self.lt.args + (self.param_mut,)), (True, False)), + RangedExpression((self.le2.args + (self.param_mut,)), (False, False)), ), # 8: ( - self.lt, + self.le2, self.var, - RangedExpression((self.lt.args + (self.var,)), (True, False)), + RangedExpression((self.le2.args + (self.var,)), (False, False)), ), ( - self.lt, + self.le2, self.mon_native, - RangedExpression((self.lt.args + (self.mon_native,)), (True, False)), + RangedExpression((self.le2.args + (self.mon_native,)), (False, False)), ), ( - self.lt, + self.le2, self.mon_param, - RangedExpression((self.lt.args + (self.mon_param,)), (True, False)), + RangedExpression((self.le2.args + (self.mon_param,)), (False, False)), ), ( - self.lt, + self.le2, self.mon_npv, - RangedExpression((self.lt.args + (self.mon_npv,)), (True, False)), + RangedExpression((self.le2.args + (self.mon_npv,)), (False, False)), ), # 12: ( - self.lt, + self.le2, self.linear, - RangedExpression((self.lt.args + (self.linear,)), (True, False)), + RangedExpression((self.le2.args + (self.linear,)), (False, False)), ), ( - self.lt, + self.le2, self.sum, - RangedExpression((self.lt.args + (self.sum,)), (True, False)), + RangedExpression((self.le2.args + (self.sum,)), (False, False)), ), ( - self.lt, + self.le2, self.other, - RangedExpression((self.lt.args + (self.other,)), (True, False)), + RangedExpression((self.le2.args + (self.other,)), (False, False)), ), ( - self.lt, + self.le2, self.mutable_l0, - RangedExpression((self.lt.args + (self.l0,)), (True, False)), + RangedExpression((self.le2.args + (self.l0,)), (False, False)), ), # 16: ( - self.lt, + self.le2, self.mutable_l1, - RangedExpression((self.lt.args + (self.l1,)), (True, False)), + RangedExpression((self.le2.args + (self.l1,)), (False, False)), ), ( - self.lt, + self.le2, self.mutable_l2, - RangedExpression((self.lt.args + (self.l2,)), (True, False)), + RangedExpression((self.le2.args + (self.l2,)), (False, False)), ), ( - self.lt, + self.le2, self.param0, - RangedExpression((self.lt.args + (0,)), (True, False)), + RangedExpression((self.le2.args + (0,)), (False, False)), ), ( - self.lt, + self.le2, self.param1, - RangedExpression((self.lt.args + (1,)), (True, False)), + RangedExpression((self.le2.args + (1,)), (False, False)), ), # 20: ( - self.lt, + self.le2, self.mutable_l3, - RangedExpression((self.lt.args + (self.l3,)), (True, False)), + RangedExpression((self.le2.args + (self.l3,)), (False, False)), ), ( - self.lt, + self.le2, self.eq, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), ( - self.lt, + self.le2, self.le, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), ( - self.lt, + self.le2, self.lt, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( - self.lt, + self.le2, self.ranged, "Cannot create an InequalityExpression where both " - "sub-expressions are relational expressions", - ), - ] - self._run_cases(tests, operator.le) - - def test_le_ranged(self): - tests = [ - (self.ranged, self.invalid, NotImplemented), - ( - self.ranged, - self.asbinary, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", - ), - ( - self.ranged, - self.zero, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + "sub-expressions are relational expressions", ), ( - self.ranged, - self.one, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + self.le2, + self.native2, + RangedExpression((self.le2.args + (8,)), (False, False)), ), - # 4: ( - self.ranged, - self.native, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + self.le2, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), ( - self.ranged, - self.npv, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + self.le2, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", ), + ] + self._run_cases(tests, operator.le) + + def test_le_lt2(self): + tests = [ + (self.lt2, self.invalid, NotImplemented), ( - self.ranged, - self.param, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + self.lt2, + self.asbinary, + RangedExpression((self.lt2.args + (self.bin,)), (True, False)), + ), + (self.lt2, self.zero, False), + (self.lt2, self.one, False), + # 4: + (self.lt2, self.native, False), + ( + self.lt2, + self.npv, + RangedExpression((self.lt2.args + (self.npv,)), (True, False)), ), + (self.lt2, self.param, False), ( - self.ranged, + self.lt2, self.param_mut, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.param_mut,)), (True, False)), ), # 8: ( - self.ranged, + self.lt2, self.var, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.var,)), (True, False)), ), ( - self.ranged, + self.lt2, self.mon_native, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.mon_native,)), (True, False)), ), ( - self.ranged, + self.lt2, self.mon_param, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.mon_param,)), (True, False)), ), ( - self.ranged, + self.lt2, self.mon_npv, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.mon_npv,)), (True, False)), ), # 12: ( - self.ranged, + self.lt2, self.linear, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.linear,)), (True, False)), ), ( - self.ranged, + self.lt2, self.sum, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.sum,)), (True, False)), ), ( - self.ranged, + self.lt2, self.other, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", - ), - ( - self.ranged, - self.mutable_l0, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.other,)), (True, False)), ), + (self.lt2, self.mutable_l0, False), # 16: ( - self.ranged, + self.lt2, self.mutable_l1, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.l1,)), (True, False)), ), ( - self.ranged, + self.lt2, self.mutable_l2, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", - ), - ( - self.ranged, - self.param0, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", - ), - ( - self.ranged, - self.param1, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.l2,)), (True, False)), ), + (self.lt2, self.param0, False), + (self.lt2, self.param1, False), # 20: ( - self.ranged, + self.lt2, self.mutable_l3, - "Cannot create an InequalityExpression where one of the " - "sub-expressions is a relational expression", + RangedExpression((self.lt2.args + (self.l3,)), (True, False)), ), ( - self.ranged, + self.lt2, self.eq, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), ( - self.ranged, + self.lt2, self.le, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), ( - self.ranged, + self.lt2, self.lt, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( + self.lt2, self.ranged, - self.ranged, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.native2, + RangedExpression((self.lt2.args + (8,)), (True, False)), + ), + ( + self.lt2, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.lt2, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), @@ -4793,6 +6156,9 @@ def test_lt_invalid(self): (self.invalid, self.lt, NotImplemented), # 24: (self.invalid, self.ranged, NotImplemented), + (self.invalid, self.native2, NotImplemented), + (self.invalid, self.le2, NotImplemented), + (self.invalid, self.lt2, NotImplemented), ] self._run_cases(tests, operator.lt) @@ -4884,13 +6250,24 @@ def test_lt_asbinary(self): self.lt, RangedExpression((self.bin,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.asbinary, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.asbinary, self.native2, InequalityExpression((self.bin, 8), True)), + ( + self.asbinary, + self.le2, + RangedExpression((self.bin,) + self.le2.args, (True, False)), + ), + ( + self.asbinary, + self.lt2, + RangedExpression((self.bin,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -4942,13 +6319,20 @@ def test_lt_zero(self): ), (self.zero, self.le, RangedExpression((0,) + self.le.args, (True, False))), (self.zero, self.lt, RangedExpression((0,) + self.lt.args, (True, True))), - # 24 + # 24: ( self.zero, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.zero, self.native2, True), + ( + self.zero, + self.le2, + RangedExpression((0,) + self.le2.args, (True, False)), + ), + (self.zero, self.lt2, self.lt2), ] self._run_cases(tests, operator.lt) @@ -4992,13 +6376,16 @@ def test_lt_one(self): ), (self.one, self.le, RangedExpression((1,) + self.le.args, (True, False))), (self.one, self.lt, RangedExpression((1,) + self.lt.args, (True, True))), - # 24 + # 24: ( self.one, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.one, self.native2, True), + (self.one, self.le2, RangedExpression((1,) + self.le2.args, (True, False))), + (self.one, self.lt2, self.lt2), ] self._run_cases(tests, operator.lt) @@ -5054,13 +6441,20 @@ def test_lt_native(self): RangedExpression((5,) + self.le.args, (True, False)), ), (self.native, self.lt, RangedExpression((5,) + self.lt.args, (True, True))), - # 24 + # 24: ( self.native, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.native, self.native2, True), + ( + self.native, + self.le2, + RangedExpression((5,) + self.le2.args, (True, False)), + ), + (self.native, self.lt2, self.lt2), ] self._run_cases(tests, operator.lt) @@ -5144,13 +6538,24 @@ def test_lt_npv(self): self.lt, RangedExpression((self.npv,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.npv, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.npv, self.native2, InequalityExpression((self.npv, 8), True)), + ( + self.npv, + self.le2, + RangedExpression((self.npv,) + self.le2.args, (True, False)), + ), + ( + self.npv, + self.lt2, + RangedExpression((self.npv,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -5201,14 +6606,21 @@ def test_lt_param(self): "sub-expressions is a relational expression", ), (self.param, self.le, RangedExpression((6,) + self.le.args, (True, False))), - (self.param, self.lt, RangedExpression((6,) + self.lt.args, (True, True))), - # 24 + (self.param, self.lt, False), + # 24: ( self.param, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param, self.native2, True), + ( + self.param, + self.le2, + RangedExpression((6,) + self.le2.args, (True, False)), + ), + (self.param, self.lt2, False), ] self._run_cases(tests, operator.lt) @@ -5332,13 +6744,28 @@ def test_lt_param_mut(self): self.lt, RangedExpression((self.param_mut,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.param_mut, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + ( + self.param_mut, + self.native2, + InequalityExpression((self.param_mut, 8), True), + ), + ( + self.param_mut, + self.le2, + RangedExpression((self.param_mut,) + self.le2.args, (True, False)), + ), + ( + self.param_mut, + self.lt2, + RangedExpression((self.param_mut,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -5422,13 +6849,24 @@ def test_lt_var(self): self.lt, RangedExpression((self.var,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.var, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.var, self.native2, InequalityExpression((self.var, 8), True)), + ( + self.var, + self.le2, + RangedExpression((self.var,) + self.le2.args, (True, False)), + ), + ( + self.var, + self.lt2, + RangedExpression((self.var,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -5556,13 +6994,28 @@ def test_lt_mon_native(self): self.lt, RangedExpression((self.mon_native,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.mon_native, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + ( + self.mon_native, + self.native2, + InequalityExpression((self.mon_native, 8), True), + ), + ( + self.mon_native, + self.le2, + RangedExpression((self.mon_native,) + self.le2.args, (True, False)), + ), + ( + self.mon_native, + self.lt2, + RangedExpression((self.mon_native,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -5686,13 +7139,28 @@ def test_lt_mon_param(self): self.lt, RangedExpression((self.mon_param,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.mon_param, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + ( + self.mon_param, + self.native2, + InequalityExpression((self.mon_param, 8), True), + ), + ( + self.mon_param, + self.le2, + RangedExpression((self.mon_param,) + self.le2.args, (True, False)), + ), + ( + self.mon_param, + self.lt2, + RangedExpression((self.mon_param,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -5796,13 +7264,24 @@ def test_lt_mon_npv(self): self.lt, RangedExpression((self.mon_npv,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.mon_npv, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mon_npv, self.native2, InequalityExpression((self.mon_npv, 8), True)), + ( + self.mon_npv, + self.le2, + RangedExpression((self.mon_npv,) + self.le2.args, (True, False)), + ), + ( + self.mon_npv, + self.lt2, + RangedExpression((self.mon_npv,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -5906,13 +7385,24 @@ def test_lt_linear(self): self.lt, RangedExpression(((self.linear,) + self.lt.args), (True, True)), ), - # 24 + # 24: ( self.linear, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.linear, self.native2, InequalityExpression((self.linear, 8), True)), + ( + self.linear, + self.le2, + RangedExpression(((self.linear,) + self.le2.args), (True, False)), + ), + ( + self.linear, + self.lt2, + RangedExpression(((self.linear,) + self.lt2.args), (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -5996,13 +7486,24 @@ def test_lt_sum(self): self.lt, RangedExpression((self.sum,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.sum, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.sum, self.native2, InequalityExpression((self.sum, 8), True)), + ( + self.sum, + self.le2, + RangedExpression((self.sum,) + self.le2.args, (True, False)), + ), + ( + self.sum, + self.lt2, + RangedExpression((self.sum,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -6094,13 +7595,24 @@ def test_lt_other(self): self.lt, RangedExpression((self.other,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.other, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.other, self.native2, InequalityExpression((self.other, 8), True)), + ( + self.other, + self.le2, + RangedExpression((self.other,) + self.le2.args, (True, False)), + ), + ( + self.other, + self.lt2, + RangedExpression((self.other,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -6200,13 +7712,20 @@ def test_lt_mutable_l0(self): self.lt, RangedExpression((self.l0,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.mutable_l0, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l0, self.native2, True), + ( + self.mutable_l0, + self.le2, + RangedExpression((self.l0,) + self.le2.args, (True, False)), + ), + (self.mutable_l0, self.lt2, self.lt2), ] self._run_cases(tests, operator.lt) @@ -6310,13 +7829,24 @@ def test_lt_mutable_l1(self): self.lt, RangedExpression((self.l1,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.mutable_l1, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l1, self.native2, InequalityExpression((self.l1, 8), True)), + ( + self.mutable_l1, + self.le2, + RangedExpression((self.l1,) + self.le2.args, (True, False)), + ), + ( + self.mutable_l1, + self.lt2, + RangedExpression((self.l1,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -6420,13 +7950,24 @@ def test_lt_mutable_l2(self): self.lt, RangedExpression((self.l2,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.mutable_l2, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l2, self.native2, InequalityExpression((self.l2, 8), True)), + ( + self.mutable_l2, + self.le2, + RangedExpression((self.l2,) + self.le2.args, (True, False)), + ), + ( + self.mutable_l2, + self.lt2, + RangedExpression((self.l2,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -6482,13 +8023,20 @@ def test_lt_param0(self): RangedExpression((0,) + self.le.args, (True, False)), ), (self.param0, self.lt, RangedExpression((0,) + self.lt.args, (True, True))), - # 24 + # 24: ( self.param0, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param0, self.native2, True), + ( + self.param0, + self.le2, + RangedExpression((0,) + self.le2.args, (True, False)), + ), + (self.param0, self.lt2, self.lt2), ] self._run_cases(tests, operator.lt) @@ -6544,13 +8092,20 @@ def test_lt_param1(self): RangedExpression((1,) + self.le.args, (True, False)), ), (self.param1, self.lt, RangedExpression((1,) + self.lt.args, (True, True))), - # 24 + # 24: ( self.param1, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.param1, self.native2, True), + ( + self.param1, + self.le2, + RangedExpression((1,) + self.le2.args, (True, False)), + ), + (self.param1, self.lt2, self.lt2), ] self._run_cases(tests, operator.lt) @@ -6654,13 +8209,24 @@ def test_lt_mutable_l3(self): self.lt, RangedExpression((self.l3,) + self.lt.args, (True, True)), ), - # 24 + # 24: ( self.mutable_l3, self.ranged, "Cannot create an InequalityExpression where one of the " "sub-expressions is a relational expression", ), + (self.mutable_l3, self.native2, InequalityExpression((self.l3, 8), True)), + ( + self.mutable_l3, + self.le2, + RangedExpression((self.l3,) + self.le2.args, (True, False)), + ), + ( + self.mutable_l3, + self.lt2, + RangedExpression((self.l3,) + self.lt2.args, (True, True)), + ), ] self._run_cases(tests, operator.lt) @@ -6810,13 +8376,31 @@ def test_lt_eq(self): "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( self.eq, self.ranged, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), + ( + self.eq, + self.native2, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.eq, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.eq, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), ] self._run_cases(tests, operator.lt) @@ -6942,13 +8526,30 @@ def test_lt_le(self): "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( self.le, self.ranged, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), + ( + self.le, + self.native2, + RangedExpression((self.le.args + (8,)), (False, True)), + ), + ( + self.le, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), ] self._run_cases(tests, operator.lt) @@ -6960,24 +8561,16 @@ def test_lt_lt(self): self.asbinary, RangedExpression((self.lt.args + (self.bin,)), (True, True)), ), - (self.lt, self.zero, RangedExpression((self.lt.args + (0,)), (True, True))), - (self.lt, self.one, RangedExpression((self.lt.args + (1,)), (True, True))), + (self.lt, self.zero, False), + (self.lt, self.one, False), # 4: - ( - self.lt, - self.native, - RangedExpression((self.lt.args + (5,)), (True, True)), - ), + (self.lt, self.native, False), ( self.lt, self.npv, RangedExpression((self.lt.args + (self.npv,)), (True, True)), ), - ( - self.lt, - self.param, - RangedExpression((self.lt.args + (6,)), (True, True)), - ), + (self.lt, self.param, False), ( self.lt, self.param_mut, @@ -7020,11 +8613,7 @@ def test_lt_lt(self): self.other, RangedExpression((self.lt.args + (self.other,)), (True, True)), ), - ( - self.lt, - self.mutable_l0, - RangedExpression((self.lt.args + (self.l0,)), (True, True)), - ), + (self.lt, self.mutable_l0, False), # 16: ( self.lt, @@ -7036,16 +8625,8 @@ def test_lt_lt(self): self.mutable_l2, RangedExpression((self.lt.args + (self.l2,)), (True, True)), ), - ( - self.lt, - self.param0, - RangedExpression((self.lt.args + (0,)), (True, True)), - ), - ( - self.lt, - self.param1, - RangedExpression((self.lt.args + (1,)), (True, True)), - ), + (self.lt, self.param0, False), + (self.lt, self.param1, False), # 20: ( self.lt, @@ -7070,13 +8651,26 @@ def test_lt_lt(self): "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: ( self.lt, self.ranged, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), + (self.lt, self.native2, self.lt), + ( + self.lt, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), ] self._run_cases(tests, operator.lt) @@ -7226,12 +8820,377 @@ def test_lt_ranged(self): "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), - # 24 + # 24: + ( + self.ranged, + self.ranged, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.ranged, + self.native2, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.ranged, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.ranged, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ] + self._run_cases(tests, operator.lt) + + def test_lt_native2(self): + tests = [ + (self.native2, self.invalid, NotImplemented), + (self.native2, self.asbinary, InequalityExpression((8, self.bin), True)), + (self.native2, self.zero, False), + (self.native2, self.one, False), + # 4: + (self.native2, self.native, False), + (self.native2, self.npv, InequalityExpression((8, self.npv), True)), + (self.native2, self.param, False), + ( + self.native2, + self.param_mut, + InequalityExpression((8, self.param_mut), True), + ), + # 8: + (self.native2, self.var, InequalityExpression((8, self.var), True)), + ( + self.native2, + self.mon_native, + InequalityExpression((8, self.mon_native), True), + ), + ( + self.native2, + self.mon_param, + InequalityExpression((8, self.mon_param), True), + ), + (self.native2, self.mon_npv, InequalityExpression((8, self.mon_npv), True)), + # 12: + (self.native2, self.linear, InequalityExpression((8, self.linear), True)), + (self.native2, self.sum, InequalityExpression((8, self.sum), True)), + (self.native2, self.other, InequalityExpression((8, self.other), True)), + (self.native2, self.mutable_l0, False), + # 16: + (self.native2, self.mutable_l1, InequalityExpression((8, self.l1), True)), + (self.native2, self.mutable_l2, InequalityExpression((8, self.l2), True)), + (self.native2, self.param0, False), + (self.native2, self.param1, False), + # 20: + (self.native2, self.mutable_l3, InequalityExpression((8, self.l3), True)), + ( + self.native2, + self.eq, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + ( + self.native2, + self.le, + RangedExpression((8,) + self.le.args, (True, False)), + ), + (self.native2, self.lt, False), + # 24: + ( + self.native2, + self.ranged, + "Cannot create an InequalityExpression where one of the " + "sub-expressions is a relational expression", + ), + (self.native2, self.native2, False), + ( + self.native2, + self.le2, + RangedExpression((8,) + self.le2.args, (True, False)), + ), + (self.native2, self.lt2, False), + ] + self._run_cases(tests, operator.lt) + + def test_lt_le2(self): + tests = [ + (self.le2, self.invalid, NotImplemented), + ( + self.le2, + self.asbinary, + RangedExpression((self.le2.args + (self.bin,)), (False, True)), + ), + ( + self.le2, + self.zero, + RangedExpression((self.le2.args + (0,)), (False, True)), + ), + ( + self.le2, + self.one, + RangedExpression((self.le2.args + (1,)), (False, True)), + ), + # 4: + ( + self.le2, + self.native, + RangedExpression((self.le2.args + (5,)), (False, True)), + ), + ( + self.le2, + self.npv, + RangedExpression((self.le2.args + (self.npv,)), (False, True)), + ), + ( + self.le2, + self.param, + RangedExpression((self.le2.args + (6,)), (False, True)), + ), + ( + self.le2, + self.param_mut, + RangedExpression((self.le2.args + (self.param_mut,)), (False, True)), + ), + # 8: + ( + self.le2, + self.var, + RangedExpression((self.le2.args + (self.var,)), (False, True)), + ), + ( + self.le2, + self.mon_native, + RangedExpression((self.le2.args + (self.mon_native,)), (False, True)), + ), + ( + self.le2, + self.mon_param, + RangedExpression((self.le2.args + (self.mon_param,)), (False, True)), + ), + ( + self.le2, + self.mon_npv, + RangedExpression((self.le2.args + (self.mon_npv,)), (False, True)), + ), + # 12: + ( + self.le2, + self.linear, + RangedExpression((self.le2.args + (self.linear,)), (False, True)), + ), + ( + self.le2, + self.sum, + RangedExpression((self.le2.args + (self.sum,)), (False, True)), + ), + ( + self.le2, + self.other, + RangedExpression((self.le2.args + (self.other,)), (False, True)), + ), + ( + self.le2, + self.mutable_l0, + RangedExpression((self.le2.args + (self.l0,)), (False, True)), + ), + # 16: + ( + self.le2, + self.mutable_l1, + RangedExpression((self.le2.args + (self.l1,)), (False, True)), + ), + ( + self.le2, + self.mutable_l2, + RangedExpression((self.le2.args + (self.l2,)), (False, True)), + ), + ( + self.le2, + self.param0, + RangedExpression((self.le2.args + (0,)), (False, True)), + ), + ( + self.le2, + self.param1, + RangedExpression((self.le2.args + (1,)), (False, True)), + ), + # 20: + ( + self.le2, + self.mutable_l3, + RangedExpression((self.le2.args + (self.l3,)), (False, True)), + ), + ( + self.le2, + self.eq, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le2, + self.le, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le2, + self.lt, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + # 24: ( + self.le2, self.ranged, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le2, + self.native2, + RangedExpression((self.le2.args + (8,)), (False, True)), + ), + ( + self.le2, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.le2, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ] + self._run_cases(tests, operator.lt) + + def test_lt_lt2(self): + tests = [ + (self.lt2, self.invalid, NotImplemented), + ( + self.lt2, + self.asbinary, + RangedExpression((self.lt2.args + (self.bin,)), (True, True)), + ), + (self.lt2, self.zero, False), + (self.lt2, self.one, False), + # 4: + (self.lt2, self.native, False), + ( + self.lt2, + self.npv, + RangedExpression((self.lt2.args + (self.npv,)), (True, True)), + ), + (self.lt2, self.param, False), + ( + self.lt2, + self.param_mut, + RangedExpression((self.lt2.args + (self.param_mut,)), (True, True)), + ), + # 8: + ( + self.lt2, + self.var, + RangedExpression((self.lt2.args + (self.var,)), (True, True)), + ), + ( + self.lt2, + self.mon_native, + RangedExpression((self.lt2.args + (self.mon_native,)), (True, True)), + ), + ( + self.lt2, + self.mon_param, + RangedExpression((self.lt2.args + (self.mon_param,)), (True, True)), + ), + ( + self.lt2, + self.mon_npv, + RangedExpression((self.lt2.args + (self.mon_npv,)), (True, True)), + ), + # 12: + ( + self.lt2, + self.linear, + RangedExpression((self.lt2.args + (self.linear,)), (True, True)), + ), + ( + self.lt2, + self.sum, + RangedExpression((self.lt2.args + (self.sum,)), (True, True)), + ), + ( + self.lt2, + self.other, + RangedExpression((self.lt2.args + (self.other,)), (True, True)), + ), + (self.lt2, self.mutable_l0, False), + # 16: + ( + self.lt2, + self.mutable_l1, + RangedExpression((self.lt2.args + (self.l1,)), (True, True)), + ), + ( + self.lt2, + self.mutable_l2, + RangedExpression((self.lt2.args + (self.l2,)), (True, True)), + ), + (self.lt2, self.param0, False), + (self.lt2, self.param1, False), + # 20: + ( + self.lt2, + self.mutable_l3, + RangedExpression((self.lt2.args + (self.l3,)), (True, True)), + ), + ( + self.lt2, + self.eq, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.le, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.lt, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + # 24: + ( + self.lt2, self.ranged, "Cannot create an InequalityExpression where both " "sub-expressions are relational expressions", ), + ( + self.lt2, + self.native2, + RangedExpression((self.lt2.args + (8,)), (True, True)), + ), + ( + self.lt2, + self.le2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), + ( + self.lt2, + self.lt2, + "Cannot create an InequalityExpression where both " + "sub-expressions are relational expressions", + ), ] self._run_cases(tests, operator.lt) diff --git a/pyomo/mpec/complementarity.py b/pyomo/mpec/complementarity.py index 3f70351958c..c606af88314 100644 --- a/pyomo/mpec/complementarity.py +++ b/pyomo/mpec/complementarity.py @@ -117,7 +117,12 @@ def to_standard_form(self): _e1, _e2 = _e2, _e1 # if _e2[0] is None and _e2[2] is None: - self.c = Constraint(expr=(None, _e2[1], None)) + # FIXME: this is making an unbounded RangedExpression - + # which makes little sense. When we rework Complimentarity, + # we should determine how to avoid this overhead. + self.c = Constraint( + expr=EXPR.RangedExpression((None, _e2[1], None), strict=False) + ) self.c._complementarity_type = 3 elif _e2[2] is None: self.c = Constraint(expr=_e2[0] <= _e2[1]) diff --git a/pyomo/solvers/tests/models/LP_compiled.py b/pyomo/solvers/tests/models/LP_compiled.py index f0a06d30298..a42a107ce03 100644 --- a/pyomo/solvers/tests/models/LP_compiled.py +++ b/pyomo/solvers/tests/models/LP_compiled.py @@ -16,6 +16,7 @@ RangeSet, ConstraintList, ) +from pyomo.core.expr import EqualityExpression, RangedExpression from pyomo.solvers.tests.models.base import _BaseTestModel, register_model from pyomo.repn.beta.matrix import compile_block_linear_constraints @@ -82,27 +83,30 @@ def _generate_model(self): model.c.add((-1.0, model.x[10], -1.0)) model.c.add((1.0, model.x[11], 1.0)) model.c.add((1.0, model.x[12], 1.0)) - cdata = model.c.add((0, 1, 3)) + cdata = model.c.add(RangedExpression((0, 1, 3), False)) assert cdata.lower == 0 assert cdata.upper == 3 assert cdata.body() == 1 assert not cdata.equality - cdata = model.c.add((0, 2, 3)) + cdata = model.c.add(RangedExpression((0, 2, 3), False)) assert cdata.lower == 0 assert cdata.upper == 3 assert cdata.body() == 2 assert not cdata.equality - cdata = model.c.add((0, 1, None)) + # Note this is a redundant test, left in to preserve the + # baseline. RangedExpression does not manipulate the arguments + # like the old tuple notation did. + cdata = model.c.add(RangedExpression((None, 0, 1), False)) assert cdata.lower is None assert cdata.upper == 1 assert cdata.body() == 0 assert not cdata.equality - cdata = model.c.add((None, 0, 1)) + cdata = model.c.add(RangedExpression((None, 0, 1), False)) assert cdata.lower is None assert cdata.upper == 1 assert cdata.body() == 0 assert not cdata.equality - cdata = model.c.add((1, 1)) + cdata = model.c.add(EqualityExpression((1, 1))) assert cdata.lower == 1 assert cdata.upper == 1 assert cdata.body() == 1 diff --git a/pyomo/solvers/tests/models/LP_trivial_constraints.py b/pyomo/solvers/tests/models/LP_trivial_constraints.py index 660863d27f1..09e9ecfacee 100644 --- a/pyomo/solvers/tests/models/LP_trivial_constraints.py +++ b/pyomo/solvers/tests/models/LP_trivial_constraints.py @@ -16,6 +16,7 @@ RangeSet, ConstraintList, ) +from pyomo.core.expr.relational_expr import EqualityExpression, RangedExpression from pyomo.solvers.tests.models.base import _BaseTestModel, register_model @@ -45,27 +46,30 @@ def _generate_model(self): model.c = ConstraintList() model.c.add(model.x >= -2) model.c.add(model.y <= 3) - cdata = model.c.add((0, 1, 3)) + cdata = model.c.add(RangedExpression((0, 1, 3), False)) assert cdata.lower == 0 assert cdata.upper == 3 assert cdata.body() == 1 assert not cdata.equality - cdata = model.c.add((0, 2, 3)) + cdata = model.c.add(RangedExpression((0, 2, 3), False)) assert cdata.lower == 0 assert cdata.upper == 3 assert cdata.body() == 2 assert not cdata.equality - cdata = model.c.add((0, 1, None)) + # Note this is a redundant test, left in to preserve the + # baseline. RangedExpression does not manipulate the arguments + # like the old tuple notation did. + cdata = model.c.add(RangedExpression((None, 0, 1), False)) assert cdata.lower is None assert cdata.upper == 1 assert cdata.body() == 0 assert not cdata.equality - cdata = model.c.add((None, 0, 1)) + cdata = model.c.add(RangedExpression((None, 0, 1), False)) assert cdata.lower is None assert cdata.upper == 1 assert cdata.body() == 0 assert not cdata.equality - cdata = model.c.add((1, 1)) + cdata = model.c.add(EqualityExpression((1, 1))) assert cdata.lower == 1 assert cdata.upper == 1 assert cdata.body() == 1