clean up scope a bit

Author: dance858

sparsediffpy/__init__.py

@@ -18,7 +18,7 @@
 from sparsediffpy import _sparsediffengine  # noqa: F401
 
 # Core classes
-from sparsediffpy._core._scope import Scope, Variable, Parameter  # noqa: F401
+from sparsediffpy._core._scope import Scope, Variable, Parameter, DimensionError  # noqa: F401
 from sparsediffpy._core._expression import Expression  # noqa: F401
 
 # Compile

sparsediffpy/_core/_compile.py

@@ -163,9 +163,12 @@ def _convert_node(node, n_vars, cache, param_caps, param_objs):
         )
 
     if isinstance(node, Parameter):
+        # Use current values if set, otherwise zeros as placeholder.
+        # Real values are synced via problem_update_params before evaluation.
+        size = node.shape[0] * node.shape[1]
+        values = node._value_flat if node._value_flat is not None else np.zeros(size)
         cap = _C.make_parameter(
-            node.shape[0], node.shape[1], node._param_id, n_vars,
-            node._value_flat,
+            node.shape[0], node.shape[1], node._param_id, n_vars, values,
         )
         param_caps.append(cap)
         param_objs.append(node)
@@ -308,6 +311,12 @@ def _sync_params(self):
         """Push current parameter values to the C problem."""
         if not self._param_objects:
             return
+        for p in self._param_objects:
+            if p._value_flat is None:
+                raise ValueError(
+                    f"Parameter with shape {p.shape} has no value set. "
+                    f"Assign a value via parameter.value = ... before evaluating."
+                )
         theta_parts = [p._value_flat for p in self._param_objects]
         theta = np.concatenate(theta_parts)
         _C.problem_update_params(self._problem, theta)

sparsediffpy/_core/_registry.py

@@ -62,8 +62,14 @@ def make_dense_right_matmul(param_node, child_cap, A_flat, m, n):
 
 
 def _to_dense_row_major(matrix):
-    """Convert a Constant or Parameter to row-major flat data for dense matmul."""
+    """Convert a Constant or Parameter to row-major flat data for dense matmul.
+
+    For Parameters with no value set yet, returns zeros as a placeholder —
+    the real values are pushed via problem_update_params before evaluation.
+    """
     m, n = matrix.shape
+    if matrix._value_flat is None:
+        return np.zeros(m * n, dtype=np.float64)
     return matrix._value_flat.reshape((m, n), order="F").flatten(order="C")
 
 

sparsediffpy/_core/_scope.py

@@ -6,6 +6,11 @@
 from sparsediffpy._core._shapes import validate_shape
 
 
+class DimensionError(ValueError):
+    """Raised when a value has the wrong number of elements."""
+    pass
+
+
 class Variable(Expression):
     """A decision variable in the expression tree.
 
@@ -20,61 +25,41 @@ def __init__(self, scope, var_id, shape):
 
     @property
     def value(self):
-        size = self.shape[0] * self.shape[1]
-        return self._scope._flat_values[self._var_id:self._var_id + size].copy()
+        return self._scope._flat_values[self._var_id:self._var_id + self.size].copy()
 
     @value.setter
     def value(self, val):
         val = np.asarray(val, dtype=np.float64).ravel()
-        size = self.shape[0] * self.shape[1]
-        if val.size != size:
-            raise ValueError(
-                f"Expected {size} elements for Variable with shape {self.shape}, "
-                f"got {val.size}"
-            )
-        self._scope._flat_values[self._var_id:self._var_id + size] = val
+        if val.size != self.size:
+            raise DimensionError(f"expected {self.size} elements, got {val.size}")
+        self._scope._flat_values[self._var_id:self._var_id + self.size] = val
 
 
 class Parameter(Expression):
     """An updatable parameter in the expression tree.
 
