Refactor linear/quadratic expression compilers

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,34 @@ def template_expr(self):
         return self._expr
 
     def set_value(self, expr):
-        self.__class__ = ConstraintData
+        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 +712,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 +949,7 @@ class SimpleConstraint(metaclass=RenamedClass):
 
 @disable_methods(
     {
+        '__call__',
         'add',
         'set_value',
         'to_bounded_expression',
@@ -947,6 +971,10 @@ class AbstractSimpleConstraint(metaclass=RenamedClass):
     __renamed__version__ = '6.0'
 
 
+class TemplateScalarConstraint(TemplateDataMixin, ScalarConstraint):
+    pass
+
+
 class IndexedConstraint(Constraint):
     #
     # Leaving this method for backward compatibility reasons

pyomo/core/base/objective.py

@@ -26,6 +26,7 @@
 from pyomo.core.expr.numvalue import value
 from pyomo.core.expr.template_expr import templatize_rule
 from pyomo.core.base.component import ActiveComponentData, ModelComponentFactory
+from pyomo.core.base.disable_methods import disable_methods
 from pyomo.core.base.global_set import UnindexedComponent_index
 from pyomo.core.base.indexed_component import (
     ActiveIndexedComponent,
@@ -165,7 +166,27 @@ class _GeneralObjectiveData(metaclass=RenamedClass):
     __renamed__version__ = '6.7.2'
 
 
-class TemplateObjectiveData(ObjectiveData):
+class TemplateDataMixin(object):
+    __slots__ = ()
+
+    @property
+    def args(self):
+        # Note that it is faster to just generate the expression from
+        # scratch than it is to clone it and replace the IndexTemplate objects
+        self.set_value(self.parent_component().rule(self.parent_block(), self.index()))
+        return self._args_
+
+    def template_expr(self):
+        return self._args_
+
+    def set_value(self, expr):
+        self.__class__ = self.__class__.__mro__[
+            self.__class__.__mro__.index(TemplateDataMixin) + 1
+        ]
+        return self.set_value(expr)
+
+
+class TemplateObjectiveData(TemplateDataMixin, ObjectiveData):
     __slots__ = ()
 
     def __init__(self, template_info, component, index, sense):
@@ -249,11 +270,11 @@ class Objective(ActiveIndexedComponent):
 
     def __new__(cls, *args, **kwds):
         if cls != Objective:
-            return super(Objective, cls).__new__(cls)
+            return super().__new__(cls)
         if not args or (args[0] is UnindexedComponent_set and len(args) == 1):
-            return ScalarObjective.__new__(ScalarObjective)
+            return super().__new__(AbstractScalarObjective)
         else:
-            return IndexedObjective.__new__(IndexedObjective)
+            return super().__new__(IndexedObjective)
 
     @overload
     def __init__(
@@ -320,13 +341,23 @@ def construct(self, data=None):
                 if TEMPLATIZE_OBJECTIVES:
                     try:
                         template_info = templatize_rule(block, rule, self.index_set())
-                        comp = weakref_ref(self)
-                        self._data = {
-                            idx: TemplateObjectiveData(
-                                template_info, comp, idx, self._init_sense(block, index)
-                            )
-                            for idx in self.index_set()
-                        }
+                        if self.is_indexed():
+                            comp = weakref_ref(self)
+                            self._data = {
+                                idx: TemplateObjectiveData(
+                                    template_info,
+                                    comp,
+                                    idx,
+                                    self._init_sense(block, index),
+                                )
+                                for idx in self.index_set()
+                            }
+                        else:
+                            assert self.__class__ is ScalarObjective
+                            self.__class__ = TemplateScalarObjective
+                            self._expr = template_info
+                            self._data = {None: self}
+                            self.set_sense(self._init_sense(self, self.index()))
                         return
                     except TemplateExpressionError:
                         pass
@@ -428,50 +459,27 @@ def __init__(self, *args, **kwd):
         Objective.__init__(self, *args, **kwd)
         self._index = UnindexedComponent_index
 
-    #
-    # Override abstract interface methods to first check for
-    # construction
-    #
-
     def __call__(self, exception=NOTSET):
         exception = _type_check_exception_arg(self, exception)
-        if self._constructed:
-            if len(self._data) == 0:
-                raise ValueError(
-                    "Evaluating the expression of ScalarObjective "
-                    "'%s' before the Objective has been assigned "
-                    "a sense or expression (there is currently "
-                    "no value to return)." % (self.name)
-                )
-            return super().__call__(exception)
-        raise ValueError(
-            "Evaluating the expression of objective '%s' "
-            "before the Objective has been constructed (there "
-            "is currently no value to return)." % (self.name)
-        )
-
-    @property
-    def expr(self):
-        """Access the expression of this objective."""
-        if self._constructed:
-            if len(self._data) == 0:
-                raise ValueError(
-                    "Accessing the expression of ScalarObjective "
-                    "'%s' before the Objective has been assigned "
-                    "a sense or expression (there is currently "
-                    "no value to return)." % (self.name)
-                )
-            return ObjectiveData.expr.fget(self)
-        raise ValueError(
-            "Accessing the expression of objective '%s' "
-            "before the Objective has been constructed (there "
-            "is currently no value to return)." % (self.name)
-        )
+        if not self._data:
+            raise ValueError(
+                "Evaluating the expression of ScalarObjective "
+                "'%s' before the Objective has been assigned "
+                "a sense or expression (there is currently "
+                "no value to return)." % (self.name)
+            )
+        return super().__call__(exception)
 
-    @expr.setter
-    def expr(self, expr):
-        """Set the expression of this objective."""
-        self.set_value(expr)
+    #
+    # Singleton objectives are strange in that we want them to be
+    # both be constructed but have len() == 0 when not initialized with
+    # anything (at least according to the unit tests that are
+    # currently in place). So during initialization only, we will
+    # treat them as "indexed" objects where things like
+    # Objective.Skip are managed. But after that they will behave
+    # like ObjectiveData objects where set_value does not handle
+    # Objective.Skip but expects a valid expression or None
+    #
 
     @property
     def sense(self):
@@ -496,43 +504,20 @@ def sense(self, sense):
         """Set the sense (direction) of this objective."""
         self.set_sense(sense)
 
-    #
-    # Singleton objectives are strange in that we want them to be
-    # both be constructed but have len() == 0 when not initialized with
-    # anything (at least according to the unit tests that are
-    # currently in place). So during initialization only, we will
-    # treat them as "indexed" objects where things like
-    # Objective.Skip are managed. But after that they will behave
-    # like ObjectiveData objects where set_value does not handle
-    # Objective.Skip but expects a valid expression or None
-    #
-
     def clear(self):
         self._data = {}
 
     def set_value(self, expr):
         """Set the expression of this objective."""
-        if not self._constructed:
-            raise ValueError(
-                "Setting the value of objective '%s' "
-                "before the Objective has been constructed (there "
-                "is currently no object to set)." % (self.name)
-            )
         if not self._data:
             self._data[None] = self
         return super().set_value(expr)
 
     def set_sense(self, sense):
         """Set the sense (direction) of this objective."""
-        if self._constructed:
-            if len(self._data) == 0:
-                self._data[None] = self
-            return ObjectiveData.set_sense(self, sense)
-        raise ValueError(
-            "Setting the sense of objective '%s' "
-            "before the Objective has been constructed (there "
-            "is currently no object to set)." % (self.name)
-        )
+        if len(self._data) == 0:
+            self._data[None] = self
+        return ObjectiveData.set_sense(self, sense)
 
     #
     # Leaving this method for backward compatibility reasons.
@@ -554,6 +539,15 @@ class SimpleObjective(metaclass=RenamedClass):
     __renamed__version__ = '6.0'
 
 
+@disable_methods({'__call__', 'add', 'expr', 'sense', 'set_sense', 'set_value'})
+class AbstractScalarObjective(ScalarObjective):
+    pass
+
+
+class TemplateScalarObjective(TemplateDataMixin, ScalarObjective):
+    pass
+
+
 class IndexedObjective(Objective):
     #
     # Leaving this method for backward compatibility reasons