Remove redundant n_params from diff engine API

n_params was only used for a size validation check and can be computed
from n_param_nodes + each node's size. This simplifies the API by
removing one argument from problem_register_params and one field to
maintain.

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

Author: Transurgeon

cvxpy/reductions/dcp2cone/diff_engine_param_cone_prog.py

@@ -110,14 +110,13 @@ def __init__(
 
         all_params = list({p.id: p for p in self.parameters}.values())
         if all_params:
-            param_dict, param_capsules, n_params = build_parameter_dict(
+            param_dict, param_capsules = build_parameter_dict(
                 all_params, n_vars
             )
         else:
-            param_dict, param_capsules, n_params = None, [], 0
+            param_dict, param_capsules = None, []
 
         self._all_params = all_params
-        self._n_params = n_params
 
         # Convert objective.
         c_objective = convert_expr(objective_expr, var_dict, n_vars, param_dict)
@@ -135,7 +134,7 @@ def __init__(
         # Register parameters.
         if param_capsules:
             _diffengine.problem_register_params(
-                self._capsule, param_capsules, n_params
+                self._capsule, param_capsules
             )
 
         # Initialize derivative structures.
@@ -158,9 +157,9 @@ def is_mixed_integer(self):
 
     def _update_params(self):
         """Push current parameter values to the C expression tree."""
-        if self._n_params == 0:
+        if not self._all_params:
             return
-        theta = np.empty(self._n_params)
+        theta = np.empty(sum(p.size for p in self._all_params))
         offset = 0
         for param in self._all_params:
             val = np.asarray(param.value, dtype=np.float64).flatten(order='F')

cvxpy/reductions/solvers/nlp_solvers/diff_engine/_bindings/problem/register_params.h

@@ -7,9 +7,8 @@ static PyObject *py_problem_register_params(PyObject *self, PyObject *args)
 {
     PyObject *prob_capsule;
     PyObject *param_list;
-    int n_params;
 
-    if (!PyArg_ParseTuple(args, "OOi", &prob_capsule, &param_list, &n_params))
+    if (!PyArg_ParseTuple(args, "OO", &prob_capsule, &param_list))
     {
         return NULL;
     }
@@ -54,7 +53,7 @@ static PyObject *py_problem_register_params(PyObject *self, PyObject *args)
         }
     }
 
-    problem_register_params(prob, param_nodes, (int) n_param_nodes, n_params);
+    problem_register_params(prob, param_nodes, (int) n_param_nodes);
     free(param_nodes);
 
     Py_RETURN_NONE;

cvxpy/reductions/solvers/nlp_solvers/diff_engine/_bindings/problem/update_params.h

@@ -29,12 +29,15 @@ static PyObject *py_problem_update_params(PyObject *self, PyObject *args)
     }
 
     int theta_size = (int) PyArray_SIZE(theta_array);
-    if (theta_size != prob->n_params)
+    int expected = 0;
+    for (int i = 0; i < prob->n_param_nodes; i++)
+        expected += prob->param_nodes[i]->size;
+    if (theta_size != expected)
     {
         Py_DECREF(theta_array);
         PyErr_Format(PyExc_ValueError,
-                     "theta size %d does not match n_params %d",
-                     theta_size, prob->n_params);
+                     "theta size %d does not match expected %d",
+                     theta_size, expected);
         return NULL;
     }
 

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

@@ -37,19 +37,18 @@ class C_problem:
     """Wrapper around C problem struct for CVXPY problems."""
 
     def __init__(self, cvxpy_problem: cp.Problem, verbose: bool = True):
-        c_obj, c_constraints, param_capsules, n_params, all_params = (
+        c_obj, c_constraints, param_capsules, all_params = (
             convert_expressions(cvxpy_problem)
         )
         self._capsule = _diffengine.make_problem(c_obj, c_constraints, verbose)
 
         # Register parameters with the C problem
         if param_capsules:
             _diffengine.problem_register_params(
-                self._capsule, param_capsules, n_params
+                self._capsule, param_capsules
             )
 
         self._all_params = all_params
-        self._n_params = n_params
         self._jacobian_allocated = False
         self._hessian_allocated = False
 
@@ -119,9 +118,9 @@ def update_params(self):
         without rebuilding it. After calling this, objective_forward/gradient/etc.
         will use the new parameter values.
         """
-        if self._n_params == 0:
+        if not self._all_params:
             return
-        theta = np.empty(self._n_params)
+        theta = np.empty(sum(p.size for p in self._all_params))
         offset = 0
         for param in self._all_params:
             val = np.asarray(param.value, dtype=np.float64).flatten(order='F')

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

@@ -435,7 +435,7 @@ def build_variable_dict(variables: list) -> tuple[dict, int]:
     return var_dict, n_vars
 
 
-def build_parameter_dict(parameters: list, n_vars: int) -> tuple[dict, list, int]:
+def build_parameter_dict(parameters: list, n_vars: int) -> tuple[dict, list]:
     """
     Build dictionary mapping CVXPY parameter ids to C parameter nodes.
 
@@ -446,9 +446,8 @@ def build_parameter_dict(parameters: list, n_vars: int) -> tuple[dict, list, int
     Returns:
         param_dict: {param.id: c_param_node} mapping
         param_capsules: list of C capsules for registration
-        n_params: total scalar parameter count
     """
-    id_map, _, n_params, param_shapes = InverseData.get_param_offsets(parameters)
+    id_map, _, _, param_shapes = InverseData.get_param_offsets(parameters)
 
     param_dict = {}
     param_capsules = []
@@ -458,7 +457,7 @@ def build_parameter_dict(parameters: list, n_vars: int) -> tuple[dict, list, int
         c_param = _diffengine.make_parameter(d1, d2, offset, n_vars)
         param_dict[param.id] = c_param
         param_capsules.append(c_param)
-    return param_dict, param_capsules, n_params
+    return param_dict, param_capsules
 
 
 def convert_expr(expr, var_dict: dict, n_vars: int, param_dict: dict = None):
@@ -529,17 +528,16 @@ def convert_expressions(problem: cp.Problem) -> tuple:
         c_objective: C expression for objective
         c_constraints: list of C expressions for constraints
         param_capsules: list of parameter capsules (empty if no params)
-        n_params: total scalar parameter count
         all_params: list of unique CVXPY Parameter objects
     """
     var_dict, n_vars = build_variable_dict(problem.variables())
 
     # Collect unique parameters
     all_params = list({p.id: p for p in problem.parameters()}.values())
     if all_params:
-        param_dict, param_capsules, n_params = build_parameter_dict(all_params, n_vars)
+        param_dict, param_capsules = build_parameter_dict(all_params, n_vars)
     else:
-        param_dict, param_capsules, n_params = None, [], 0
+        param_dict, param_capsules = None, []
 
     # Convert objective
     c_objective = convert_expr(problem.objective.expr, var_dict, n_vars, param_dict)
@@ -550,4 +548,4 @@ def convert_expressions(problem: cp.Problem) -> tuple:
         c_expr = convert_expr(constr.expr, var_dict, n_vars, param_dict)
         c_constraints.append(c_expr)
 
-    return c_objective, c_constraints, param_capsules, n_params, all_params
+    return c_objective, c_constraints, param_capsules, all_params