Testing the normally bigm-ed constraints

Author: emma58

pyomo/gdp/tests/test_mbigm.py

@@ -16,6 +16,7 @@
 from pyomo.common.fileutils import import_file, PYOMO_ROOT_DIR
 from pyomo.common.log import LoggingIntercept
 import pyomo.common.unittest as unittest
+from pyomo.core.expr.compare import assertExpressionsEqual
 
 from pyomo.environ import (
     BooleanVar, ConcreteModel, Constraint, LogicalConstraint,
@@ -665,5 +666,64 @@ def test_only_multiple_bigm_bound_constraints(self):
         self.check_pretty_bound_constraints(cons[1], m.x2, {m.d1: 3, m.d2: 10,
                                                             m.d3: 1}, lb=False)
 
-        # TODO: now we check that the other constraints were transformed with
-        # normal bigm
+        cons = mbm.get_transformed_constraints(m.d1.func)
+        self.assertEqual(len(cons), 2)
+        lb = cons[0]
+        ub = cons[1]
+        assertExpressionsEqual(self, lb.expr, 0.0 <= m.x1 + m.x2 - m.d -
+                               (-1030.0)*(1 - m.d1.binary_indicator_var))
+        # [ESJ 11/23/22]: It's really hard to use assertExpressionsEqual on the
+        # ub constraints because SumExpressions are sharing args, I think. So
+        # when they get constructed in the transformation (because they come
+        # after the lb constraints), there are nested SumExpressions. Instead of
+        # trying to reproduce them I am just building a "flat" SumExpression
+        # with generate_standard_repn and comparing that.
+        self.assertIsNone(ub.lower)
+        self.assertEqual(ub.upper, 0)
+        repn = generate_standard_repn(ub.body)
+        self.assertTrue(repn.is_linear())
+        simplified = repn.constant + sum(
+            repn.linear_coefs[i]*repn.linear_vars[i]
+            for i in range(len(repn.linear_vars)))
+        assertExpressionsEqual(
+            self,
+            simplified,
+            m.x1 + m.x2 - m.d + 1030.0*m.d1.binary_indicator_var - 1030.0)
+
+        cons = mbm.get_transformed_constraints(m.d2.func)
+        self.assertEqual(len(cons), 2)
+        lb = cons[0]
+        ub = cons[1]
+        print(lb.expr)
+        assertExpressionsEqual(self, lb.expr, 0.0 <= 2*m.x1 + 4*m.x2 + 7 - m.d -
+                               (-1093.0)*(1 - m.d2.binary_indicator_var))
+        self.assertIsNone(ub.lower)
+        self.assertEqual(ub.upper, 0)
+        repn = generate_standard_repn(ub.body)
+        self.assertTrue(repn.is_linear())
+        simplified = repn.constant + sum(
+            repn.linear_coefs[i]*repn.linear_vars[i]
+            for i in range(len(repn.linear_vars)))
+        assertExpressionsEqual(
+            self,
+            simplified,
+            2*m.x1 + 4*m.x2 - m.d + 1107.0*m.d2.binary_indicator_var - 1100.0)
+
+        cons = mbm.get_transformed_constraints(m.d3.func)
+        self.assertEqual(len(cons), 2)
+        lb = cons[0]
+        ub = cons[1]
+        print(lb.expr)
+        assertExpressionsEqual(self, lb.expr, 0.0 <= m.x1 - 5*m.x2 - 3 - m.d -
+                               (-1113.0)*(1 - m.d3.binary_indicator_var))
+        self.assertIsNone(ub.lower)
+        self.assertEqual(ub.upper, 0)
+        repn = generate_standard_repn(ub.body)
+        self.assertTrue(repn.is_linear())
+        simplified = repn.constant + sum(
+            repn.linear_coefs[i]*repn.linear_vars[i]
+            for i in range(len(repn.linear_vars)))
+        assertExpressionsEqual(
+            self,
+            simplified,
+            m.x1 - 5*m.x2 - m.d + 1107.0*m.d3.binary_indicator_var - 1110.0)