Add diff_engine integration layer for CVXPY-to-C expression conversion

- Create cvxpy/reductions/solvers/nlp_solvers/diff_engine/ package
- Move C_problem wrapper and ATOM_CONVERTERS from dnlp-diff-engine
- converters.py: Expression tree conversion from CVXPY atoms to C nodes
- c_problem.py: C_problem class wrapping the C problem struct
- Update nlp_solver.py to import from new location

This separates CVXPY-specific glue code from the pure C autodiff library,
eliminating circular dependencies and preparing dnlp-diff-engine for
standalone PyPI distribution.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Transurgeon

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,90 @@
+"""
+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.
+"""
+
+"""
+Wrapper around C problem struct for CVXPY problems.
+"""
+
+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 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)