Merge pull request #3483 from jsiirola/relational-multiple-dispatch

Multiple dispatch for relational expression generation

Author: mrmundt

pyomo/core/expr/__init__.py

@@ -19,14 +19,9 @@
 )
 
 #
-# FIXME: remove circular dependencies between relational_expr and numeric_expr
+# FIXME: remove circular dependencies between logical_expr and numeric_expr
 #
 
-# Initialize relational expression functions
-numeric_expr._generate_relational_expression = (
-    relational_expr._generate_relational_expression
-)
-
 # Initialize logicalvalue functions
 boolean_value._generate_logical_proposition = logical_expr._generate_logical_proposition
 

pyomo/core/expr/base.py

@@ -9,8 +9,6 @@
 #  This software is distributed under the 3-clause BSD License.
 #  ___________________________________________________________________________
 
-import enum
-
 from pyomo.common.dependencies import attempt_import
 from pyomo.common.numeric_types import native_types
 from pyomo.common.modeling import NOTSET

pyomo/core/expr/boolean_value.py

@@ -14,8 +14,8 @@
 
 from pyomo.common.deprecation import deprecated
 from pyomo.common.modeling import NOTSET
+from pyomo.common.numeric_types import native_types, native_logical_types
 from pyomo.core.expr.expr_common import _type_check_exception_arg
-from pyomo.core.expr.numvalue import native_types, native_logical_types
 from pyomo.core.expr.expr_common import _and, _or, _equiv, _inv, _xor, _impl
 from pyomo.core.pyomoobject import PyomoObject
 

pyomo/core/expr/compare.py

@@ -71,6 +71,11 @@ def handle_sequence(node: collections.abc.Sequence, pn: List):
     return list(node)
 
 
+def handle_inequality(node: collections.abc.Sequence, pn: List):
+    pn.append((type(node), node.nargs(), node.strict))
+    return node.args
+
+
 def _generic_expression_handler():
     return handle_expression
 
@@ -83,7 +88,8 @@ def _generic_expression_handler():
 handler[NPV_ExternalFunctionExpression] = handle_external_function_expression
 handler[AbsExpression] = handle_unary_expression
 handler[NPV_AbsExpression] = handle_unary_expression
-handler[RangedExpression] = handle_expression
+handler[InequalityExpression] = handle_inequality
+handler[RangedExpression] = handle_inequality
 handler[list] = handle_sequence
 
 

pyomo/core/expr/expr_common.py

@@ -17,10 +17,6 @@
 
 TO_STRING_VERBOSE = False
 
-_eq = 0
-_le = 1
-_lt = 2
-
 # logical propositions
 _and = 0
 _or = 1
@@ -83,6 +79,120 @@ class ExpressionType(enums.Enum):
     LOGICAL = 2
 
 
+class NUMERIC_ARG_TYPE(enums.IntEnum):
+    MUTABLE = -2
+    ASNUMERIC = -1
+    INVALID = 0
+    NATIVE = 1
+    NPV = 2
+    PARAM = 3
+    VAR = 4
+    MONOMIAL = 5
+    LINEAR = 6
+    SUM = 7
+    OTHER = 8
+
+
+class RELATIONAL_ARG_TYPE(enums.IntEnum, metaclass=enums.ExtendedEnumType):
+    __base_enum__ = NUMERIC_ARG_TYPE
+
+    INEQUALITY = 100
+    INVALID_RELATIONAL = 101
+
+
+def _invalid(*args):
+    return NotImplemented
+
+
+def _recast_mutable(expr):
+    expr.make_immutable()
+    if expr._nargs > 1:
+        return expr
+    elif not expr._nargs:
+        return 0
+    else:
+        return expr._args_[0]
+
+
+def _unary_op_dispatcher_type_mapping(dispatcher, updates, TYPES=NUMERIC_ARG_TYPE):
+    #
+    # Special case (wrapping) operators
+    #
+    def _asnumeric(a):
+        a = a.as_numeric()
+        return dispatcher[a.__class__](a)
+
+    def _mutable(a):
+        a = _recast_mutable(a)
+        return dispatcher[a.__class__](a)
+
+    mapping = {
+        TYPES.ASNUMERIC: _asnumeric,
+        TYPES.MUTABLE: _mutable,
+        TYPES.INVALID: _invalid,
+    }
+
+    mapping.update(updates)
+    return mapping
+
+
+def _binary_op_dispatcher_type_mapping(dispatcher, updates, TYPES=NUMERIC_ARG_TYPE):
+    #
+    # Special case (wrapping) operators
+    #
+    def _any_asnumeric(a, b):
+        b = b.as_numeric()
+        return dispatcher[a.__class__, b.__class__](a, b)
+
+    def _asnumeric_any(a, b):
+        a = a.as_numeric()
+        return dispatcher[a.__class__, b.__class__](a, b)
+
+    def _asnumeric_asnumeric(a, b):
+        a = a.as_numeric()
+        b = b.as_numeric()
+        return dispatcher[a.__class__, b.__class__](a, b)
+
+    def _any_mutable(a, b):
+        b = _recast_mutable(b)
+        return dispatcher[a.__class__, b.__class__](a, b)
+
+    def _mutable_any(a, b):
+        a = _recast_mutable(a)
+        return dispatcher[a.__class__, b.__class__](a, b)
+
+    def _mutable_mutable(a, b):
+        if a is b:
+            # Note: _recast_mutable is an in-place operation: make sure
+            # that we don't call it twice on the same object.
+            a = b = _recast_mutable(a)
+        else:
+            a = _recast_mutable(a)
+            b = _recast_mutable(b)
+        return dispatcher[a.__class__, b.__class__](a, b)
+
+    mapping = {}
+
+    # Because ASNUMERIC and MUTABLE re-call the dispatcher, we want to
+    # resolve ASNUMERIC first, MUTABLE second, and INVALID last.  That
+    # means we will add them to the dispatcher dict in opposite order so
+    # "higher priority" callbacks override lower priority ones.
+
+    mapping.update({(i, TYPES.INVALID): _invalid for i in TYPES})
+    mapping.update({(TYPES.INVALID, i): _invalid for i in TYPES})
+
+    mapping.update({(i, TYPES.MUTABLE): _any_mutable for i in TYPES})
+    mapping.update({(TYPES.MUTABLE, i): _mutable_any for i in TYPES})
+    mapping[TYPES.MUTABLE, TYPES.MUTABLE] = _mutable_mutable
+
+    mapping.update({(i, TYPES.ASNUMERIC): _any_asnumeric for i in TYPES})
+    mapping.update({(TYPES.ASNUMERIC, i): _asnumeric_any for i in TYPES})
+    mapping[TYPES.ASNUMERIC, TYPES.ASNUMERIC] = _asnumeric_asnumeric
+
+    mapping.update(updates)
+    return mapping
+
+
 @deprecated(
     """The clone counter has been removed and will always return 0.