pySimBlocks 0.1.0__py3-none-any.whl

tests/blocks/observers/test_luenberger.py

@@ -0,0 +1,225 @@
+# tests/blocks/observers/test_luenberger.py
+
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.sources.step import Step
+from pySimBlocks.blocks.observers.luenberger import Luenberger
+
+
+# ------------------------------------------------------------
+# Helpers
+# ------------------------------------------------------------
+def run_sim(obs: Luenberger, u_src, y_src, dt=0.1, T=0.3, logging=None):
+    m = Model()
+    m.add_block(u_src)
+    m.add_block(y_src)
+    m.add_block(obs)
+
+    m.connect(u_src.name, "out", obs.name, "u")
+    m.connect(y_src.name, "out", obs.name, "y")
+
+    if logging is None:
+        logging = [
+            f"{obs.name}.outputs.y_hat",
+            f"{obs.name}.outputs.x_hat",
+            f"{obs.name}.state.x_hat",
+        ]
+
+    sim_cfg = SimulationConfig(dt, T, logging=logging)
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs
+
+
+def manual_observer_rollout(A, B, C, L, x0, u_seq, y_seq):
+    """
+    Returns:
+        y_hat_seq: list of y_hat[k] = C x[k]
+        x_next_seq: list of x[k+1]
+    """
+    x = x0.copy()
+    y_hat_seq = []
+    x_next_seq = []
+
+    for (u, y) in zip(u_seq, y_seq):
+        y_hat = C @ x
+        x_next = A @ x + B @ u + L @ (y - y_hat)
+
+        y_hat_seq.append(y_hat.copy())
+        x_next_seq.append(x_next.copy())
+        x = x_next
+
+    return y_hat_seq, x_next_seq
+
+
+# ------------------------------------------------------------
+# 1) Basic correctness (state + output timing)
+# ------------------------------------------------------------
+def test_luenberger_basic_update_and_logging_timing():
+    # Dimensions: n=2, m=1, p=1
+    A = np.array([[0.9, 0.1],
+                  [0.0, 0.95]], dtype=float)
+    B = np.array([[0.1],
+                  [0.05]], dtype=float)
+    C = np.array([[1.0, 0.0]], dtype=float)
+    L = np.array([[0.5],
+                  [0.1]], dtype=float)
+
+    obs = Luenberger("obs", A=A, B=B, C=C, L=L, x0=None)
+
+    # Use constants so u[k] and y[k] are stable and easy to predict
+    u_src = Constant("u_src", [[1.0]])     # u = 1
+    y_src = Constant("y_src", [[0.0]])     # y = 0
+
+    dt = 0.1
+    T = 0.3  # 3 steps -> logs at k=0,1,2
+
+    logs = run_sim(
+        obs,
+        u_src=u_src,
+        y_src=y_src,
+        dt=dt,
+        T=T,
+        logging=[
+            "obs.outputs.y_hat",
+            "obs.state.x_hat",
+        ],
+    )
+
+    # Manual reference:
+    # log index k corresponds to:
+    #   - y_hat[k] computed from x[k]
+    #   - state.x_hat already committed to x[k+1]
+    x0 = np.zeros((2, 1), dtype=float)
+    u_seq = [np.array([[1.0]]) for _ in range(3)]
+    y_seq = [np.array([[0.0]]) for _ in range(3)]
+    y_hat_ref, x_next_ref = manual_observer_rollout(A, B, C, L, x0, u_seq, y_seq)
+
+    # outputs.y_hat
+    assert np.allclose(logs["obs.outputs.y_hat"][0], y_hat_ref[0])
+    assert np.allclose(logs["obs.outputs.y_hat"][1], y_hat_ref[1])
+    assert np.allclose(logs["obs.outputs.y_hat"][2], y_hat_ref[2])
+
+    # state.x_hat is x[k+1]
+    assert np.allclose(logs["obs.state.x_hat"][0], x_next_ref[0])
+    assert np.allclose(logs["obs.state.x_hat"][1], x_next_ref[1])
+    assert np.allclose(logs["obs.state.x_hat"][2], x_next_ref[2])
+
+
+# ------------------------------------------------------------
+# 2) Provided x0 should be respected
+# ------------------------------------------------------------
+def test_luenberger_respects_x0():
+    A = np.eye(2)
+    B = np.zeros((2, 1))
+    C = np.array([[1.0, 0.0]])
+    L = np.zeros((2, 1))
+
+    x0 = np.array([[2.0], [3.0]])
+    obs = Luenberger("obs", A=A, B=B, C=C, L=L, x0=x0)
+
+    u_src = Constant("u_src", [[0.0]])
+    y_src = Constant("y_src", [[0.0]])
+
+    logs = run_sim(
+        obs,
+        u_src=u_src,
+        y_src=y_src,
+        dt=0.1,
+        T=0.1,
+        logging=["obs.outputs.y_hat", "obs.state.x_hat"],
+    )
+
+    # At k=0: y_hat[0] = C x0 = 2
+    assert np.allclose(logs["obs.outputs.y_hat"][0], [[2.0]])
+    # state after first step is x1 = A x0 = x0 (since everything else is zero)
+    assert np.allclose(logs["obs.state.x_hat"][0], x0)
+
+
+# ------------------------------------------------------------
+# 3) Missing inputs should raise (at runtime state_update)
+# ------------------------------------------------------------
+def test_luenberger_missing_u_raises():
+    A = np.eye(1)
+    B = np.ones((1, 1))
+    C = np.ones((1, 1))
+    L = np.ones((1, 1))
+
+    obs = Luenberger("obs", A=A, B=B, C=C, L=L)
+    y_src = Constant("y_src", [[0.0]])
+
+    m = Model()
+    m.add_block(y_src)
+    m.add_block(obs)
+    # only connect y
+    m.connect("y_src", "out", "obs", "y")
+
+    sim = Simulator(m, SimulationConfig(0.1, 0.1, logging=["obs.outputs.y_hat"]))
+    sim.initialize()
+    with pytest.raises(RuntimeError, match="Input 'u'"):
+        sim.step()
+
+
+def test_luenberger_missing_y_raises():
+    A = np.eye(1)
+    B = np.ones((1, 1))
+    C = np.ones((1, 1))
+    L = np.ones((1, 1))
+
+    obs = Luenberger("obs", A=A, B=B, C=C, L=L)
+    u_src = Constant("u_src", [[0.0]])
+
+    m = Model()
+    m.add_block(u_src)
+    m.add_block(obs)
+    # only connect u
+    m.connect("u_src", "out", "obs", "u")
+
+    sim = Simulator(m, SimulationConfig(0.1, 0.1, logging=["obs.outputs.y_hat"]))
+    sim.initialize()
+    with pytest.raises(RuntimeError, match="Input 'y'"):
+        sim.step()
+
+
+# ------------------------------------------------------------
+# 4) Invalid matrix dimensions should raise at construction
+# ------------------------------------------------------------
+def test_luenberger_invalid_dimensions():
+    A = np.eye(2)
+    B = np.ones((3, 1))      # wrong rows
+    C = np.ones((1, 2))
+    L = np.ones((2, 1))
+
+    with pytest.raises(ValueError):
+        Luenberger("obs", A=A, B=B, C=C, L=L)
+
+
+# ------------------------------------------------------------
+# 5) Bad input shape (wrong number of elements) triggers reshape error
+# ------------------------------------------------------------
+def test_luenberger_bad_input_size_raises_value_error():
+    A = np.eye(2)
+    B = np.ones((2, 1))
+    C = np.ones((1, 2))
+    L = np.ones((2, 1))
+    obs = Luenberger("obs", A=A, B=B, C=C, L=L)
+
+    # u must be (1,1) -> OK, y must be (1,1) -> but we provide 2 elements
+    u_src = Constant("u_src", [[0.0]])
+    y_src = Constant("y_src", [[1.0], [2.0]])  # wrong total size for (1,1)
+
+    m = Model()
+    m.add_block(u_src)
+    m.add_block(y_src)
+    m.add_block(obs)
+    m.connect("u_src", "out", "obs", "u")
+    m.connect("y_src", "out", "obs", "y")
+
+    sim = Simulator(m, SimulationConfig(0.1, 0.1, logging=["obs.outputs.y_hat"]))
+    sim.initialize()
+    with pytest.raises(ValueError):
+        sim.step()
+

