pySimBlocks 0.1.0__py3-none-any.whl

tests/blocks/sources/test_white_noise.py

@@ -0,0 +1,108 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.sources.white_noise import WhiteNoise
+
+
+# ----------------------------------------------------------
+# 1) Scalar noise, deterministic with seed
+# ----------------------------------------------------------
+def test_white_noise_scalar_reproducible():
+    s1 = WhiteNoise("n", mean=0.0, std=1.0, seed=42)
+    s2 = WhiteNoise("n", mean=0.0, std=1.0, seed=42)
+
+    s1.initialize(0.0)
+    s2.initialize(0.0)
+
+    assert np.allclose(s1.outputs["out"], s2.outputs["out"])
+
+
+def test_white_noise_scalar_update_changes():
+    s = WhiteNoise("n", mean=2.0, std=0.5, seed=0)
+    s.initialize(0.0)
+    first = s.outputs["out"].copy()
+    s.output_update(0.1, 0.1)
+    second = s.outputs["out"]
+
+    assert not np.allclose(first, second)
+
+
+# ----------------------------------------------------------
+# 2) Vector parameters + broadcasting (still valid)
+# ----------------------------------------------------------
+def test_white_noise_vector_params_shape():
+    s = WhiteNoise("n", mean=[1.0, 2.0], std=[0.1, 0.2], seed=10)
+    s.initialize(0.0)
+    assert s.outputs["out"].shape == (2, 1)
+
+
+def test_white_noise_broadcast_scalar_mean():
+    s = WhiteNoise("n", mean=0.0, std=[1.0, 2.0, 3.0], seed=1)
+    s.initialize(0.0)
+    assert s.mean.shape == (3, 1)
+    assert s.std.shape == (3, 1)
+    assert s.outputs["out"].shape == (3, 1)
+
+
+# ----------------------------------------------------------
+# 3) Matrix parameters (Option B)
+# ----------------------------------------------------------
+def test_white_noise_matrix_params_shape():
+    mean = np.array([[0.0, 1.0],
+                     [2.0, 3.0]])
+    std = np.array([[1.0, 2.0],
+                    [3.0, 4.0]])
+    s = WhiteNoise("n", mean=mean, std=std, seed=123)
+    s.initialize(0.0)
+    assert s.outputs["out"].shape == (2, 2)
+
+
+def test_white_noise_matrix_broadcast_scalar_std():
+    mean = np.array([[0.0, 1.0],
+                     [2.0, 3.0]])
+    s = WhiteNoise("n", mean=mean, std=1.0, seed=123)  # scalar broadcast
+    s.initialize(0.0)
+    assert s.mean.shape == (2, 2)
+    assert s.std.shape == (2, 2)
+    assert s.outputs["out"].shape == (2, 2)
+
+
+def test_white_noise_matrix_reproducible_same_seed():
+    mean = np.array([[0.0, 1.0],
+                     [2.0, 3.0]])
+    std = np.array([[1.0, 1.0],
+                    [1.0, 1.0]])
+
+    s1 = WhiteNoise("n", mean=mean, std=std, seed=999)
+    s2 = WhiteNoise("n", mean=mean, std=std, seed=999)
+
+    s1.initialize(0.0)
+    s2.initialize(0.0)
+    assert np.allclose(s1.outputs["out"], s2.outputs["out"])
+
+
+# ----------------------------------------------------------
+# 4) Error cases
+# ----------------------------------------------------------
+def test_white_noise_inconsistent_shapes():
+    with pytest.raises(ValueError):
+        WhiteNoise(
+            "n",
+            mean=np.zeros((2, 2)),
+            std=np.zeros((2, 3)),  # mismatch among non-scalars
+        )
+
+
+def test_white_noise_negative_std_scalar():
+    with pytest.raises(ValueError):
+        WhiteNoise("n", mean=0.0, std=-1.0)
+
+
+def test_white_noise_negative_std_matrix_elementwise():
+    with pytest.raises(ValueError):
+        WhiteNoise("n", mean=np.zeros((2, 2)), std=np.array([[1.0, -1.0], [1.0, 1.0]]))
+
+
+def test_white_noise_illegal_ndim():
+    with pytest.raises(ValueError):
+        WhiteNoise("n", mean=np.zeros((2, 2, 2)), std=1.0)

