Merge pull request #3651 from jsiirola/repn-refactor

Refactor linear/quadratic expression compilers

Author: blnicho

pyomo/contrib/pyros/util.py

@@ -59,7 +59,7 @@
 from pyomo.core.util import prod
 from pyomo.opt import SolverFactory
 import pyomo.repn.ampl as pyomo_ampl_repn
-from pyomo.repn.parameterized_quadratic import ParameterizedQuadraticRepnVisitor
+from pyomo.repn.parameterized import ParameterizedQuadraticRepnVisitor
 import pyomo.repn.plugins.nl_writer as pyomo_nl_writer
 from pyomo.repn.util import OrderedVarRecorder
 from pyomo.util.vars_from_expressions import get_vars_from_components

pyomo/core/base/constraint.py

@@ -63,7 +63,8 @@
 TEMPLATIZE_CONSTRAINTS = False
 
 _inf = float('inf')
-_nonfinite_values = {_inf, -_inf}
+_ninf = -_inf
+_nonfinite_values = {_inf, _ninf}
 _known_relational_expression_types = {
     EqualityExpression,
     InequalityExpression,
@@ -246,21 +247,31 @@ def to_bounded_expression(self, evaluate_bounds=False):
 
         if evaluate_bounds:
             lb, body, ub = ans
-            return self._evaluate_bound(lb, True), body, self._evaluate_bound(ub, False)
+            return self._evaluate_bound(lb, _ninf), body, self._evaluate_bound(ub, _inf)
         return ans
 
-    def _evaluate_bound(self, bound, is_lb):
+    def _evaluate_bound(self, bound, unbounded):
         if bound is None:
             return None
         if bound.__class__ not in native_numeric_types:
-            bound = float(value(bound))
+            bound = value(bound)
+            if bound.__class__ not in native_numeric_types:
+                # Starting in numpy 1.25, casting 1-element ndarray to
+                # float is deprecated.  We still want to support
+                # that... but without enforcing a hard numpy dependence
+                for cls in bound.__class__.__mro__:
+                    if cls.__name__ == 'ndarray' and cls.__module__ == 'numpy':
+                        if len(bound) == 1:
+                            bound = bound[0]
+                        break
+                bound = float(bound)
         # Note that "bound != bound" catches float('nan')
         if bound in _nonfinite_values or bound != bound:
-            if bound == (-_inf if is_lb else _inf):
+            if bound == unbounded:
                 return None
             raise ValueError(
                 f"Constraint '{self.name}' created with an invalid non-finite "
-                f"{'lower' if is_lb else 'upper'} bound ({bound})."
+                f"{'upper' if unbounded==_inf else 'lower'} bound ({bound})."
             )
         return bound
 
@@ -333,12 +344,12 @@ def upper(self):
     @property
     def lb(self):
         """float : the value of the lower bound of a constraint expression."""
-        return self._evaluate_bound(self.to_bounded_expression()[0], True)
+        return self._evaluate_bound(self.to_bounded_expression()[0], _ninf)
 
     @property
     def ub(self):
         """float : the value of the upper bound of a constraint expression."""
-        return self._evaluate_bound(self.to_bounded_expression()[2], False)
+        return self._evaluate_bound(self.to_bounded_expression()[2], _inf)
 
     @property
     def equality(self):
@@ -527,20 +538,9 @@ class _GeneralConstraintData(metaclass=RenamedClass):
     __renamed__version__ = '6.7.2'
 
 
-class TemplateConstraintData(ConstraintData):
+class TemplateDataMixin(object):
     __slots__ = ()
 
-    def __init__(self, template_info, component, index):
-        # These lines represent in-lining of the
-        # following constructors:
-        #   - ConstraintData,
-        #   - ActiveComponentData
-        #   - ComponentData
-        self._component = component
-        self._active = True
-        self._index = index
-        self._expr = template_info
-
     @property
     def expr(self):
         # Note that it is faster to just generate the expression from
@@ -552,17 +552,41 @@ def template_expr(self):
         return self._expr
 
     def set_value(self, expr):
-        self.__class__ = ConstraintData
+        # Setting a value will convert this instance from a templatized
+        # type to the original Data type (and call the original set_value()).
+        #
+        # Note: We assume that the templatized type is created by
+        # inheriting (TemplateDataMixin, <original data class>), and
+        # that this instance doesn't have additional multiple
+        # inheritance that could re-order the MRO.
+        self.__class__ = self.__class__.__mro__[
+            self.__class__.__mro__.index(TemplateDataMixin) + 1
+        ]
         return self.set_value(expr)
 
-    def to_bounded_expression(self):
+    def to_bounded_expression(self, evaluate_bounds=False):
         tmp, self._expr = self._expr, self._expr[0]
         try:
-            return super().to_bounded_expression()
+            return super().to_bounded_expression(evaluate_bounds)
         finally:
             self._expr = tmp
 
 
+class TemplateConstraintData(TemplateDataMixin, ConstraintData):
+    __slots__ = ()
+
+    def __init__(self, template_info, component, index):
+        # These lines represent in-lining of the
+        # following constructors:
+        #   - ConstraintData,
+        #   - ActiveComponentData
+        #   - ComponentData
+        self._component = component
+        self._active = True
+        self._index = index
+        self._expr = template_info
+
+
 @ModelComponentFactory.register("General constraint expressions.")
 class Constraint(ActiveIndexedComponent):
     """
@@ -695,11 +719,17 @@ def construct(self, data=None):
                 if TEMPLATIZE_CONSTRAINTS:
                     try:
                         template_info = templatize_constraint(self)
-                        comp = weakref_ref(self)
-                        self._data = {
-                            idx: TemplateConstraintData(template_info, comp, idx)
-                            for idx in self.index_set()
-                        }
+                        if self.is_indexed():
+                            comp = weakref_ref(self)
+                            self._data = {
+                                idx: TemplateConstraintData(template_info, comp, idx)
+                                for idx in self.index_set()
+                            }
+                        else:
+                            assert self.__class__ is ScalarConstraint
+                            self.__class__ = TemplateScalarConstraint
+                            self._expr = template_info
+                            self._data = {None: self}
                         return
                     except TemplateExpressionError:
                         pass
@@ -926,6 +956,7 @@ class SimpleConstraint(metaclass=RenamedClass):
 
 @disable_methods(
     {
+        '__call__',
         'add',
         'set_value',
         'to_bounded_expression',
@@ -947,6 +978,10 @@ class AbstractSimpleConstraint(metaclass=RenamedClass):
     __renamed__version__ = '6.0'
 
 
+class TemplateScalarConstraint(TemplateDataMixin, ScalarConstraint):
+    pass
+
+
 class IndexedConstraint(Constraint):
     #
     # Leaving this method for backward compatibility reasons