tests/blocks/operators/test_algebraic_function.py

@@ -0,0 +1,230 @@
+
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.operators.algebraic_function import AlgebraicFunction
+
+
+# ---------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------
+def make_block(func, input_keys=("u",), output_keys=("y",)):
+    return AlgebraicFunction(
+        name="F",
+        function=func,
+        input_keys=list(input_keys),
+        output_keys=list(output_keys),
+    )
+
+
+# ---------------------------------------------------------------------
+# 1) Basic pass-through (scalar as (1,1))
+# ---------------------------------------------------------------------
+def test_algebraic_function_pass_through_scalar():
+    def f(t, dt, u):
+        if u is None:
+            return {"y": np.zeros((1, 1))}
+        return {"y": u}
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y",))
+    blk.initialize(0.0)
+
+    blk.inputs["u"] = np.array([[2.0]])
+    blk.output_update(0.0, 0.1)
+
+    assert np.allclose(blk.outputs["y"], [[2.0]])
+
+
+# ---------------------------------------------------------------------
+# 2) Matrix support
+# ---------------------------------------------------------------------
+def test_algebraic_function_matrix_support():
+    def f(t, dt, A, B):
+        if A is None or B is None:
+            return {"Y": np.zeros((1, 1))}
+        return {"Y": A @ B}
+
+    blk = make_block(f, input_keys=("A", "B"), output_keys=("Y",))
+    blk.initialize(0.0)
+
+    A = np.array([[1.0, 2.0],
+                  [3.0, 4.0]])
+    B = np.array([[5.0],
+                  [6.0]])
+
+    blk.inputs["A"] = A
+    blk.inputs["B"] = B
+    blk.output_update(0.0, 0.1)
+
+    assert np.allclose(blk.outputs["Y"], A @ B)
+    assert blk.outputs["Y"].shape == (2, 1)
+
+
+# ---------------------------------------------------------------------
+# 3) Multiple outputs
+# ---------------------------------------------------------------------
+def test_algebraic_function_multiple_outputs():
+    def f(t, dt, u):
+        if u is None:
+            return {"y1": np.zeros((1, 1)), "y2": np.zeros((1, 1))}
+        return {"y1": u, "y2": 2.0 * u}
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y1", "y2"))
+    blk.initialize(0.0)
+
+    u = np.array([[3.0], [4.0]])
+    blk.inputs["u"] = u
+    blk.output_update(0.0, 0.1)
+
+    assert np.allclose(blk.outputs["y1"], u)
+    assert np.allclose(blk.outputs["y2"], 2.0 * u)
+
+
+# ---------------------------------------------------------------------
+# 4) Missing input -> RuntimeError
+# ---------------------------------------------------------------------
+def test_algebraic_function_missing_input_raises():
+    def f(t, dt, u):
+        if u is None:
+            return {"y": np.zeros((1, 1))}
+        return {"y": u}
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y",))
+    blk.initialize(0.0)
+
+    blk.inputs["u"] = None
+    with pytest.raises(RuntimeError) as err:
+        blk.output_update(0.0, 0.1)
+
+    assert "not set" in str(err.value).lower()
+
+
+# ---------------------------------------------------------------------
+# 5) Signature mismatch (input_keys != function args) -> ValueError in initialize
+# ---------------------------------------------------------------------
+def test_algebraic_function_signature_mismatch_raises():
+    # function declares 'u', but block expects 'x'
+    def f(t, dt, u):
+        if u is None:
+            return {"y": np.zeros((1, 1))}
+        return {"y": u}
+
+    blk = make_block(f, input_keys=("x",), output_keys=("y",))
+    with pytest.raises(ValueError) as err:
+        blk.initialize(0.0)
+
+    assert "arguments mismatch" in str(err.value).lower()
+
+
+# ---------------------------------------------------------------------
+# 6) Function must return a dict
+# ---------------------------------------------------------------------
+def test_algebraic_function_return_not_dict_raises():
+    def f(t, dt, u):
+        if u is None:
+            return {"y": np.zeros((1, 1))}
+        return u  # invalid
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y",))
+    blk.initialize(0.0)
+
+    blk.inputs["u"] = np.array([[1.0]])
+    with pytest.raises(RuntimeError) as err:
+        blk.output_update(0.0, 0.1)
+
+    assert "must return a dict" in str(err.value).lower()
+
+
+# ---------------------------------------------------------------------
+# 7) Output keys mismatch
+# ---------------------------------------------------------------------
+def test_algebraic_function_output_keys_mismatch_raises():
+    def f(t, dt, u):
+        if u is None:
+            return {"y": np.zeros((1, 1))}
+        return {"z": u}  # wrong key
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y",))
+    blk.initialize(0.0)
+
+    blk.inputs["u"] = np.array([[1.0]])
+    with pytest.raises(RuntimeError) as err:
+        blk.output_update(0.0, 0.1)
+
+    assert "missing output keys" in str(err.value).lower()
+
+
+# ---------------------------------------------------------------------
+# 8) Output must be 2D
+# ---------------------------------------------------------------------
+def test_algebraic_function_output_must_be_2d():
+    def f(t, dt, u):
+        return {"y": np.array([1.0, 2.0])}  # 1D invalid
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y",))
+    blk.initialize(0.0)
+
+    blk.inputs["u"] = np.array([[1.0]])
+    with pytest.raises(ValueError) as err:
+        blk.output_update(0.0, 0.1)
+
+    assert "must be a 2d" in str(err.value).lower()
+
+
+# ---------------------------------------------------------------------
+# 9) Input shape freeze: once seen, shape cannot change
+# ---------------------------------------------------------------------
+def test_algebraic_function_input_shape_change_raises():
+    def f(t, dt, u):
+        if u is None:
+            return {"y": np.zeros((1, 1))}
+        return {"y": u}
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y",))
+    blk.initialize(0.0)
+
+    blk.inputs["u"] = np.array([[1.0]])  # (1,1)
+    blk.output_update(0.0, 0.1)
+
+    blk.inputs["u"] = np.array([[1.0, 2.0],
+                                [3.0, 4.0]])  # (2,2) -> shape change
+    with pytest.raises(ValueError) as err:
+        blk.output_update(0.1, 0.1)
+
+    assert "shape changed" in str(err.value).lower()
+
+
+# ---------------------------------------------------------------------
+# 10) Output shape freeze: once produced, shape cannot change
+# ---------------------------------------------------------------------
+def test_algebraic_function_output_shape_change_raises():
+    # function changes output shape depending on time -> should raise at second call
+    def f(t, dt, u):
+        if t < 0.1:
+            return {"y": np.array([[1.0]])}  # (1,1)
+        return {"y": np.array([[1.0, 2.0]])}  # (1,2) -> shape change
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y",))
+    blk.initialize(0.0)
+
+    blk.inputs["u"] = np.array([[0.0]])  # dummy input (shape fixed too)
+    blk.output_update(0.0, 0.1)
+
+    with pytest.raises(ValueError) as err:
+        blk.output_update(0.1, 0.1)
+
+    assert "shape changed" in str(err.value).lower()
+
+
+def test_algebraic_function_func_error():
+    def f(t, dt, u):
+        return 2 * u  # invalid
+
+    blk = make_block(f, input_keys=("u",), output_keys=("y",))
+    with pytest.raises(RuntimeError) as err:
+        blk.initialize(0.0)
+
+    assert "function call error" in str(err.value).lower()
+
+if __name__ == "__main__":
+    test_algebraic_function_func_error()

