Merge branch 'main' into mindtpy-docs

Author: bernalde

doc/OnlineDocs/explanation/solvers/pyros/index.rst

@@ -31,7 +31,7 @@ projects.
 Citing PyROS
 ============
 If you use PyROS in your research,
-please acknowledge PyROS by citing [IAE+21]_.
+please acknowledge PyROS by citing [SIS+26]_ and [IAE+21]_.
 
 
 Feedback and Reporting Issues

doc/OnlineDocs/reference/bibliography.rst

@@ -167,6 +167,11 @@ Bibliography
    1032–1037. 2003. DOI `10.1016/S1570-7946(03)80444-3
    <https://doi.org/10.1016/S1570-7946(03)80444-3>`_
 
+.. [SIS+26] J. A. F. Sherman, N. M. Isenberg, J. D. Siirola,
+   and C. E. Gounaris. "PyROS: The Pyomo Robust Optimization Solver".
+   Optimization Online, Preprint. 2026.
+   https://optimization-online.org/2026/06/pyros-the-pyomo-robust-optimization-solver/
+
 .. [TG15] F. Trespalacios and I. E. Grossmann. "Improved Big-M
    reformulation for generalized disjunctive programs", *Computers and
    Chemical Engineering*, 76, 98–103. 2015.  DOI

pyomo/common/env.py

@@ -393,7 +393,7 @@ class CtypesEnviron:
     `os.environ` reflects the current python environment variables, and
     will be passed to subprocesses.  However, it does not reflect the C
     Runtime Library (MSVCRT) environment on Windows platforms.  This can
-    be problemmatic as DLLs loaded through the CTYPES interface will see
+    be problematic as DLLs loaded through the CTYPES interface will see
     the MSVCRT environment and not os.environ.  This class provides a
     way to manage environment variables and pass changes to both
     os.environ and the MSVCRT runtime.

pyomo/contrib/parmest/parmest.py

@@ -1074,16 +1074,13 @@ def __init__(
         assert isinstance(experiment_list, list)
         self.exp_list = experiment_list
 
-        # get the number of experiments
-        self.number_exp = _count_total_experiments(self.exp_list)
-
         # check if the experiment has a ``get_labeled_model`` function
         model = _get_labeled_model(self.exp_list[0])
 
         # check if the model has all the required suffixes
         _check_model_labels(model)
 
-        # populate keyword argument options
+        # check if the objective function is supplied correctly
         if isinstance(obj_function, str):
             try:
                 self.obj_function = ObjectiveType(obj_function)
@@ -1113,6 +1110,18 @@ def __init__(
                 f"{[e.value for e in RegularizationType]}."
             )
 
+        # get the number of data points
+        # this is used to compute the covariance matrix for the case
+        # when the measurement errors are not supplied by the user
+        get_measurement_error = getattr(model, "measurement_error", None)
+
+        all_unknown_errors = get_measurement_error is None or all(
+            model.measurement_error[y_hat] is None for y_hat in model.experiment_outputs
+        )
+
+        if self.obj_function == ObjectiveType.SSE and all_unknown_errors:
+            self.number_exp = _count_total_experiments(self.exp_list)
+
         self.tee = tee
         self.diagnostic_mode = diagnostic_mode
         self.solver_options = solver_options
@@ -1691,7 +1700,11 @@ def _cov_at_theta(self, method, solver, step):
 
                 # fix the value of the unknown parameters to the estimated values
                 for param in model.unknown_parameters:
-                    param.fix(self.estimated_theta[param.name])
+                    if param.is_indexed():
+                        for idx in param:
+                            param[idx].fix(self.estimated_theta[param[idx].name])
+                    else:
+                        param.fix(self.estimated_theta[param.name])
 
                 # re-solve the model with the estimated parameters
                 results = pyo.SolverFactory(solver).solve(model, tee=self.tee)
@@ -1720,12 +1733,6 @@ def _cov_at_theta(self, method, solver, step):
                 f"The sum of squared errors at the estimated parameter(s) is: {sse}"
             )
 
