Add parameter support to DNLP diff engine

Enable cp.Parameter objects to be treated as updatable nodes in the C
expression DAG instead of being baked in as constants. On re-solve with
new parameter values, the cached DAG and sparsity structures are reused
via problem._nlp_cache, analogous to DPP for conic programs.

Requires SparseDiffPy PR #10 for make_parameter, problem_register_params,
and problem_update_params bindings. Tests skip gracefully until installed.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Transurgeon

cvxpy/problems/problem.py

@@ -176,6 +176,7 @@ def __init__(
         self._status: Optional[str] = None
         self._solution = None
         self._cache = Cache()
+        self._nlp_cache = None
         self._solver_cache = {}
         # Information about the shape of the problem and its constituent parts
         self._size_metrics: Optional["SizeMetrics"] = None

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

@@ -25,12 +25,40 @@
 class C_problem:
     """Wrapper around C problem struct for CVXPY problems."""
 
-    def __init__(self, cvxpy_problem: cp.Problem, verbose: bool = True):
+    def __init__(self, cvxpy_problem: cp.Problem, verbose: bool = True,
+                 inverse_data=None):
+        """Create a C problem from a CVXPY problem.
+
+        Args:
+            cvxpy_problem: CVXPY Problem object
+            verbose: print solver output
+            inverse_data: InverseData with param_id_map. When provided,
+                cp.Parameter objects are converted to updatable C parameter
+                nodes instead of being baked in as constants.
+        """
         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]
+
+        param_nodes = [] if inverse_data is not None else None
+        c_obj = convert_expr(cvxpy_problem.objective.expr, var_dict, n_vars,
+                             inverse_data, param_nodes)
+        c_constraints = [convert_expr(c.expr, var_dict, n_vars,
+                                      inverse_data, param_nodes)
+                         for c in cvxpy_problem.constraints]
         self._capsule = _diffengine.make_problem(c_obj, c_constraints, verbose)
 
+        if param_nodes:
+            _diffengine.problem_register_params(self._capsule, param_nodes)
+
+    def update_params(self, theta: np.ndarray) -> None:
+        """Update parameter values in the C DAG.
+
+        Sparsity structures (Jacobian/Hessian) remain valid after this call.
+
+        Args:
+            theta: flat array of parameter values, ordered by InverseData offsets
+        """
+        _diffengine.problem_update_params(self._capsule, theta)
+
     def init_jacobian_coo(self):
         """Fill sparsity for the constraint Jacobian in COO format.