Add get_current_iterate and get_current_violations methods to Problem class

.github/workflows/tests.yml

@@ -54,6 +54,6 @@ jobs:
         # Ipopt needed different libfortrans.
         if: (matrix.ipopt-version != '3.12' && matrix.python-version != '3.11') || (matrix.ipopt-version != '3.12' && matrix.python-version != '3.10' && matrix.os != 'macos-latest')
         run: |
-          mamba install -q -y -c conda-forge cython>=0.26 "ipopt=${{ matrix.ipopt-version }}" numpy>=1.15 pkg-config>=0.29.2 setuptools>=39.0 pytest>=3.3.2 scipy>=0.19.0
+          mamba install -q -y -c conda-forge cython>=0.26 "ipopt=${{ matrix.ipopt-version }}" numpy>=1.15 pkg-config>=0.29.2 setuptools>=39.0 pytest>=3.3.2 scipy==1.10.0
           mamba list
           pytest

cyipopt/cython/ipopt.pxd

@@ -9,7 +9,78 @@ Copyright (C) 2017-2023 cyipopt developers
 License: EPL 2.0
 """
 
+cdef extern from "IpoptConfig.h":
+
+    int IPOPT_VERSION_MAJOR
+
+    int IPOPT_VERSION_MINOR
+
+    int IPOPT_VERSION_RELEASE
+
+
 cdef extern from "IpStdCInterface.h":
+    """
+    #define VERSION_LT_3_14_0\
+        (IPOPT_VERSION_MAJOR < 3\
+            || (IPOPT_VERSION_MAJOR == 3 && IPOPT_VERSION_MINOR < 14))
+
+    #if VERSION_LT_3_14_0
+        // If not defined, define dummy versions of these functions
+        Bool GetIpoptCurrentIterate(
+                        IpoptProblem ipopt_problem,
+                        Bool scaled,
+                        Index n,
+                        Number* x,
+                        Number* z_L,
+                        Number* z_U,
+                        Index m,
+                        Number* g,
+                        Number* lambd
+                        ){
+            return 0;
+        }
+        Bool GetIpoptCurrentViolations(
+                        IpoptProblem ipopt_problem,
+                        Bool scaled,
+                        Index n,
+                        Number* x_L_violation,
+                        Number* x_U_violation,
+                        Number* compl_x_L,
+                        Number* compl_x_U,
+                        Number* grad_lag_x,
+                        Index m,
+                        Number* nlp_constraint_violation,
+                        Number* compl_g
+                        ){
+            return 0;
+        }
+        #define _ip_get_iter(\
+                problem, scaled, n, x, z_L, z_U, m, g, lambd\
+            )\
+            GetIpoptCurrentIterate(\
+                problem, scaled, n, x, z_L, z_U, m, g, lambd\
+            )
+        #define _ip_get_viol(\
+                problem, scaled, n, xL, xU, complxL, complxU, glx, m, cviol, complg\
+            )\
+            GetIpoptCurrentViolations(\
+                problem, scaled, n, xL, xU, complxL, complxU, glx, m, cviol, complg\
+            )
+    #else
+        #define _ip_get_iter(\
+                problem, scaled, n, x, z_L, z_U, m, g, lambd\
+            )\
+            GetIpoptCurrentIterate(\
+                problem, scaled, n, x, z_L, z_U, m, g, lambd\
+            )
+        #define _ip_get_viol(\
+                problem, scaled, n, xL, xU, complxL, complxU, glx, m, cviol, complg\
+            )\
+            GetIpoptCurrentViolations(\
+                problem, scaled, n, xL, xU, complxL, complxU, glx, m, cviol, complg\
+            )
+    #endif
+    """
 
     ctypedef double Number
 
@@ -167,3 +238,33 @@ cdef extern from "IpStdCInterface.h":
                     Number* mult_x_U,
                     UserDataPtr user_data
                     )
+
+    # Wrapper around GetIpoptCurrentIterate with a dummy implementation in
+    # case it is not defined (i.e. Ipopt < 3.14.0)
+    Bool CyGetCurrentIterate "_ip_get_iter" (
+                    IpoptProblem ipopt_problem,
+                    Bool scaled,
+                    Index n,
+                    Number* x,
+                    Number* z_L,
+                    Number* z_U,
+                    Index m,
+                    Number* g,
+                    Number* lambd
+                    )
+
+    # Wrapper around GetIpoptCurrentViolations with a dummy implementation in
+    # case it is not defined (i.e. Ipopt < 3.14.0)
+    Bool CyGetCurrentViolations "_ip_get_viol" (
+                    IpoptProblem ipopt_problem,
+                    Bool scaled,
+                    Index n,
+                    Number* x_L_violation,
+                    Number* x_U_violation,
+                    Number* compl_x_L,
+                    Number* compl_x_U,
+                    Number* grad_lag_x,
+                    Index m,
+                    Number* nlp_constraint_violation,
+                    Number* compl_g
+                    )

cyipopt/cython/ipopt_wrapper.pyx

@@ -12,14 +12,19 @@ License: EPL 2.0
 import logging
 import sys
 import warnings
+import inspect
 
 import numpy as np
 cimport numpy as np
 
 from cyipopt.utils import deprecated_warning, generate_deprecation_warning_msg
 from ipopt cimport *
 
-__all__ = ["set_logging_level", "setLoggingLevel", "Problem", "problem"]
+__all__ = [
+    "set_logging_level", "setLoggingLevel", "Problem", "problem", "IPOPT_VERSION"
+]
+
+IPOPT_VERSION = (IPOPT_VERSION_MAJOR, IPOPT_VERSION_MINOR, IPOPT_VERSION_RELEASE)
 
 DTYPEi = np.int32
 ctypedef np.int32_t DTYPEi_t
@@ -275,6 +280,7 @@ cdef class Problem:
     cdef public Index __m
 
     cdef public object __exception
+    cdef Bool __in_ipopt_solve
 
     def __init__(self, n, m, problem_obj=None, lb=None, ub=None, cl=None,
                  cu=None):
@@ -433,6 +439,10 @@ cdef class Problem:
 
         self.__exception = None
 
+        # This flag is necessary to prevent segfaults in Ipopt <=3.14.11 due
+        # to the lack of guard for __nlp->tnlp being NULL or undefined.
+        self.__in_ipopt_solve = False
+
     def __dealloc__(self):
         if self.__nlp != NULL:
             FreeIpoptProblem(self.__nlp)
@@ -628,6 +638,9 @@ cdef class Problem:
 
         cdef Number obj_val = 0
 
+        # Set flag that we are in a solve, so __nlp->tnlp references (e.g. in
+        # get_current_iterate) are valid.
+        self.__in_ipopt_solve = True
         stat = IpoptSolve(self.__nlp,
                           <Number*>np_x.data,
                           <Number*>g.data,
@@ -637,6 +650,8 @@ cdef class Problem:
                           <Number*>mult_x_U.data,
                           <UserDataPtr>self
                           )
+        # Unset flag
+        self.__in_ipopt_solve = False
 
         if self.__exception:
             raise self.__exception[0], self.__exception[1], self.__exception[2]
@@ -654,6 +669,185 @@ cdef class Problem:
 
         return np_x, info
 
+    def get_current_iterate(self, scaled=False):
+        """Return the current iterate vectors during an Ipopt solve
+
+        The iterate contains vectors for primal variables, bound multipliers,
+        constraint function values, and constraint multipliers. Here, the
+        constraints are treated as a single function rather than separating
+        equality and inequality constraints. This method can only be called
+        during an intermediate callback.
+
+        **Only supports Ipopt >=3.14.0**
+
+        Parameters
+        ----------
+        scaled: Bool
+            Whether the scaled iterate vectors should be returned
+
+        Returns
+        -------
+        dict or None
+            A dict containing the iterate vector with keys ``"x"``,
+            ``"mult_x_L"``, ``"mult_x_U"``, ``"g"``, and ``"mult_g"``.
+            If iterate vectors cannot be obtained, ``None`` is returned.
+
+        """
+        # Check that we are using an Ipopt version that supports this
+        # functionality
+        major, minor, release = IPOPT_VERSION
+        if major < 3 or (major == 3 and minor < 14):
+            raise RuntimeError(
+                "get_current_iterate only supports Ipopt version >=3.14.0"
+                " CyIpopt is compiled with version %s.%s.%s"
+                % (major, minor, release)
+            )
+        # Check that we are in a solve. This is necessary to prevent segfaults
+        # pre-Ipopt 3.14.12
+        if not self.__in_ipopt_solve:
+            raise RuntimeError(
+                "get_current_iterate can only be called during a call to solve,"
+                " e.g. in an intermediate callback."
+            )
+        # Allocate arrays to hold the current iterate
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_x
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_mult_x_L
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_mult_x_U
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_g
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_mult_g
+        np_x = np.zeros((self.__n,), dtype=DTYPEd).flatten()
+        np_mult_x_L = np.zeros((self.__n,), dtype=DTYPEd).flatten()
+        np_mult_x_U = np.zeros((self.__n,), dtype=DTYPEd).flatten()
+        np_g = np.zeros((self.__m,), dtype=DTYPEd).flatten()
+        np_mult_g = np.zeros((self.__m,), dtype=DTYPEd).flatten()
+
+        # Cast to C data types
+        x = <Number*>np_x.data
+        mult_x_L = <Number*>np_mult_x_L.data
+        mult_x_U = <Number*>np_mult_x_U.data
+        g = <Number*>np_g.data
+        mult_g = <Number*>np_mult_g.data
+
+        successful = CyGetCurrentIterate(
+            self.__nlp,
+            scaled,
+            self.__n,
+            x,
+            mult_x_L,
+            mult_x_U,
+            self.__m,
+            g,
+            mult_g,
+        )
+        if successful:
+            # Return values to user
+            return {
+                "x": np_x,
+                "mult_x_L": np_mult_x_L,
+                "mult_x_U": np_mult_x_U,
+                "g": np_g,
+                "mult_g": np_mult_g,
+            }
+        else:
+            # This happens if this method is called during IpoptSolve,
+            # but outside of an intermediate callback.
+            return None
+
+    def get_current_violations(self, scaled=False):
+        """Return the current violation vectors during an Ipopt solve
+
+        Violations returned are primal variable bound violations, bound
+        complementarities, the gradient of the Lagrangian, constraint
+        violation, and constraint complementarity. Here, the constraints
+        are treated as a single function rather than separating equality
+        and inequality constraints. This method can only be called during
+        an intermediate callback.
+
+        **Only supports Ipopt >=3.14.0**
+
+        Parameters
+        ----------
+        scaled: Bool
+            Whether to scale the returned violations
+
+        Returns
+        -------
+        dict or None
+            A dict containing the violation vector with keys
+            ``"x_L_violation"``, ``"x_U_violation"``, ``"compl_x_L"``,
+            ``"compl_x_U"``, ``"grad_lag_x"``, ``"g_violation"``,
+            and ``"compl_g"``. If violation vectors cannot be obtained,
+            ``None`` is returned.
+
+        """
+        major, minor, release = IPOPT_VERSION
+        if major < 3 or (major == 3 and minor < 14):
+            raise RuntimeError(
+                "get_current_violations only supports Ipopt version >=3.14.0"
+                " CyIpopt is compiled with version %s.%s.%s"
+                % (major, minor, release)
+            )
+        # Check that we are in a solve. This is necessary to prevent segfaults
+        # pre-Ipopt 3.14.12
+        if not self.__in_ipopt_solve:
+            raise RuntimeError(
+                "get_current_violations can only be called during a call to solve,"
+                " e.g. in an intermediate callback."
+            )
+        # Allocate arrays to hold current violations
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_x_L_viol
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_x_U_viol
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_compl_x_L
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_compl_x_U
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_grad_lag_x
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_g_viol
+        cdef np.ndarray[DTYPEd_t, ndim=1] np_compl_g
+        np_x_L_viol = np.zeros((self.__n,), dtype=DTYPEd).flatten()
+        np_x_U_viol = np.zeros((self.__n,), dtype=DTYPEd).flatten()
+        np_compl_x_L = np.zeros((self.__n,), dtype=DTYPEd).flatten()
+        np_compl_x_U = np.zeros((self.__n,), dtype=DTYPEd).flatten()
+        np_grad_lag_x = np.zeros((self.__n,), dtype=DTYPEd).flatten()
+        np_g_viol = np.zeros((self.__m,), dtype=DTYPEd).flatten()
+        np_compl_g = np.zeros((self.__m,), dtype=DTYPEd).flatten()
+
+        # Cast to C data types
+        x_L_viol = <Number*>np_x_L_viol.data
+        x_U_viol = <Number*>np_x_U_viol.data
+        compl_x_L = <Number*>np_compl_x_L.data
+        compl_x_U = <Number*>np_compl_x_U.data
+        grad_lag_x = <Number*>np_grad_lag_x.data
+        g_viol = <Number*>np_g_viol.data
+        compl_g = <Number*>np_compl_g.data
+
+        successful = CyGetCurrentViolations(
+            self.__nlp,
+            scaled,
+            self.__n,
+            x_L_viol,
+            x_U_viol,
+            compl_x_L,
+            compl_x_U,
+            grad_lag_x,
+            self.__m,
+            g_viol,
+            compl_g,
+        )
+        if successful:
+            # Return values to the user
+            return {
+                "x_L_violation": np_x_L_viol,
+                "x_U_violation": np_x_U_viol,
+                "compl_x_L": np_compl_x_L,
+                "compl_x_U": np_compl_x_U,
+                "grad_lag_x": np_grad_lag_x,
+                "g_violation": np_g_viol,
+                "compl_g": np_compl_g,
+            }
+        else:
+            # This happens if this method is called during IpoptSolve,
+            # but outside of an intermediate callback.
+            return None
+
 
 #
 # Callback functions

cyipopt/tests/conftest.py

@@ -111,7 +111,7 @@ def intermediate(*args):
 
 
 @pytest.fixture()
-def hs071_defintion_instance_fixture(hs071_objective_fixture,
+def hs071_definition_instance_fixture(hs071_objective_fixture,
                                      hs071_gradient_fixture,
                                      hs071_constraints_fixture,
                                      hs071_jacobian_fixture,
@@ -175,15 +175,15 @@ def hs071_constraint_upper_bounds_fixture():
 
 
 @pytest.fixture()
-def hs071_problem_instance_fixture(hs071_defintion_instance_fixture,
+def hs071_problem_instance_fixture(hs071_definition_instance_fixture,
                                    hs071_initial_guess_fixture,
                                    hs071_variable_lower_bounds_fixture,
                                    hs071_variable_upper_bounds_fixture,
                                    hs071_constraint_lower_bounds_fixture,
                                    hs071_constraint_upper_bounds_fixture,
                                    ):
     """Return a default cyipopt.Problem instance of the hs071 test problem."""
-    problem_definition = hs071_defintion_instance_fixture
+    problem_definition = hs071_definition_instance_fixture
     x0 = hs071_initial_guess_fixture
     lb = hs071_variable_lower_bounds_fixture
     ub = hs071_variable_upper_bounds_fixture