tests/blocks/systems/test_linear_state_space.py

@@ -0,0 +1,135 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.systems.linear_state_space import LinearStateSpace
+
+
+# ------------------------------------------------------------
+def run_sim(src, sys, dt=0.1, T=0.3):
+    m = Model()
+    m.add_block(src)
+    m.add_block(sys)
+    m.connect(src.name, "out", sys.name, "u")
+
+    sim_cfg = SimulationConfig(dt, T, logging=[f"{sys.name}.outputs.y", f"{sys.name}.outputs.x"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs
+
+
+# ------------------------------------------------------------
+def test_lss_scalar_1state_basic():
+    # x[k+1] = 0.9 x[k] + 1*u[k], y = x
+    A = [[0.9]]
+    B = [[1.0]]
+    C = [[1.0]]
+
+    src = Constant("u", [[1.0]])
+    sys = LinearStateSpace("sys", A=A, B=B, C=C, x0=[[0.0]])
+
+    logs = run_sim(src, sys, dt=0.1, T=0.3)
+
+    y = logs["sys.outputs.y"]
+    x = logs["sys.outputs.x"]
+
+    # At t=0: x0=0 -> y0=0
+    assert np.allclose(y[0], [[0.0]])
+    assert np.allclose(x[0], [[0.0]])
+
+    # Then x1 = 0 + 0.1*?  (No: discrete system is already discrete; dt not used in state update)
+    # Here: x[k+1]=0.9 x[k] + 1*u[k]
+    # Step-by-step with u=1:
+    # x1 = 0.9*0 + 1 = 1
+    # x2 = 0.9*1 + 1 = 1.9
+    # y[k] = x[k]
+    assert np.allclose(y[1], [[1.0]])
+    assert np.allclose(y[2], [[1.9]])
+
+
+# ------------------------------------------------------------
+def test_lss_vector_dims():
+    # n=2, m=1, p=1
+    A = [[1.0, 0.1],
+         [0.0, 1.0]]
+    B = [[0.0],
+         [1.0]]
+    C = [[1.0, 0.0]]
+
+    src = Constant("u", [[2.0]])
+    sys = LinearStateSpace("sys", A=A, B=B, C=C, x0=[[0.0], [0.0]])
+
+    logs = run_sim(src, sys, dt=0.1, T=0.3)
+
+    y = logs["sys.outputs.y"]
+    x = logs["sys.outputs.x"]
+
+    # k=0: x0=[0,0], y0=0
+    assert np.allclose(y[0], [[0.0]])
+
+    # k=1: x1 = A x0 + B u = [0, 2]
+    assert np.allclose(x[1], [[0.0], [2.0]])
+    assert np.allclose(y[1], [[0.0]])
+
+    # k=2: x2 = A x1 + B u = [0 + 0.1*2, 2] + [0,2] = [0.2, 4]
+    assert np.allclose(x[2], [[0.2], [4.0]])
+    assert np.allclose(y[2], [[0.2]])
+
+
+# ------------------------------------------------------------
+def test_lss_missing_input_raises():
+    A = [[1.0]]
+    B = [[1.0]]
+    C = [[1.0]]
+    sys = LinearStateSpace("sys", A=A, B=B, C=C)
+
+    m = Model()
+    m.add_block(sys)
+
+    sim_cfg = SimulationConfig(0.1, 0.1, logging=["sys.outputs.y"])
+    sim = Simulator(m, sim_cfg)
+    sim.initialize()
+
+    with pytest.raises(RuntimeError):
+        sim.run()
+
+
+# ------------------------------------------------------------
+def test_lss_rejects_non_vector_u():
+    A = [[1.0]]
+    B = [[1.0]]
+    C = [[1.0]]
+    sys = LinearStateSpace("sys", A=A, B=B, C=C)
+
+    # Provide u as 1x2 matrix via Constant -> invalid for u (must be (m,1)=(1,1))
+    src = Constant("u", [[1.0, 2.0]])
+
+    m = Model()
+    m.add_block(src)
+    m.add_block(sys)
+    m.connect("u", "out", "sys", "u")
+
+    sim_cfg = SimulationConfig(0.1, 0.1, logging=["sys.outputs.y"])
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(ValueError) as err:
+        sim.run()
+
+    assert "must be a column vector" in str(err.value) or "must have shape" in str(err.value)
+
+
+# ------------------------------------------------------------
+def test_lss_invalid_matrix_dimensions():
+    # A is 2x2, B has wrong rows
+    A = np.eye(2)
+    B = np.ones((3, 1))  # wrong
+    C = np.ones((1, 2))
+
+    with pytest.raises(ValueError):
+        LinearStateSpace("sys", A=A, B=B, C=C)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
+

tests/blocks/systems/test_polytopic_state_space.py

@@ -0,0 +1,133 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.systems.polytopic_state_space import PolytopicStateSpace
+
+
+def run_sim(src_w, src_u, sys, dt=0.1, T=0.3):
+    m = Model()
+    m.add_block(src_w)
+    m.add_block(src_u)
+    m.add_block(sys)
+    m.connect(src_w.name, "out", sys.name, "w")
+    m.connect(src_u.name, "out", sys.name, "u")
+
+    sim_cfg = SimulationConfig(dt, T, logging=[f"{sys.name}.outputs.y", f"{sys.name}.outputs.x"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs
+
+
+def test_poly_scalar_basic():
+    # r=2, nx=1, nu=1, ny=1
+    A = [[0.8, 0.5]]   # [A1 A2]
+    B = [[1.0, 2.0]]   # [B1 B2]
+    C = [[1.0]]
+
+    src_w = Constant("w", [[0.25], [0.75]])
+    src_u = Constant("u", [[2.0]])
+    sys = PolytopicStateSpace("sys", A=A, B=B, C=C, x0=[[0.0]])
+
+    logs = run_sim(src_w, src_u, sys)
+    y = logs["sys.outputs.y"]
+    x = logs["sys.outputs.x"]
+
+    # x[k+1] = 0.575*x[k] + 3.5
+    assert np.allclose(y[0], [[0.0]])
+    assert np.allclose(x[1], [[3.5]])
+    assert np.allclose(y[1], [[3.5]])
+    assert np.allclose(x[2], [[5.5125]])
+    assert np.allclose(y[2], [[5.5125]])
+
+
+def test_poly_vector_dimensions():
+    # r=2, nx=2, nu=1, ny=1
+    A1 = np.array([[1.0, 0.1], [0.0, 1.0]])
+    A2 = np.array([[0.9, 0.0], [0.0, 0.95]])
+    A = np.hstack([A1, A2])
+
+    B1 = np.array([[0.0], [1.0]])
+    B2 = np.array([[1.0], [0.0]])
+    B = np.hstack([B1, B2])
+    C = np.array([[1.0, 0.0]])
+
+    src_w = Constant("w", [[0.2], [0.8]])
+    src_u = Constant("u", [[2.0]])
+    sys = PolytopicStateSpace("sys", A=A, B=B, C=C, x0=[[0.0], [0.0]])
+
+    logs = run_sim(src_w, src_u, sys)
+    x = logs["sys.outputs.x"]
+    y = logs["sys.outputs.y"]
+
+    assert np.allclose(x[1], [[1.6], [0.4]])
+    assert np.allclose(y[1], [[1.6]])
+    assert np.allclose(x[2], [[3.08], [0.784]])
+    assert np.allclose(y[2], [[3.08]])
+
+
+def test_poly_missing_w_input_raises():
+    A = [[1.0, 0.0]]
+    B = [[1.0, 1.0]]
+    C = [[1.0]]
+
+    src_u = Constant("u", [[1.0]])
+    sys = PolytopicStateSpace("sys", A=A, B=B, C=C)
+
+    m = Model()
+    m.add_block(src_u)
+    m.add_block(sys)
+    m.connect("u", "out", "sys", "u")
+
+    sim_cfg = SimulationConfig(0.1, 0.1, logging=["sys.outputs.y"])
+    sim = Simulator(m, sim_cfg)
+    sim.initialize()
+
+    with pytest.raises(RuntimeError):
+        sim.run()
+
+
+def test_poly_rejects_non_column_w():
+    A = [[1.0, 0.0]]
+    B = [[1.0, 1.0]]
+    C = [[1.0]]
+
+    src_w = Constant("w", [[0.2, 0.8], [0.1, 0.9]])  # 2x2, not column vector
+    src_u = Constant("u", [[1.0]])
+    sys = PolytopicStateSpace("sys", A=A, B=B, C=C)
+
+    m = Model()
+    m.add_block(src_w)
+    m.add_block(src_u)
+    m.add_block(sys)
+    m.connect("w", "out", "sys", "w")
+    m.connect("u", "out", "sys", "u")
+
+    sim_cfg = SimulationConfig(0.1, 0.1, logging=["sys.outputs.y"])
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(ValueError) as err:
+        sim.run()
+
+    assert "must be a column vector" in str(err.value)
+
+
+def test_poly_invalid_matrix_dimensions():
+    C = [[1.0]]
+
+    # A has nx=1 but 3 columns -> not (nx, r*nx)
+    with pytest.raises(ValueError):
+        PolytopicStateSpace("sys1", A=[[1.0, 2.0, 3.0]], B=[[1.0, 1.0]], C=C)
+
+    # A => nx=1, r=2, so B must have 2*nu columns
+    with pytest.raises(ValueError):
+        PolytopicStateSpace("sys2", A=[[1.0, 2.0]], B=[[1.0, 2.0, 3.0]], C=C)
+
+    # C has wrong number of columns
+    with pytest.raises(ValueError):
+        PolytopicStateSpace("sys3", A=[[1.0, 2.0]], B=[[1.0, 1.0]], C=[[1.0, 2.0]])
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/core/test_core_errors_and_determinism.py

@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core.block import Block
+from pySimBlocks.core.model import Model
+from pySimBlocks.core.config import SimulationConfig
+from pySimBlocks.core.simulator import Simulator
+
+
+class RequiresInput(Block):
+    """
+    Block that explicitly requires an input port 'u'.
+    Used to validate that missing inputs raise RuntimeError at evaluation time.
+    """
+
+    def initialize(self, t0: float):
+        self.outputs["y"] = np.array([[0.0]])
+
+    def output_update(self, t: float, dt: float):
+        if "u" not in self.inputs:
+            raise RuntimeError(f"[{self.name}] missing input 'u'")
+        self.outputs["y"] = np.array(self.inputs["u"])
+
+    def state_update(self, t: float, dt: float):
+        self.next_state = self.state
+
+
+class PureSource(Block):
+    def __init__(self, name: str, value: float, sample_time: float | None = None):
+        super().__init__(name=name, sample_time=sample_time)
+        self.value = float(value)
+
+    def initialize(self, t0: float):
+        self.outputs["y"] = np.array([[self.value]])
+
+    def output_update(self, t: float, dt: float):
+        self.outputs["y"] = np.array([[self.value]])
+
+    def state_update(self, t: float, dt: float):
+        self.next_state = self.state
+
+
+def _run(model: Model, cfg: SimulationConfig):
+    sim = Simulator(model=model, sim_cfg=cfg, verbose=False)
+    sim.run()
+    return sim.logs
+
+
+def test_missing_input_raises_runtime_error(capsys):
+    m = Model(name="missing_input_test")
+    m.add_block(RequiresInput("a"))
+
+    cfg = SimulationConfig(dt=0.01, T=0.01, t0=0.0, solver="fixed", logging=["a.outputs.y"])
+
+    with pytest.raises(RuntimeError):
+        _run(m, cfg)
+
+
+def test_determinism_same_model_same_logs(capsys):
+    """
+    Runs the same model twice and asserts identical logs.
+    This freezes the determinism expectation of the core.
+    """
+    cfg = SimulationConfig(dt=0.01, T=0.03, t0=0.0, solver="fixed", logging=["p.outputs.y"])
+
+    m1 = Model(name="determinism_test_1")
+    m1.add_block(PureSource("s", value=2.0))
+    m1.add_block(RequiresInput("p"))
+    m1.connect("s", "y", "p", "u")
+
+    logs1 = _run(m1, cfg)
+
+    m2 = Model(name="determinism_test_2")
+    m2.add_block(PureSource("s", value=2.0))
+    m2.add_block(RequiresInput("p"))
+    m2.connect("s", "y", "p", "u")
+
+    logs2 = _run(m2, cfg)
+
+    assert len(logs1["p.outputs.y"]) == len(logs2["p.outputs.y"])
+    for v1, v2 in zip(logs1["p.outputs.y"], logs2["p.outputs.y"]):
+        assert np.allclose(v1, v2)

tests/core/test_core_multirate_tasks.py

@@ -0,0 +1,88 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core.block import Block
+from pySimBlocks.core.model import Model
+from pySimBlocks.core.config import SimulationConfig
+from pySimBlocks.core.simulator import Simulator
+from pySimBlocks.core.task import Task
+
+
+class RateCounter(Block):
+    """
+    Stateful counter incremented on each activation (i.e., when the task runs).
+
+    State:
+        count[k+1] = count[k] + 1
+
+    Output:
+        y[k] = count[k]
+    """
+
+    def initialize(self, t0: float):
+        self.state["count"] = np.array([[0.0]])
+        self.outputs["y"] = np.array([[0.0]])
+
+    def output_update(self, t: float, dt: float):
+        self.outputs["y"] = np.array(self.state["count"])
+        # print(self.outputs["y"])
+
+    def state_update(self, t: float, dt: float):
+        self.next_state["count"] = self.state["count"] + 1.0
+
+
+def test_task_get_dt_semantics(capsys):
+    """
+    Contract test for Task.get_dt():
+      - first activation returns Ts
+      - subsequent calls return (t - last_activation)
+
+    This test is isolated from Simulator (unit test of Task).
+    """
+    task = Task(sample_time=0.1, blocks=[], global_output_order=[])
+
+    assert task.get_dt(0.0) == pytest.approx(0.1)
+
+    # Emulate one advance cycle (as Simulator would do)
+    task.advance()  # last_activation becomes 0.0
+    assert task.last_activation == pytest.approx(0.0)
+
+    assert task.get_dt(0.3) == pytest.approx(0.3 - 0.0)
+
+
+def test_multirate_activation_and_hold(capsys):
+    """
+    Validates that task activation controls execution:
+      - fast block executes every dt (Ts = dt)
+      - slow block executes every 2*dt (Ts = 2*dt)
+
+    We log the slow state at every global tick; it must change only on its activations.
+    """
+    dt = 0.01
+    T = 0.04  # logs at t = 0, 0.01, 0.02, 0.03, 0.04
+
+    m = Model(name="multirate_test")
+    m.add_block(RateCounter("fast", sample_time=dt))
+    m.add_block(RateCounter("slow", sample_time=2 * dt))
+
+    cfg = SimulationConfig(
+        dt=dt,
+        T=T,
+        t0=0.0,
+        solver="fixed",
+        logging=["slow.outputs.y", "fast.outputs.y"],
+    )
+    sim = Simulator(model=m, sim_cfg=cfg, verbose=False)
+    logs = sim.run()
+
+    slow_count = np.array(logs["slow.outputs.y"]).flatten()
+    fast_count = np.array(logs["fast.outputs.y"]).flatten()
+
+    # # # fast executes every tick -> after each step, count increases by 1
+    assert np.allclose(fast_count, np.arange(0, int(round(T/dt))+1))
+
+    # # slow executes at t = 0, 0.02, 0.04 -> state after commit should be:
+    # # t=0: 1, t=0.01: 1, t=0.02: 2, t=0.03: 2, t=0.04: 3
+    expected = np.array([0, 0, 1, 1, 2], dtype=float)
+    assert len(slow_count) == len(expected)
+    assert np.allclose(slow_count, expected)

tests/core/test_core_two_phase_and_propagation.py

@@ -0,0 +1,132 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core.block import Block
+from pySimBlocks.core.model import Model
+from pySimBlocks.core.config import SimulationConfig
+from pySimBlocks.core.simulator import Simulator
+
+
+class SourceSetsOne(Block):
+    """
+    Test source that sets output to 0 at initialize and to 1 at each output_update.
+    This is used to validate *immediate propagation* within Phase 1.
+    """
+
+    def initialize(self, t0: float):
+        self.outputs["y"] = np.array([[0.0]])
+
+    def output_update(self, t: float, dt: float):
+        self.outputs["y"] = np.array([[1.0]])
+
+    def state_update(self, t: float, dt: float):
+        # Stateless
+        self.next_state = self.state
+
+
+class PassThrough(Block):
+    """
+    Test operator that forwards input u to output y.
+    Raises if u is missing, to make propagation expectations explicit.
+    """
+
+    def initialize(self, t0: float):
+        self.outputs["y"] = np.array([[0.0]])
+
+    def output_update(self, t: float, dt: float):
+        if "u" not in self.inputs:
+            raise RuntimeError(f"[{self.name}] missing input 'u'")
+        self.outputs["y"] = np.array(self.inputs["u"])
+
+    def state_update(self, t: float, dt: float):
+        self.next_state = self.state
+
+
+class StatefulCounter(Block):
+    """
+    Test stateful block:
+      - output y[k] = x[k]
+      - next state x[k+1] = x[k] + 1
+
+    Used to validate two-phase update semantics (outputs computed before state commit).
+    """
+
+    def initialize(self, t0: float):
+        self.state["x"] = np.array([[0.0]])
+        self.outputs["y"] = np.array([[0.0]])
+
+    def output_update(self, t: float, dt: float):
+        self.outputs["y"] = np.array(self.state["x"])
+
+    def state_update(self, t: float, dt: float):
+        self.next_state["x"] = self.state["x"] + 1.0
+
+
+def _run(model: Model, dt: float, T: float, logging: list[str]):
+    cfg = SimulationConfig(dt=dt, T=T, t0=0.0, solver="fixed", logging=logging)
+    sim = Simulator(model=model, sim_cfg=cfg, verbose=False)
+    sim.run()  # uses cfg.logging by default
+    return sim.logs
+
+
+def test_phase1_immediate_propagation(capsys):
+    """
+    Validates that outputs are propagated immediately after each output_update,
+    not only at the end of Phase 1.
+
+    Setup:
+      src: outputs y=0 at initialize, y=1 at output_update
+      dst: pass-through (y = u)
+      connection: src.y -> dst.u
+
+    Expectation:
+      At the first tick (t=0), dst must see u=1 (the updated output), not u=0.
+    """
+    m = Model(name="propagation_test")
+    m.add_block(SourceSetsOne("src"))
+    m.add_block(PassThrough("dst"))
+    m.connect("src", "y", "dst", "u")
+
+    logs = _run(
+        model=m,
+        dt=0.01,
+        T=0.01,
+        logging=["dst.outputs.y", "src.outputs.y"],
+    )
+
+    # First logged sample corresponds to t_step = 0.0
+    dst_y0 = float(logs["dst.outputs.y"][0][0, 0])
+    src_y0 = float(logs["src.outputs.y"][0][0, 0])
+
+    assert src_y0 == 1.0
+    assert dst_y0 == 1.0
+
+
+def test_two_phase_outputs_vs_state_commit(capsys):
+    """
+    Validates the strict two-phase semantics:
+      - outputs at time t are computed from x[k]
+      - state is committed to x[k+1] at end of step
+
+    We log, per tick:
+      - c.outputs.y  (expected: x[k])
+      - c.state.x    (expected: x[k+1])
+
+    Therefore, at each logged time:
+      state_x == output_y + 1
+    """
+    m = Model(name="two_phase_test")
+    m.add_block(StatefulCounter("c"))
+
+    logs = _run(
+        model=m,
+        dt=0.01,
+        T=0.04,  # gives samples at t = 0, 0.01, 0.02, 0.03, 0.04
+        logging=["c.outputs.y", "c.state.x"],
+    )
+
+    y = np.array(logs["c.outputs.y"]).flatten()
+    x = np.array(logs["c.state.x"]).flatten()
+
+    assert len(y) == len(x) >= 3
+    assert np.allclose(x, y + 1.0)