pySimBlocks 0.1.0__py3-none-any.whl

tests/blocks/operators/test_delay.py

@@ -0,0 +1,167 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.step import Step
+from pySimBlocks.blocks.operators.delay import Delay
+
+
+# ------------------------------------------------------------
+def run_sim(value_before, value_after, delay_block, dt=0.1, T_mult=3):
+    m = Model()
+
+    src = Step("src", start_time=0.1, value_before=value_before, value_after=value_after)
+    m.add_block(src)
+    m.add_block(delay_block)
+    m.connect("src", "out", delay_block.name, "in")
+
+    sim_cfg = SimulationConfig(dt, T_mult * dt, logging=[f"{delay_block.name}.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs[f"{delay_block.name}.outputs.out"]
+
+
+# ------------------------------------------------------------
+def test_delay_scalar_1_step():
+    d = Delay("D", num_delays=1)
+    logs = run_sim([[0.0]], [[5.0]], d)
+
+    assert np.allclose(logs[0], [[0.0]])
+    assert np.allclose(logs[1], [[0.0]])
+    assert np.allclose(logs[2], [[5.0]])
+
+
+# ------------------------------------------------------------
+def test_delay_scalar_2_steps():
+    d = Delay("D", num_delays=2)
+    logs = run_sim([[0.0]], [[1.0]], d)
+
+    assert np.allclose(logs[0], [[0.0]])
+    assert np.allclose(logs[1], [[0.0]])
+    assert np.allclose(logs[2], [[0.0]])
+
+
+# ------------------------------------------------------------
+def test_delay_with_initial_output_scalar():
+    # initial_output scalar is allowed and should be used at t=0
+    d = Delay("D", num_delays=2, initial_output=[[7.0]])
+    logs = run_sim([[0.0]], [[1.0]], d)
+
+    assert np.allclose(logs[0], [[7.0]])
+
+
+# ------------------------------------------------------------
+def test_delay_initial_output_scalar_broadcast_to_matrix():
+    # initial_output scalar can be broadcast to match matrix input shape
+    d = Delay("D", num_delays=1, initial_output=[[2.0]])
+
+    value_before = [[0.0, 0.0],
+                    [0.0, 0.0]]
+    value_after = [[5.0, 6.0],
+                   [7.0, 8.0]]
+
+    logs = run_sim(value_before, value_after, d)
+
+    # buffer at t=0 uses scalar init broadcasted to (2,2)
+    assert np.allclose(logs[0], np.full((2, 2), 2.0))
+
+
+# ------------------------------------------------------------
+def test_delay_with_initial_output_matrix():
+    init = [[1.0, 2.0],
+            [3.0, 4.0]]
+    d = Delay("D", num_delays=2, initial_output=init)
+
+    value_before = init
+    value_after = [[10.0, 20.0],
+                   [30.0, 40.0]]
+
+    logs = run_sim(value_before, value_after, d)
+
+    assert np.allclose(logs[0], np.array(init))
+
+
+# ------------------------------------------------------------
+def test_delay_dimension_mismatch_initial_output_non_scalar_vs_input():
+    # initial_output non-scalar fixes buffer shape; if input shape differs -> error
+    d = Delay("D", num_delays=1, initial_output=[[1.0], [2.0]])  # shape (2, 1)
+
+    m = Model()
+    src = Step("src", start_time=0.1, value_before=[[0.0], [0.0], [0.]],
+               value_after=[[1.0], [1.0], [1.]])  # shape (3, 1)
+    m.add_block(src)
+    m.add_block(d)
+    m.connect("src", "out", "D", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.2, logging=["D.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError) as err:
+        sim.run()
+
+    assert "shape" in str(err.value) and "expected" in str(err.value)
+
+
+# ------------------------------------------------------------
+def test_delay_uninitialized_buffer_error():
+    m = Model()
+    d = Delay("D", num_delays=1)
+    m.add_block(d)
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError):
+        sim.run(T=0.1)
+
+
+# ------------------------------------------------------------
+def test_delay_vector_1_step():
+    value_before = [[0.0], [0.0]]
+    value_after = [[5.0], [10.0]]
+
+    d = Delay("D", num_delays=1)
+    logs = run_sim(value_before, value_after, d)
+
+    expected0 = np.array([[0.0], [0.0]])
+    expected1 = np.array([[0.0], [0.0]])
+    expected2 = np.array([[5.0], [10.0]])
+
+    assert np.allclose(logs[0], expected0)
+    assert np.allclose(logs[1], expected1)
+    assert np.allclose(logs[2], expected2)
+
+
+# ------------------------------------------------------------
+def test_delay_matrix_1_step():
+    value_before = [[0.0, 0.0],
+                    [0.0, 0.0]]
+    value_after = [[1.0, 2.0],
+                   [3.0, 4.0]]
+
+    d = Delay("D", num_delays=1)
+    logs = run_sim(value_before, value_after, d)
+
+    expected0 = np.array(value_before)
+    expected1 = np.array(value_before)
+    expected2 = np.array(value_after)
+
+    assert np.allclose(logs[0], expected0)
+    assert np.allclose(logs[1], expected1)
+    assert np.allclose(logs[2], expected2)
+
+
+# ------------------------------------------------------------
+def test_delay_input_shape_change_over_time_raises():
+    # First phase: scalar, second phase: matrix (shape change) -> should raise
+    d = Delay("D", num_delays=1)
+
+    d.initialize(0.0)
+    d.inputs["in"] = np.array([[1.0]])  # scalar input
+    d.state_update(0.0, 0.1)
+    d.inputs["in"] = np.array([[1.0, 2.0],  # shape change to (2,2)
+                             [3.0, 4.0]])
+    with pytest.raises(ValueError) as err:
+        d.state_update(0.1, 0.1)
+
+    assert "shape" in str(err.value) and "expected" in str(err.value)

tests/blocks/operators/test_demux.py

@@ -0,0 +1,111 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.operators.demux import Demux
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.core import Model, SimulationConfig, Simulator
+
+
+def run_sim(value, num_outputs):
+    m = Model()
+
+    c = Constant("c", value)
+    dmx = Demux("D", num_outputs=num_outputs)
+
+    m.add_block(c)
+    m.add_block(dmx)
+    m.connect("c", "out", "D", "in")
+
+    logs = [f"D.outputs.out{i+1}" for i in range(num_outputs)]
+    sim_cfg = SimulationConfig(0.1, 0.1, logging=logs)
+    sim = Simulator(m, sim_cfg)
+    data = sim.run()
+    return [data[key][-1] for key in logs]
+
+
+def test_demux_basic_column_vector():
+    outputs = run_sim([[1.0], [2.0], [3.0]], num_outputs=3)
+    assert np.allclose(outputs[0], [[1.0]])
+    assert np.allclose(outputs[1], [[2.0]])
+    assert np.allclose(outputs[2], [[3.0]])
+
+
+def test_demux_equal_split_when_divisible():
+    outputs = run_sim([[1.0], [2.0], [3.0], [4.0]], num_outputs=2)
+    assert np.allclose(outputs[0], [[1.0], [2.0]])
+    assert np.allclose(outputs[1], [[3.0], [4.0]])
+
+
+def test_demux_remainder_split_rule():
+    # n=5, p=3 => q=1, m=2
+    # out1/out2 have 2 elems, out3 has 1 elem
+    outputs = run_sim([[1.0], [2.0], [3.0], [4.0], [5.0]], num_outputs=3)
+    assert np.allclose(outputs[0], [[1.0], [2.0]])
+    assert np.allclose(outputs[1], [[3.0], [4.0]])
+    assert np.allclose(outputs[2], [[5.0]])
+
+
+def test_demux_invalid_parameter():
+    with pytest.raises(ValueError) as err:
+        Demux("D", num_outputs=0)
+    assert "num_outputs must be a positive integer" in str(err.value)
+
+
+def test_demux_missing_input_raises():
+    m = Model()
+    dmx = Demux("D", num_outputs=2)
+    m.add_block(dmx)
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError) as err:
+        sim.run(T=0.1)
+
+    assert "not connected or not set" in str(err.value)
+
+
+def test_demux_rejects_matrix_input():
+    m = Model()
+    c = Constant("c", [[1.0, 2.0], [3.0, 4.0]])
+    dmx = Demux("D", num_outputs=4)
+
+    m.add_block(c)
+    m.add_block(dmx)
+    m.connect("c", "out", "D", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError) as err:
+        sim.run(T=0.1)
+
+    assert "must be a column vector (n,1)" in str(err.value)
+
+
+def test_demux_rejects_1d_input():
+    dmx = Demux("D", num_outputs=1)
+    dmx.inputs["in"] = np.array([5.0])
+
+    with pytest.raises(ValueError) as err:
+        dmx.output_update(t=0.0, dt=0.1)
+
+    assert "must be a column vector (n,1)" in str(err.value)
+
+
+def test_demux_rejects_more_outputs_than_input_length():
+    m = Model()
+    c = Constant("c", [[1.0], [2.0]])
+    dmx = Demux("D", num_outputs=3)
+
+    m.add_block(c)
+    m.add_block(dmx)
+    m.connect("c", "out", "D", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError) as err:
+        sim.run(T=0.1)
+
+    assert "must be <= input vector length" in str(err.value)

tests/blocks/operators/test_discrete_derivator.py

@@ -0,0 +1,160 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.step import Step
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.operators.discrete_derivator import DiscreteDerivator
+
+
+# ------------------------------------------------------------
+def run_sim(src_block, der_block, dt=0.1, T=0.3):
+    m = Model()
+    m.add_block(src_block)
+    m.add_block(der_block)
+    m.connect(src_block.name, "out", der_block.name, "in")
+
+    sim_cfg = SimulationConfig(dt, T, logging=[f"{der_block.name}.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs[f"{der_block.name}.outputs.out"]
+
+
+# ------------------------------------------------------------
+def test_derivator_scalar_basic_step():
+    """
+    Step: value_before=0 until t=0.1, then 1.
+    dt=0.1
+
+    Expected derivative (backward difference):
+      first output_update: 0 (placeholder)
+      then at t=0.1: (1-0)/0.1 = 10
+      then: 0
+    """
+    src = Step("src", start_time=0.1, value_before=[[0.0]], value_after=[[1.0]])
+    D = DiscreteDerivator("D")
+
+    logs = run_sim(src, D, dt=0.1, T=0.3)
+
+    assert np.allclose(logs[0], [[0.0]])
+    assert np.allclose(logs[1], [[10.0]])
+    assert np.allclose(logs[2], [[0.0]])
+
+
+# ------------------------------------------------------------
+def test_derivator_vector_step():
+    src = Step(
+        "src",
+        start_time=0.1,
+        value_before=[[0.0], [0.0]],
+        value_after=[[2.0], [4.0]],
+    )
+    D = DiscreteDerivator("D")
+
+    logs = run_sim(src, D, dt=0.1, T=0.3)
+
+    assert np.allclose(logs[0], [[0.0], [0.0]])
+    assert np.allclose(logs[1], [[20.0], [40.0]])
+    assert np.allclose(logs[2], [[0.0], [0.0]])
+
+
+# ------------------------------------------------------------
+def test_derivator_matrix_constant_is_zero():
+    src = Constant("src", [[1.0, 2.0], [3.0, 4.0]])
+    D = DiscreteDerivator("D")
+
+    logs = run_sim(src, D, dt=0.1, T=0.3)
+
+    # first call: 0 placeholder upgraded to matrix on first non-scalar input
+    assert logs[0].shape == (2, 2)
+    assert np.allclose(logs[0], np.zeros((2, 2)))
+
+    # constant input -> derivative zero
+    assert np.allclose(logs[1], np.zeros((2, 2)))
+    assert np.allclose(logs[2], np.zeros((2, 2)))
+
+
+# ------------------------------------------------------------
+def test_derivator_initial_output_freezes_shape():
+    """
+    initial_output fixes the shape (including scalar).
+    If input later has a different shape -> error.
+    """
+    D = DiscreteDerivator("D", initial_output=[[5.0]])  # freezes to (1,1)
+    src = Constant("src", [[1.0, 2.0], [3.0, 4.0]])     # (2,2) -> mismatch
+
+    m = Model()
+    m.add_block(src)
+    m.add_block(D)
+    m.connect("src", "out", "D", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.2, logging=["D.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError) as err:
+        sim.run()
+
+    assert "shape" in str(err.value).lower()
+
+
+# ------------------------------------------------------------
+def test_derivator_missing_input_never_none_output():
+    """
+    If the block is alone / never receives input, it must not propagate None.
+    It will just keep (1,1) zeros (placeholder).
+    """
+    D = DiscreteDerivator("D")
+    m = Model()
+    m.add_block(D)
+
+    sim_cfg = SimulationConfig(0.1, 0.2, logging=["D.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+
+    logs = sim.run()
+    assert np.allclose(logs["D.outputs.out"][0], [[0.0]])
+
+
+# ------------------------------------------------------------
+def test_derivator_shape_upgrade_from_placeholder_unit():
+    """
+    Unit test without simulator:
+      - Start with no input -> placeholder output (1,1)
+      - Then feed matrix -> shape freezes and u_prev set to avoid spike
+    """
+    D = DiscreteDerivator("D")
+    D.initialize(0.0)
+
+    # First output_update with missing input -> should keep placeholder, not crash
+    D.inputs["in"] = None
+    D.output_update(0.0, 0.1)
+    assert np.allclose(D.outputs["out"], [[0.0]])
+
+    # Now provide a matrix; first call after upgrade keeps 0 (but shape becomes (2,2))
+    D.inputs["in"] = np.array([[1.0, 2.0], [3.0, 4.0]])
+    D.output_update(0.1, 0.1)
+    assert D.outputs["out"].shape == (2, 2)
+    assert np.allclose(D.outputs["out"], np.zeros((2, 2)))
+
+    # Second call with same matrix -> derivative zero
+    D.state_update(0.1, 0.1)
+    D.state["u_prev"] = D.next_state["u_prev"].copy()
+
+    D.output_update(0.2, 0.1)
+    assert np.allclose(D.outputs["out"], np.zeros((2, 2)))
+
+
+# ------------------------------------------------------------
+def test_derivator_shape_change_after_freeze_raises_unit():
+    D = DiscreteDerivator("D")
+    D.initialize(0.0)
+
+    # First: provide matrix -> freezes
+    D.inputs["in"] = np.array([[1.0, 2.0], [3.0, 4.0]])
+    D.output_update(0.0, 0.1)
+
+    # Now attempt incompatible shape
+    D.inputs["in"] = np.array([[1.0], [2.0], [3.0]])
+    with pytest.raises(ValueError) as err:
+        D.output_update(0.1, 0.1)
+
+    assert "shape" in str(err.value).lower()

tests/blocks/operators/test_discrete_integrator.py

@@ -0,0 +1,149 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.step import Step
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.operators.discrete_integrator import DiscreteIntegrator
+
+
+def run_sim(src_block, integrator_block, dt=0.1, T=0.3):
+    m = Model()
+    m.add_block(src_block)
+    m.add_block(integrator_block)
+    m.connect(src_block.name, "out", integrator_block.name, "in")
+
+    sim_cfg = SimulationConfig(dt, T, logging=[f"{integrator_block.name}.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs[f"{integrator_block.name}.outputs.out"]
+
+
+# ----------------------------------------------------------------------
+# 1) FORWARD EULER — SCALAR
+# ----------------------------------------------------------------------
+def test_integrator_scalar_forward():
+    src = Step("src", start_time=0.1, value_before=0.0, value_after=1.0)
+    I = DiscreteIntegrator("I", method="euler forward")
+
+    logs = run_sim(src, I, dt=0.1, T=0.3)
+
+    # forward: y[k] = x[k], x[k+1] = x[k] + dt*u[k]
+    # u: 0,1,1 -> y: 0,0,0.1
+    assert np.allclose(logs[0], [[0.0]])
+    assert np.allclose(logs[1], [[0.0]])
+    assert np.allclose(logs[2], [[0.1]])
+
+
+# ----------------------------------------------------------------------
+# 2) FORWARD EULER — VECTOR
+# ----------------------------------------------------------------------
+def test_integrator_vector_forward():
+    src = Step(
+        "src",
+        start_time=0.1,
+        value_before=[[0.0], [0.0]],
+        value_after=[[1.0], [2.0]],
+    )
+    I = DiscreteIntegrator("I", method="euler forward")
+
+    logs = run_sim(src, I, dt=0.1, T=0.3)
+
+    assert np.allclose(logs[0], [[0.0], [0.0]])
+    assert np.allclose(logs[1], [[0.0], [0.0]])
+    assert np.allclose(logs[2], [[0.1], [0.2]])
+
+
+# ----------------------------------------------------------------------
+# 3) BACKWARD EULER — SCALAR
+# ----------------------------------------------------------------------
+def test_integrator_scalar_backward():
+    src = Step("src", start_time=0.1, value_before=0.0, value_after=1.0)
+    I = DiscreteIntegrator("I", method="euler backward")
+
+    logs = run_sim(src, I, dt=0.1, T=0.3)
+
+    # backward output: y = x + dt*u (with x updated in state_update)
+    # u: 0,1,1
+    # y0 = 0 + 0.1*0 = 0
+    # y1 = 0 + 0.1*1 = 0.1
+    # y2 = 0.1 + 0.1*1 = 0.2
+    assert np.allclose(logs[0], [[0.0]])
+    assert np.allclose(logs[1], [[0.1]])
+    assert np.allclose(logs[2], [[0.2]])
+
+
+# ----------------------------------------------------------------------
+# 4) INITIAL STATE — FREEZES SHAPE (NON-SCALAR)
+# ----------------------------------------------------------------------
+def test_integrator_initial_state_matrix_freezes_shape():
+    src = Constant("src", [[1.0, 2.0], [3.0, 4.0]])
+    I = DiscreteIntegrator("I", initial_state=np.zeros((2, 2)), method="euler forward")
+
+    logs = run_sim(src, I, dt=0.1, T=0.2)
+
+    # forward: y = x, with x0 fixed
+    assert np.allclose(logs[0], np.zeros((2, 2)))
+    assert np.allclose(logs[1], 0.1 * np.array([[1.0, 2.0], [3.0, 4.0]]))
+
+
+# ----------------------------------------------------------------------
+# 5) PLACEHOLDER (1,1) MUST NOT FREEZE; UPGRADE ON FIRST NON-SCALAR
+# ----------------------------------------------------------------------
+def test_integrator_placeholder_upgrades_to_matrix_on_first_non_scalar_input():
+    # Step goes from scalar -> matrix; scalar should NOT freeze the integrator if no initial_state
+    src = Step(
+        "src",
+        start_time=0.1,
+        value_before=[[0.0]],  # scalar placeholder
+        value_after=[[1.0, 2.0], [3.0, 4.0]],  # matrix
+    )
+    I = DiscreteIntegrator("I", method="euler forward")
+
+    logs = run_sim(src, I, dt=0.1, T=0.3)
+
+    # At t=0: output placeholder (1,1) is fine
+    assert np.allclose(logs[0], [[0.0]])
+
+    # After step: integrator should upgrade and integrate matrix
+    # forward y1 is still x0 (after upgrade, still zero matrix)
+    # y2 is dt*u1
+    assert logs[1].shape == (2, 2)
+    assert np.allclose(logs[1], np.zeros((2, 2)))
+    assert np.allclose(logs[2], 0.1 * np.array([[1.0, 2.0], [3.0, 4.0]]))
+
+
+# ----------------------------------------------------------------------
+# 6) SHAPE CHANGE AFTER FREEZE MUST RAISE
+# ----------------------------------------------------------------------
+def test_integrator_shape_change_after_freeze_raises():
+    # Freeze to (2,2) via initial_state, then feed (3,1)
+    src = Constant("src", [[1.0], [2.0], [3.0]])
+    I = DiscreteIntegrator("I", initial_state=np.zeros((2, 2)), method="euler backward")
+
+    m = Model()
+    m.add_block(src)
+    m.add_block(I)
+    m.connect("src", "out", "I", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.2, logging=["I.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(ValueError) as err:
+        sim.run()
+
+    assert "shape" in str(err.value).lower()
+
+
+# ----------------------------------------------------------------------
+# 7) SCALAR INPUT (1,1) MUST BROADCAST WHEN SHAPE IS FROZEN TO MATRIX
+# ----------------------------------------------------------------------
+def test_integrator_scalar_broadcast_into_frozen_matrix_shape():
+    src = Constant("src", [[2.0]])  # scalar (1,1)
+    I = DiscreteIntegrator("I", initial_state=np.zeros((2, 2)), method="euler backward")
+
+    logs = run_sim(src, I, dt=0.1, T=0.2)
+
+    # backward: y = x + dt*u, with u broadcast to 2x2
+    assert logs[0].shape == (2, 2)
+    assert np.allclose(logs[0], 0.1 * 2.0 * np.ones((2, 2)))