Store param values in CSR data order, simplify refresh to memcpy

- left_matmul: replace col-major loop in refresh_param_values with
  memcpy of nnz doubles (values now arrive in CSR data order)
- right_matmul: pass AT->x directly to new_parameter(nnz, 1, ...),
  remove col-major round-trip allocation
- test_param_prob: update theta arrays to CSR data order

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

Author: Transurgeon

src/bivariate/left_matmul.c

@@ -57,17 +57,11 @@ static void refresh_param_values(left_matmul_expr *lin_node)
 {
     if (!lin_node->param_source) return;
 
-    const double *src = lin_node->param_source->value;
-    int m = lin_node->A->m;
-    CSR_Matrix *A = lin_node->A;
-
-    /* Fill A values from column-major source, following existing sparsity pattern */
-    for (int row = 0; row < m; row++)
-        for (int k = A->p[row]; k < A->p[row + 1]; k++)
-            A->x[k] = src[row + A->i[k] * m];
+    memcpy(lin_node->A->x, lin_node->param_source->value,
+           lin_node->A->nnz * sizeof(double));
 
     /* Recompute AT values from updated A */
-    AT_fill_values(A, lin_node->AT, lin_node->base.iwork);
+    AT_fill_values(lin_node->A, lin_node->AT, lin_node->base.iwork);
 }
 
 static void forward(expr *node, const double *u)

src/bivariate/right_matmul.c

@@ -33,20 +33,12 @@ expr *new_right_matmul(expr *u, const CSR_Matrix *A)
     int *work_transpose = (int *) malloc(A->n * sizeof(int));
     CSR_Matrix *AT = transpose(A, work_transpose);
 
-    /* Convert AT (CSR) to dense column-major array for parameter node */
-    int m = AT->m; /* rows of AT = cols of A */
-    int n = AT->n; /* cols of AT = rows of A */
-    double *col_major = (double *) calloc(m * n, sizeof(double));
-    for (int row = 0; row < m; row++)
-        for (int k = AT->p[row]; k < AT->p[row + 1]; k++)
-            col_major[row + AT->i[k] * m] = AT->x[k];
-
+    /* Parameter stores CSR data order (same as AT->x) */
     expr *u_transpose = new_transpose(u);
-    expr *param_node = new_parameter(m, n, PARAM_FIXED, u->n_vars, col_major);
+    expr *param_node = new_parameter(AT->nnz, 1, PARAM_FIXED, u->n_vars, AT->x);
     expr *left_matmul_node = new_left_matmul(param_node, u_transpose, AT);
     expr *node = new_transpose(left_matmul_node);
 
-    free(col_major);
     free_csr_matrix(AT);
     free(work_transpose);
     return node;

tests/problem/test_param_prob.h

@@ -164,14 +164,14 @@ const char *test_param_vector_mult_problem(void)
  * Test 3: left_param_matmul in constraint
  *
  * Problem: minimize sum(x), subject to A @ x, x size 2, A is 2x2
- *   A is a 2x2 matrix parameter (param_id=0, size=4, column-major)
- *   A = [[1,2],[3,4]] → column-major theta = [1,3,2,4]
+ *   A is a 2x2 matrix parameter (param_id=0, size=4, CSR data order)
+ *   A = [[1,2],[3,4]] → CSR data order theta = [1,2,3,4]
  *
  * At x=[1,2]:
  *   constraint_values = [1*1+2*2, 3*1+4*2] = [5, 11]
  *   jacobian = [[1,2],[3,4]]
  *
- * After update A = [[5,6],[7,8]] → theta = [5,7,6,8]:
+ * After update A = [[5,6],[7,8]] → theta = [5,6,7,8]:
  *   constraint_values = [5*1+6*2, 7*1+8*2] = [17, 23]
  *   jacobian = [[5,6],[7,8]]
  */
@@ -208,8 +208,8 @@ const char *test_param_left_matmul_problem(void)
     problem_register_params(prob, param_nodes, 1);
     problem_init_derivatives(prob);
 
-    /* Set A = [[1,2],[3,4]], column-major: [1,3,2,4] */
-    double theta[4] = {1.0, 3.0, 2.0, 4.0};
+    /* Set A = [[1,2],[3,4]], CSR data order: [1,2,3,4] */
+    double theta[4] = {1.0, 2.0, 3.0, 4.0};
     problem_update_params(prob, theta);
 
     double u[2] = {1.0, 2.0};
@@ -235,8 +235,8 @@ const char *test_param_left_matmul_problem(void)
     double expected_x[4] = {1.0, 2.0, 3.0, 4.0};
     mu_assert("jac->x wrong (A1)", cmp_double_array(jac->x, expected_x, 4));
 
-    /* Update A = [[5,6],[7,8]], column-major: [5,7,6,8] */
-    double theta2[4] = {5.0, 7.0, 6.0, 8.0};
+    /* Update A = [[5,6],[7,8]], CSR data order: [5,6,7,8] */
+    double theta2[4] = {5.0, 6.0, 7.0, 8.0};
     problem_update_params(prob, theta2);
 
     problem_constraint_forward(prob, u);