-    Created by Scope.Parameter(). Values are stored on the parameter itself
-    (not in the scope's flat buffer). Updated via .value property.
+    Created by Scope.Parameter(). Values must be set via .value before
+    evaluating any expression that uses this parameter.
     """
 
-    def __init__(self, scope, param_id, shape, value=None):
+    def __init__(self, scope, param_id, shape):
         self._scope = scope
         self._param_id = param_id
         self.shape = shape
-        size = shape[0] * shape[1]
-        if value is not None:
-            self._value_flat = np.asarray(value, dtype=np.float64).ravel(order="F")
-            if self._value_flat.size != size:
-                raise ValueError(
-                    f"Parameter value has {self._value_flat.size} elements, "
-                    f"expected {size} for shape {shape}"
-                )
-        else:
-            self._value_flat = np.zeros(size, dtype=np.float64)
+        self._value_flat = None
 
     @property
     def value(self):
+        if self._value_flat is None:
+            return None
         return self._value_flat.copy()
 
     @value.setter
     def value(self, val):
         val = np.asarray(val, dtype=np.float64).ravel(order="F")
-        size = self.shape[0] * self.shape[1]
-        if val.size != size:
-            raise ValueError(
-                f"Expected {size} elements for Parameter with shape {self.shape}, "
-                f"got {val.size}"
-            )
-        self._value_flat[:] = val
-
-
-# Patch _is_param_like to recognize Parameter
-# (already handled via lazy import in _expressions.py)
+        if val.size != self.size:
+            raise DimensionError(f"expected {self.size} elements, got {val.size}")
+        self._value_flat = val.copy()
 
 
 class Scope:
@@ -103,26 +88,27 @@ def Variable(self, d1, d2):
         self._variables.append(var)
         return var
 
-    def Parameter(self, d1, d2, value=None):
-        """Create a new updatable parameter in this scope."""
+    def Parameter(self, d1, d2):
+        """Create a new updatable parameter in this scope.
+
+        Set its value via .value = ... before evaluating.
+        """
         validate_shape(d1, d2)
         size = d1 * d2
         param_id = self._next_param_offset
         self._next_param_offset += size
 
-        param = Parameter(self, param_id, (d1, d2), value)
+        param = Parameter(self, param_id, (d1, d2))
         self._parameters.append(param)
         return param
 
-    def set_values(self, flat_array):
+    def set_values(self, array):
         """Set all variable values at once from a flat array."""
-        flat_array = np.asarray(flat_array, dtype=np.float64)
-        if flat_array.size != self._flat_values.size:
-            raise ValueError(
-                f"Expected flat array of size {self._flat_values.size}, "
-                f"got {flat_array.size}"
-            )
-        self._flat_values[:] = flat_array
+        array = np.asarray(array, dtype=np.float64)
+        in_size = self._flat_values.size
+        if array.size != in_size:
+            raise DimensionError(f"expected {in_size} elements, got {array.size}")
+        self._flat_values[:] = array
 
     def get_values(self):
         """Return a copy of the flat value buffer."""

tests/affine/test_left_matmul.py

@@ -42,7 +42,8 @@ def test_left_matmul_sparse_forward(scope, rng):
 
 def test_left_matmul_parameter_jacobian(scope, rng):
     x = scope.Variable(3, 1)
-    A = scope.Parameter(4, 3, value=rng.standard_normal((4, 3)))
+    A = scope.Parameter(4, 3)
+    A.value = rng.standard_normal((4, 3))
     f = A @ x
     fn = sp.compile(f)
     checker = NumericalDerivativeChecker(fn, scope)
@@ -51,7 +52,8 @@ def test_left_matmul_parameter_jacobian(scope, rng):
 
 def test_left_matmul_parameter_update(scope, rng):
     x = scope.Variable(3, 1)
-    A = scope.Parameter(3, 3, value=np.eye(3))
+    A = scope.Parameter(3, 3)
+    A.value = np.eye(3)
     f = A @ x
     fn = sp.compile(f)
     x0 = random_point(scope, rng)

tests/affine/test_scalar_mult.py

@@ -21,7 +21,8 @@ def test_scalar_mult_constant_forward(scope, rng):
 
 def test_scalar_mult_parameter_jacobian(scope, rng):
     x = scope.Variable(4, 1)
-    a = scope.Parameter(1, 1, value=np.array([[3.0]]))
+    a = scope.Parameter(1, 1)
+    a.value = np.array([[3.0]])
     f = a * x
     fn = sp.compile(f)
     checker = NumericalDerivativeChecker(fn, scope)
@@ -30,7 +31,8 @@ def test_scalar_mult_parameter_jacobian(scope, rng):
 
 def test_scalar_mult_parameter_update(scope, rng):
     x = scope.Variable(3, 1)
-    a = scope.Parameter(1, 1, value=np.array([[2.0]]))
+    a = scope.Parameter(1, 1)
+    a.value = np.array([[2.0]])
     f = a * x
     fn = sp.compile(f)
     x0 = random_point(scope, rng)

tests/affine/test_vector_mult.py

@@ -23,7 +23,8 @@ def test_vector_mult_constant_forward(scope, rng):
 
 def test_vector_mult_parameter_jacobian(scope, rng):
     x = scope.Variable(3, 1)
-    a = scope.Parameter(3, 1, value=np.array([1.0, 2.0, 3.0]))
+    a = scope.Parameter(3, 1)
+    a.value = np.array([1.0, 2.0, 3.0])
     f = a * x
     fn = sp.compile(f)
     checker = NumericalDerivativeChecker(fn, scope)
@@ -32,7 +33,8 @@ def test_vector_mult_parameter_jacobian(scope, rng):
 
 def test_vector_mult_parameter_update(scope, rng):
     x = scope.Variable(3, 1)
-    a = scope.Parameter(3, 1, value=np.array([1.0, 1.0, 1.0]))
+    a = scope.Parameter(3, 1)
+    a.value = np.array([1.0, 1.0, 1.0])
     f = a * x
     fn = sp.compile(f)
     x0 = random_point(scope, rng)

tests/test_misc.py

@@ -149,7 +149,8 @@ def test_negative_fancy(self, scope, rng):
 class TestParameterJacobianAfterUpdate:
     def test_left_matmul_jacobian_after_update(self, scope, rng):
         x = scope.Variable(3, 1)
-        A = scope.Parameter(3, 3, value=np.eye(3))
+        A = scope.Parameter(3, 3)
+        A.value = np.eye(3)
         f = A @ x
         fn = sp.compile(f)
 
@@ -163,7 +164,8 @@ def test_left_matmul_jacobian_after_update(self, scope, rng):
 
     def test_scalar_mult_jacobian_after_update(self, scope, rng):
         x = scope.Variable(3, 1)
-        a = scope.Parameter(1, 1, value=np.array([[3.0]]))
+        a = scope.Parameter(1, 1)
+        a.value = np.array([[3.0]])
         f = a * x
         fn = sp.compile(f)
 

tests/test_validation.py

@@ -176,27 +176,37 @@ def test_prod_axis_must_be_variable(self, scope):
 class TestValueAssignment:
     def test_variable_wrong_size(self, scope):
         x = scope.Variable(3, 1)
-        with pytest.raises(ValueError, match="Expected 3"):
+        with pytest.raises(ValueError, match="expected 3 elements"):
             x.value = np.array([1.0, 2.0])
 
     def test_variable_too_many(self, scope):
         x = scope.Variable(3, 1)
-        with pytest.raises(ValueError, match="Expected 3"):
+        with pytest.raises(ValueError, match="expected 3 elements"):
             x.value = np.array([1.0, 2.0, 3.0, 4.0])
 
     def test_parameter_wrong_size(self, scope):
-        p = scope.Parameter(2, 2, value=np.eye(2))
-        with pytest.raises(ValueError, match="Expected 4"):
+        p = scope.Parameter(2, 2)
+        p.value = np.eye(2)
+        with pytest.raises(ValueError, match="expected 4 elements"):
             p.value = np.array([1.0, 2.0])
 
     def test_scope_set_values_wrong_size(self, scope):
         x = scope.Variable(3, 1)
-        with pytest.raises(ValueError, match="Expected flat array of size 3"):
+        with pytest.raises(ValueError, match="expected 3 elements"):
             scope.set_values(np.array([1.0, 2.0]))
 
-    def test_parameter_init_wrong_size(self, scope):
-        with pytest.raises(ValueError, match="elements"):
-            scope.Parameter(2, 2, value=np.array([1.0, 2.0]))
+    def test_parameter_unset_value_is_none(self, scope):
+        p = scope.Parameter(2, 2)
+        assert p.value is None
+
+    def test_parameter_unset_raises_on_eval(self, scope):
+        x = scope.Variable(3, 1)
+        A = scope.Parameter(3, 3)
+        f = A @ x
+        fn = sp.compile(f)
+        x.value = np.array([1.0, 2.0, 3.0])
+        with pytest.raises(ValueError, match="has no value set"):
+            fn.forward()
 
 
 # ---------------------------------------------------------------------------