Draft: change nlp_solver Oracles class to use C diffengine.

cvxpy/problems/problem.py

@@ -1268,10 +1268,21 @@ def _solve(self,
                     canon_problem, inverse_data = nlp_chain.apply(problem=self)
                     solution = nlp_chain.solver.solve_via_data(canon_problem, warm_start,
                                                                 verbose, solver_opts=kwargs)
+
+                    # This gives the objective value of the C problem
+                    # which can be slightly different from the original NLP 
+                    # so we use the below approach with unpacking. Preferably 
+                    # we would have a way to do this without unpacking.
+                    #obj_value = canon_problem['objective'](solution['x'])
+
+                    # set cvxpy variable
+                    self.unpack_results(solution, nlp_chain, inverse_data)
                     obj_value = self.objective.value
+
                     all_objs[run] = obj_value
                     if obj_value < best_obj:
                         best_obj = obj_value
+                        print("best_obj: ", best_obj)
                         best_solution = solution
 
                 # unpack best solution    
@@ -1593,7 +1604,7 @@ def unpack(self, solution) -> None:
     def unpack_results(self, solution, chain: SolvingChain, inverse_data) -> None:
         """Updates the problem state given the solver results.
 
-        Updates problem.status, problem.value and value of
+        Updates problem.status, problem.value and value ofro
         primal and dual variables.
 
         Arguments

cvxpy/reductions/dnlp2smooth/canonicalizers/log_sum_exp_canon.py

@@ -31,7 +31,7 @@ def log_sum_exp_canon(expr, args):
 
     if x.value is not None:
         t.value = expr.numeric(x.value)
-        v.value = x.value - t.value
+        v.value = np.minimum(x.value - t.value, -1)
     else:
         t.value = np.ones(expr.shape)
         v.value = -np.ones(x.shape)

cvxpy/reductions/solvers/nlp_solvers/diff_engine/__init__.py

@@ -0,0 +1,38 @@
+"""
+Copyright 2025, the CVXPY developers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""
+CVXPY integration layer for the DNLP diff engine.
+
+This module converts CVXPY expressions to C expression trees
+for automatic differentiation.
+"""
+
+from cvxpy.reductions.solvers.nlp_solvers.diff_engine.c_problem import C_problem
+from cvxpy.reductions.solvers.nlp_solvers.diff_engine.converters import (
+    ATOM_CONVERTERS,
+    build_variable_dict,
+    convert_expr,
+    convert_expressions,
+)
+
+__all__ = [
+    "C_problem",
+    "ATOM_CONVERTERS",
+    "build_variable_dict",
+    "convert_expr",
+    "convert_expressions",
+]

cvxpy/reductions/solvers/nlp_solvers/diff_engine/c_problem.py

@@ -0,0 +1,97 @@
+"""Wrapper around C problem struct for CVXPY problems.
+
+Copyright 2025, the CVXPY developers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import numpy as np
+from scipy import sparse
+
+import cvxpy as cp
+
+# Import the low-level C bindings
+try:
+    import dnlp_diff_engine as _diffengine
+except ImportError as e:
+    raise ImportError(
+        "dnlp-diff-engine is required for NLP solving. "
+        "Install with: pip install dnlp-diff-engine"
+    ) from e
+
+from cvxpy.reductions.solvers.nlp_solvers.diff_engine.converters import (
+    build_variable_dict,
+    convert_expr,
+)
+
+
+class C_problem:
+    """Wrapper around C problem struct for CVXPY problems."""
+
+    def __init__(self, cvxpy_problem: cp.Problem):
+        var_dict, n_vars = build_variable_dict(cvxpy_problem.variables())
+        c_obj = convert_expr(cvxpy_problem.objective.expr, var_dict, n_vars)
+        c_constraints = [convert_expr(c.expr, var_dict, n_vars) for c in cvxpy_problem.constraints]
+        self._capsule = _diffengine.make_problem(c_obj, c_constraints)
+        self._allocated = False
+
+    def init_derivatives(self):
+        """Initialize derivative structures. Must be called before forward/gradient/jacobian."""
+        _diffengine.problem_init_derivatives(self._capsule)
+        self._allocated = True
+
+    def objective_forward(self, u: np.ndarray) -> float:
+        """Evaluate objective. Returns obj_value float."""
+        return _diffengine.problem_objective_forward(self._capsule, u)
+
+    def constraint_forward(self, u: np.ndarray) -> np.ndarray:
+        """Evaluate constraints only. Returns constraint_values array."""
+        return _diffengine.problem_constraint_forward(self._capsule, u)
+
+    def gradient(self) -> np.ndarray:
+        """Compute gradient of objective. Call objective_forward first. Returns gradient array."""
+        return _diffengine.problem_gradient(self._capsule)
+
+    def jacobian(self) -> sparse.csr_matrix:
+        """Compute constraint Jacobian. Call constraint_forward first."""
+        data, indices, indptr, shape = _diffengine.problem_jacobian(self._capsule)
+        return sparse.csr_matrix((data, indices, indptr), shape=shape)
+
+    def get_jacobian(self) -> sparse.csr_matrix:
+        """Get constraint Jacobian. This function does not evaluate the jacobian. """
+        data, indices, indptr, shape = _diffengine.get_jacobian(self._capsule)
+        return sparse.csr_matrix((data, indices, indptr), shape=shape)
+
+    def hessian(self, obj_factor: float, lagrange: np.ndarray) -> sparse.csr_matrix:
+        """Compute Lagrangian Hessian.
+
+        Computes: obj_factor * H_obj + sum(lagrange_i * H_constraint_i)
+
+        Call objective_forward and constraint_forward before this.
+
+        Args:
+            obj_factor: Weight for objective Hessian
+            lagrange: Array of Lagrange multipliers (length = total_constraint_size)
+
+        Returns:
+            scipy CSR matrix of shape (n_vars, n_vars)
+        """
+        data, indices, indptr, shape = _diffengine.problem_hessian(
+            self._capsule, obj_factor, lagrange
+        )
+        return sparse.csr_matrix((data, indices, indptr), shape=shape)
+
+    def get_hessian(self) -> sparse.csr_matrix:
+        """Get Lagrangian Hessian. This function does not evaluate the hessian."""
+        data, indices, indptr, shape = _diffengine.get_hessian(self._capsule)
+        return sparse.csr_matrix((data, indices, indptr), shape=shape)