tests/blocks/operators/test_dead_zone.py

@@ -0,0 +1,106 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.operators.dead_zone import DeadZone
+
+
+def run_sim(src, dz, dt=0.1, T=0.1):
+    m = Model()
+    m.add_block(src)
+    m.add_block(dz)
+    m.connect(src.name, "out", dz.name, "in")
+
+    sim_cfg = SimulationConfig(dt, T, logging=[f"{dz.name}.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs[f"{dz.name}.outputs.out"]
+
+
+def test_dead_zone_identity_default():
+    src = Constant("src", 2.0)
+    dz = DeadZone("dz")
+    logs = run_sim(src, dz)
+    assert np.allclose(logs[0], [[2.0]])
+
+
+def test_dead_zone_inside_zone():
+    src = Constant("src", 0.2)
+    dz = DeadZone("dz", lower_bound=-0.5, upper_bound=0.5)
+    logs = run_sim(src, dz)
+    assert np.allclose(logs[0], [[0.0]])
+
+
+def test_dead_zone_above():
+    src = Constant("src", 2.0)
+    dz = DeadZone("dz", lower_bound=-0.5, upper_bound=0.5)
+    logs = run_sim(src, dz)
+    assert np.allclose(logs[0], [[1.5]])
+
+
+def test_dead_zone_below():
+    src = Constant("src", -2.0)
+    dz = DeadZone("dz", lower_bound=-0.5, upper_bound=0.5)
+    logs = run_sim(src, dz)
+    assert np.allclose(logs[0], [[-1.5]])
+
+
+def test_dead_zone_vector():
+    src = Constant("src", [[0.2], [1.0], [-1.0]])
+    dz = DeadZone("dz", lower_bound=-0.3, upper_bound=0.3)
+    logs = run_sim(src, dz)
+    assert np.allclose(logs[0], [[0.0], [0.7], [-0.7]])
+
+
+def test_dead_zone_matrix_scalar_bounds():
+    src = Constant("src", [[0.2,  1.0],
+                           [-1.0, 0.0]])
+    dz = DeadZone("dz", lower_bound=-0.3, upper_bound=0.3)
+    logs = run_sim(src, dz)
+
+    # Apply component-wise:
+    # 0.2 -> 0
+    # 1.0 -> 1.0 - 0.3 = 0.7
+    # -1.0 -> -1.0 - (-0.3) = -0.7
+    # 0.0 -> 0
+    expected = np.array([[0.0, 0.7],
+                         [-0.7, 0.0]])
+    assert np.allclose(logs[0], expected)
+
+
+def test_dead_zone_matrix_vector_bounds_broadcast_columns():
+    src = Constant("src", [[1.0, -1.0, 0.0],
+                           [2.0, -2.0, 0.1]])  # (2,3)
+
+    # (2,1) bounds via 1D -> broadcast on 3 cols
+    dz = DeadZone("dz", lower_bound=[-0.5, -1.0], upper_bound=[0.5, 1.0])
+    logs = run_sim(src, dz)
+
+    # Row1 bounds [-0.5,0.5]:
+    # [1.0 -> 0.5], [-1.0 -> -0.5], [0.0 -> 0]
+    # Row2 bounds [-1,1]:
+    # [2 -> 1], [-2 -> -1], [0.1 -> 0]
+    expected = np.array([[0.5, -0.5, 0.0],
+                         [1.0, -1.0, 0.0]])
+    assert np.allclose(logs[0], expected)
+
+
+def test_dead_zone_invalid_bounds():
+    # Must include zero: lower <= 0 <= upper, and lower <= upper
+    with pytest.raises(ValueError):
+        dz = DeadZone("dz", lower_bound=1.0, upper_bound=0.0)
+        dz.inputs["in"] = np.array([[0.0]])
+        dz.initialize(0.0)
+
+
+def test_dead_zone_missing_input():
+    dz = DeadZone("dz")
+    m = Model()
+    m.add_block(dz)
+
+    sim_cfg = SimulationConfig(0.1, 1.0)
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError):
+        sim.initialize()