Unify right_matmul binding to accept param_or_none like left_matmul

Update py_make_right_matmul signature to (param_or_none, child, data,
indices, indptr, m, n) matching left_matmul. When param_or_none is None,
a PARAM_FIXED node is created internally; otherwise the passed parameter
capsule is used for updatable sparse parameters.

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

Author: Transurgeon

sparsediffpy/_bindings/atoms/right_matmul.h

@@ -3,15 +3,27 @@
 
 #include "bivariate.h"
 #include "common.h"
+#include "subexpr.h"
 
-/* Right matrix multiplication: f(x) @ A where A is a constant matrix */
+/* Right matrix multiplication: f(x) @ A where A is a constant or parameter matrix.
+ *
+ * Unified binding for both fixed-constant and updatable-parameter cases.
+ * Python signature:
+ *   make_right_matmul(param_or_none, child, data, indices, indptr, m, n)
+ *
+ * - param_or_none: None for fixed constants (a PARAM_FIXED parameter is created
+ *   internally), or an existing parameter capsule for updatable parameters.
+ * - child: the child expression capsule f(x).
+ * - data, indices, indptr, m, n: CSR arrays defining the sparsity pattern and
+ *   initial values of the matrix A. */
 static PyObject *py_make_right_matmul(PyObject *self, PyObject *args)
 {
+    PyObject *param_obj;
     PyObject *child_capsule;
     PyObject *data_obj, *indices_obj, *indptr_obj;
     int m, n;
-    if (!PyArg_ParseTuple(args, "OOOOii", &child_capsule, &data_obj, &indices_obj,
-                          &indptr_obj, &m, &n))
+    if (!PyArg_ParseTuple(args, "OOOOOii", &param_obj, &child_capsule, &data_obj,
+                          &indices_obj, &indptr_obj, &m, &n))
     {
         return NULL;
     }
@@ -38,18 +50,55 @@ static PyObject *py_make_right_matmul(PyObject *self, PyObject *args)
         return NULL;
     }
 
-    int nnz = (int) PyArray_SIZE(data_array);
+    double *csr_data = (double *) PyArray_DATA(data_array);
+    int *csr_indices = (int *) PyArray_DATA(indices_array);
+    int *csr_indptr = (int *) PyArray_DATA(indptr_array);
+    int nnz = csr_indptr[m];
+
+    /* Build CSR matrix from Python arrays */
     CSR_Matrix *A = new_csr_matrix(m, n, nnz);
-    memcpy(A->x, PyArray_DATA(data_array), nnz * sizeof(double));
-    memcpy(A->i, PyArray_DATA(indices_array), nnz * sizeof(int));
-    memcpy(A->p, PyArray_DATA(indptr_array), (m + 1) * sizeof(int));
+    memcpy(A->p, csr_indptr, (m + 1) * sizeof(int));
+    memcpy(A->i, csr_indices, nnz * sizeof(int));
+    memcpy(A->x, csr_data, nnz * sizeof(double));
+
+    /* Determine param_node: use passed capsule, or create PARAM_FIXED internally */
+    expr *param_node;
+    if (param_obj == Py_None)
+    {
+        /* Fixed constant: pass CSR data directly (values are already in CSR order) */
+        param_node = new_parameter(nnz, 1, PARAM_FIXED, child->n_vars, csr_data);
+
+        if (!param_node)
+        {
+            free_csr_matrix(A);
+            Py_DECREF(data_array);
+            Py_DECREF(indices_array);
+            Py_DECREF(indptr_array);
+            PyErr_SetString(PyExc_RuntimeError,
+                            "failed to create matrix parameter node");
+            return NULL;
+        }
+    }
+    else
+    {
+        param_node = (expr *) PyCapsule_GetPointer(param_obj, EXPR_CAPSULE_NAME);
+        if (!param_node)
+        {
+            free_csr_matrix(A);
+            Py_DECREF(data_array);
+            Py_DECREF(indices_array);
+            Py_DECREF(indptr_array);
+            PyErr_SetString(PyExc_ValueError, "invalid param capsule");
+            return NULL;
+        }
+    }
 
     Py_DECREF(data_array);
     Py_DECREF(indices_array);
     Py_DECREF(indptr_array);
 
-    expr *node = new_right_matmul(child, A);
-    free_csr_matrix(A);
+    expr *node = new_right_matmul(param_node, child, A);
+    free_csr_matrix(A); /* constructor copies it */
 
     if (!node)
     {

sparsediffpy/_bindings/bindings.c

@@ -122,7 +122,7 @@ static PyMethodDef DNLPMethods[] = {
     {"make_param_vector_mult", py_make_param_vector_mult, METH_VARARGS,
      "Create vector mult from parameter (p ∘ f(x))"},
     {"make_right_matmul", py_make_right_matmul, METH_VARARGS,
-     "Create right matmul node (f(x) @ A)"},
+     "Create right matmul node (f(x) @ A): pass None or param capsule as first arg"},
     {"make_quad_form", py_make_quad_form, METH_VARARGS,
      "Create quadratic form node (x' * Q * x)"},
     {"make_quad_over_lin", py_make_quad_over_lin, METH_VARARGS,