IPOPT now returns Lagrange multpliers using the same sign convention as SNOPT. (#416)

* Restored lagrange multipliers in the string representation of the solution.

Added lagrange multipliers to IPOPT's output. Note that in the call to _createSolution we negate the multiplier values so that they are consistent with those returned by SNOPT.
My understanding is that this is a matter of convention (due to the internal representations of the problems in the two optimizers).

* added ParOpt to optimizers which check lambdas

* ran black on test_hs071.py

* Reverted IPOPT to return is Lagrange multipliers unchanged.

* formatting and comment for posterity

---------

Co-authored-by: Marco Mangano <mmangano@umich.edu>

Author: robfalck

pyoptsparse/pyIPOPT/pyIPOPT.py

@@ -296,7 +296,7 @@ def eval_intermediate_callback(*args, **kwargs):
             sol_inform["text"] = self.informs[status]
 
             # Create the optimization solution
-            sol = self._createSolution(optTime, sol_inform, obj, x)
+            sol = self._createSolution(optTime, sol_inform, obj, x, multipliers=constraint_multipliers)
 
             # Indicate solution finished
             self.optProb.comm.bcast(-1, root=0)

pyoptsparse/pyOpt_optimization.py

@@ -1577,7 +1577,7 @@ def _mapContoOpt_Dict(self, conDict: Dict1DType) -> Dict1DType:
         con_opt = self._mapContoOpt(con)
         return self.processContoDict(con_opt, scaled=False, natural=True)
 
-    def summary_str(self, minimal_print=False):
+    def summary_str(self, minimal_print=False, print_multipliers=False):
         """
         Print Structured Optimization Problem
 
@@ -1588,6 +1588,8 @@ def summary_str(self, minimal_print=False):
             variables and constraints with a non-empty status
             (for example a violated bound).
             This defaults to False, which will print all results.
+        print_multipliers : bool
+            If True, print the Lagrange multipliers associated with the constraints.
         """
         TOL = 1.0e-6
 
@@ -1656,7 +1658,7 @@ def summary_str(self, minimal_print=False):
 
         if len(self.constraints) > 0:
             # must be an instance of the Solution class
-            if not isinstance(self, Optimization) and self.lambdaStar is not None:
+            if print_multipliers and self.lambdaStar is not None:
                 lambdaStar = self.lambdaStar
                 lambdaStar_label = "Lagrange Multiplier"
             else:
@@ -1716,7 +1718,7 @@ def summary_str(self, minimal_print=False):
         return text
 
     def __str__(self):
-        return self.summary_str(minimal_print=False)
+        return self.summary_str(minimal_print=False, print_multipliers=False)
 
     def __getstate__(self) -> dict:
         """

pyoptsparse/pyOpt_solution.py

@@ -75,7 +75,7 @@ def __str__(self) -> str:
         """
         Print Structured Solution
         """
-        text0 = super().__str__()
+        text0 = self.summary_str(minimal_print=False, print_multipliers=True)
         text1 = ""
         lines = text0.split("\n")
         lines[1] = lines[1][len("Optimization Problem -- ") :]

tests/test_hs071.py

@@ -210,9 +210,28 @@ def test_optimization(self, optName):
         optOptions = self.optOptions.pop(optName, None)
         sol = self.optimize(optOptions=optOptions)
         # Check Solution
-        self.assert_solution_allclose(sol, self.tol[optName])
+        lambda_sign = -1.0 if optName == "IPOPT" else 1.0
+        self.assert_solution_allclose(sol, self.tol[optName], lambda_sign=lambda_sign)
         # Check informs
         self.assert_inform_equal(sol)
+        # Check the lagrange multipliers in the solution text
+        lines = str(sol).split("\n")
+        constraint_header_line_num = [i for i, line in enumerate(lines) if "Constraints" in line][0]
+        con1_line_num = constraint_header_line_num + 2
+        con2_line_num = constraint_header_line_num + 3
+        lambda_con1 = float(lines[con1_line_num].split()[-1])
+        lambda_con2 = float(lines[con2_line_num].split()[-1])
+        if optName in ("IPOPT", "SNOPT", "ParOpt"):
+            # IPOPT returns Lagrange multipliers with opposite sign than SNOPT and ParOpt
+            lambda_sign = -1.0 if optName == "IPOPT" else 1.0
+            assert_allclose(
+                [lambda_con1, lambda_con2],
+                lambda_sign * np.asarray(self.lambdaStar[0]["con"]),
+                rtol=1.0e-5,
+                atol=1.0e-5,
+            )
+        else:
+            assert_allclose([lambda_con1, lambda_con2], [9.0e100, 9.0e100], rtol=1.0e-5, atol=1.0e-5)
 
 
 if __name__ == "__main__":

tests/testing_utils.py

@@ -85,7 +85,7 @@ class OptTest(unittest.TestCase):
     def setUp(self):
         self.histFileName = None
 
-    def assert_solution_allclose(self, sol, tol, partial_x=False):
+    def assert_solution_allclose(self, sol, tol, partial_x=False, lambda_sign=1.0):
         """
         An assertion method to check that the solution object matches the expected
         optimum values defined in the class.
@@ -100,6 +100,10 @@ def assert_solution_allclose(self, sol, tol, partial_x=False):
             Whether partial assertion of the design variables ``x`` is allowed.
             For large problems, we may not have the full x vector available at the optimum,
             so we only check a few entries.
+        lambda_sign : float
+            The sign of the Lagrange multipliers returned by the optimizer. By convention,
+            SNOPT and ParOpt return a sign that agrees with the test data, while IPOPT
+            returns the opposite sign.
         """
         if not isinstance(self.xStar, list):
             self.xStar = [self.xStar]
@@ -139,7 +143,8 @@ def assert_solution_allclose(self, sol, tol, partial_x=False):
             and self.lambdaStar is not None
             and sol.lambdaStar is not None
         ):
-            assert_dict_allclose(sol.lambdaStar, self.lambdaStar[self.sol_index], atol=tol, rtol=tol)
+            lamStar = {con: lambda_sign * lam for con, lam in sol.lambdaStar.items()}
+            assert_dict_allclose(lamStar, self.lambdaStar[self.sol_index], atol=tol, rtol=tol)
 
         # test printing solution
         print(sol)