Merge pull request #3990 from emma58/linear-pw-linear

contrib.piecewise: Add special case for single-segment "piecewise" linear functions

Author: michaelbynum

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):

pyomo/contrib/piecewise/tests/test_nested_inner_repn_gdp.py

@@ -122,6 +122,11 @@ def test_descend_into_expressions_objective_target(self):
             self, 'contrib.piecewise.nested_inner_repn_gdp'
         )
 
+    def test_single_segment_no_disjunction(self):
+        ct.check_single_segment_no_disjunction(
+            self, 'contrib.piecewise.nested_inner_repn_gdp'
+        )
+
     # Check the 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_outer_repn_gdp.py

@@ -178,3 +178,6 @@ def test_solve_multiple_choice_model(self):
         SolverFactory('gurobi').solve(m)
 
         ct.check_log_x_model_soln(self, m)
+
+    def test_single_segment_no_disjunction(self):
+        ct.check_single_segment_no_disjunction(self, 'contrib.piecewise.outer_repn_gdp')

pyomo/contrib/piecewise/tests/test_piecewise_linear_function.py

@@ -102,6 +102,20 @@ def test_pw_linear_approx_of_ln_x_points(self):
         m.pw = PiecewiseLinearFunction(points=[1, 3, 6, 10], function=m.f)
         self.check_ln_x_approx(m.pw, m.x)
 
+    def test_pw_linear_approx_of_ln_x_single_segment(self):
+        m = self.make_ln_x_model()
+        m.pw = PiecewiseLinearFunction(points=[1, 10], function=m.f)
+
+        self.assertEqual(len(m.pw._simplices), 1)
+        self.assertEqual(len(m.pw._linear_functions), 1)
+        self.assertEqual(m.pw._simplices[0], (0, 1))
+
+        slope = log(10) / 9
+        intercept = -log(10) / 9
+        assertExpressionsEqual(
+            self, m.pw._linear_functions[0](m.x), slope * m.x + intercept, places=7
+        )
+
     def test_pw_linear_approx_of_ln_x_linear_funcs(self):
         m = self.make_ln_x_model()
         m.pw = PiecewiseLinearFunction(

pyomo/contrib/piecewise/tests/test_reduced_inner_repn.py

@@ -245,6 +245,11 @@ def test_descend_into_expressions_objective_target(self):
             self, 'contrib.piecewise.reduced_inner_repn_gdp'
         )
 
+    def test_single_segment_no_disjunction(self):
+        ct.check_single_segment_no_disjunction(
+            self, 'contrib.piecewise.reduced_inner_repn_gdp'
+        )
+
     @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
     @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')
     def test_solve_convex_combo_model(self):

pyomo/contrib/piecewise/transform/disaggregated_logarithmic.py

@@ -44,7 +44,9 @@ class DisaggregatedLogarithmicMIPTransformation(PiecewiseLinearTransformationBas
 
     # Implement to use PiecewiseLinearTransformationBase. This function returns the Var
     # that replaces the transformed piecewise linear expr
-    def _transform_pw_linear_expr(self, pw_expr, pw_linear_func, transformation_block):
+    def _transform_multiple_segment_pw_linear_expr(
+        self, pw_expr, pw_linear_func, transformation_block
+    ):
         # Get a new Block for our transformation in transformation_block.transformed_functions,
         # which is a Block(Any). This is where we will put our new components.
         transBlock = transformation_block.transformed_functions[