-        # Number of data points considered
-        n = self.number_exp
-
-        # Extract the number of fitted parameters
-        l = len(self.estimated_theta)
-
         """Calculate covariance assuming experimental observation errors are
         independent and follow a Gaussian distribution with constant variance.
 
@@ -1763,6 +1770,17 @@ def _cov_at_theta(self, method, solver, step):
 
                 # check if the user supplied the values of the measurement errors
                 if all(item is None for item in meas_error):
+                    # Number of data points considered
+                    n = self.number_exp
+
+                    # Extract the number of fitted parameters
+                    l = len(self.estimated_theta)
+
+                    assert n > l, (
+                        "The number of datapoints must be greater than the "
+                        "number of parameters to estimate."
+                    )
+
                     if cov_method == CovarianceMethod.reduced_hessian:
                         # in the "reduced_hessian" method, use the objective value
                         # to calculate the measurement error variance because this
@@ -2027,18 +2045,6 @@ def cov_est(self, method="finite_difference", solver="ipopt", step=1e-3):
         if not isinstance(step, float):
             raise TypeError("Expected a float for the step, e.g., 1e-2")
 
-        # number of unknown parameters
-        num_unknowns = max(
-            [
-                len(_expanded_unknown_parameter_info(experiment.get_labeled_model())[0])
-                for experiment in self.exp_list
-            ]
-        )
-        assert self.number_exp > num_unknowns, (
-            "The number of datapoints must be greater than the "
-            "number of parameters to estimate."
-        )
-
         return self._cov_at_theta(method=method, solver=solver, step=step)
 
     def theta_est_bootstrap(

pyomo/contrib/parmest/tests/test_parmest.py

@@ -2272,9 +2272,12 @@ def test_indexed_unknown_parameter_names_are_expanded_consistently(self):
 
         self.assertEqual(pest._return_theta_names(), ["theta[a]", "theta[b]"])
 
+    @unittest.skipUnless(ipopt_available, "Test requires ipopt")
     def test_cov_est_counts_expanded_indexed_unknown_parameters(self):
         pest = _build_indexed_theta_estimator([(1.0, 2.0), (2.0, 4.0)])
 
+        obj, theta = pest.theta_est()
+
         with self.assertRaisesRegex(
             AssertionError,
             "The number of datapoints must be greater than the number of parameters to estimate.",

pyomo/contrib/piecewise/tests/common_tests.py

@@ -10,7 +10,8 @@
 import pyomo.contrib.piecewise.tests.models as models
 from pyomo.core import Var
 from pyomo.core.base import TransformationFactory
-from pyomo.environ import value
+from pyomo.core.expr.compare import assertExpressionsEqual
+from pyomo.environ import value, Expression
 from pyomo.gdp import Disjunct, Disjunction
 
 
@@ -85,3 +86,25 @@ def check_descend_into_expressions_objective_target(test, transformation, m=None
     test.check_pw_log(m)
     # And check that the paraboloid was *not* transformed.
     test.assertIsNone(m.pw_paraboloid.get_transformation_var(m.paraboloid_expr))
+
+
+def check_single_segment_no_disjunction(test, transformation, m=None):
+    if m is None:
+        m = models.make_single_segment_log_x_model()
+    transform = TransformationFactory(transformation)
+    transform.apply_to(m)
+
+    # A single segment doesn't require making a discrete choice, so this
+    # should not have created any GDP components.
+    test.assertEqual(len(list(m.component_data_objects(Disjunct))), 0)
+    test.assertEqual(len(list(m.component_data_objects(Disjunction))), 0)
+    # Nor should it have introduced any new Vars (such as a substitute_var
+    # or an indicator_var)--m.x should be the only Var in the model.
+    model_vars = list(m.component_data_objects(Var))
+    test.assertEqual(len(model_vars), 1)
+    test.assertIs(model_vars[0], m.x)
+
+    z = m.pw_log.get_transformation_var(m.log_expr)
+    test.assertIsInstance(z, Expression)
+    assertExpressionsEqual(test, z.expr, m.f1(m.x), places=7)
+    test.assertIs(m.log_expr.expr, z)

pyomo/contrib/piecewise/tests/models.py

@@ -45,7 +45,7 @@ def f3(x):
     m.x1 = Var(bounds=(0, 3))
     m.x2 = Var(bounds=(1, 7))
 
-    ## apprximates paraboloid x1**2 + x2**2
+    ## approximates paraboloid x1**2 + x2**2
     def g1(x1, x2):
         return 3 * x1 + 5 * x2 - 4
 
@@ -72,3 +72,19 @@ def c_rule(m, i):
     m.indexed_c = Constraint([0, 1], rule=c_rule)
 
     return m
+
+
+def make_single_segment_log_x_model():
+    m = ConcreteModel()
+    m.x = Var(bounds=(1, 10))
+    m.pw_log = PiecewiseLinearFunction(points=[1, 10], function=log)
+
+    def f1(x):
+        return (log(10) / 9) * x - log(10) / 9
+
+    m.f1 = f1
+
+    m.log_expr = m.pw_log(m.x)
+    m.obj = Objective(expr=m.log_expr)
+
+    return m

pyomo/contrib/piecewise/tests/test_disaggregated_logarithmic.py

@@ -263,6 +263,11 @@ def test_descend_into_expressions_objective_target(self):
             self, 'contrib.piecewise.disaggregated_logarithmic'
         )
 
+    def test_single_segment_no_disjunction(self):
+        ct.check_single_segment_no_disjunction(
+            self, 'contrib.piecewise.disaggregated_logarithmic'
+        )
+
     # Check solution of the log(x) model
     @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
     @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')

pyomo/contrib/piecewise/tests/test_incremental.py

@@ -174,6 +174,9 @@ def test_descend_into_expressions_objective_target(self):
             make_log_x_model(simplices=self.ordered_simplices),
         )
 
+    def test_single_segment_no_disjunction(self):
+        ct.check_single_segment_no_disjunction(self, 'contrib.piecewise.incremental')
+
     @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
     @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')
     def test_solve_log_model(self):

pyomo/contrib/piecewise/tests/test_inner_repn_gdp.py

@@ -106,6 +106,9 @@ def test_descend_into_expressions_objective_target(self):
             self, 'contrib.piecewise.inner_repn_gdp'
         )
 
+    def test_single_segment_no_disjunction(self):
+        ct.check_single_segment_no_disjunction(self, 'contrib.piecewise.inner_repn_gdp')
+
     @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
     @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')
     def test_solve_disaggregated_convex_combo_model(self):