pySimBlocks 0.1.0__py3-none-any.whl

tests/blocks/operators/test_saturation.py

@@ -0,0 +1,157 @@
+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.operators.saturation import Saturation
+
+
+# ------------------------------------------------------------
+# Helper
+# ------------------------------------------------------------
+def run_sim(src_block, sat_block, dt=0.1, T=0.2):
+    m = Model()
+    m.add_block(src_block)
+    m.add_block(sat_block)
+    m.connect(src_block.name, "out", sat_block.name, "in")
+
+    sim_cfg = SimulationConfig(dt, T, logging=[f"{sat_block.name}.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs[f"{sat_block.name}.outputs.out"]
+
+
+# ------------------------------------------------------------
+# 1) Scalar saturation
+# ------------------------------------------------------------
+def test_saturation_scalar():
+    src = Constant("src", 5.0)  # -> (1,1)
+    sat = Saturation("sat", u_min=0.0, u_max=3.0)
+
+    logs = run_sim(src, sat)
+    assert np.allclose(logs[0], [[3.0]])
+
+
+# ------------------------------------------------------------
+# 2) No saturation when bounds are wide
+# ------------------------------------------------------------
+def test_saturation_no_effect():
+    src = Constant("src", 2.0)
+    sat = Saturation("sat", u_min=-10.0, u_max=10.0)
+
+    logs = run_sim(src, sat)
+    assert np.allclose(logs[0], [[2.0]])
+
+
+# ------------------------------------------------------------
+# 3) Lower bound only
+# ------------------------------------------------------------
+def test_saturation_lower_only():
+    src = Constant("src", -5.0)
+    sat = Saturation("sat", u_min=-2.0)
+
+    logs = run_sim(src, sat)
+    assert np.allclose(logs[0], [[-2.0]])
+
+
+# ------------------------------------------------------------
+# 4) Upper bound only
+# ------------------------------------------------------------
+def test_saturation_upper_only():
+    src = Constant("src", 5.0)
+    sat = Saturation("sat", u_max=1.5)
+
+    logs = run_sim(src, sat)
+    assert np.allclose(logs[0], [[1.5]])
+
+
+# ------------------------------------------------------------
+# 5) Vector bounds on vector input (m,1)
+# ------------------------------------------------------------
+def test_saturation_vector():
+    src = Constant("src", [[5.0], [-5.0]])  # (2,1)
+    sat = Saturation("sat", u_min=[-1.0, -2.0], u_max=[3.0, -1.0])  # -> (2,1)
+
+    logs = run_sim(src, sat)
+    assert np.allclose(logs[0], [[3.0], [-2.0]])
+
+
+# ------------------------------------------------------------
+# 6) Matrix input with scalar bounds
+# ------------------------------------------------------------
+def test_saturation_matrix_scalar_bounds():
+    src = Constant("src", [[5.0, -5.0],
+                           [2.0,  10.0]])  # (2,2)
+    sat = Saturation("sat", u_min=0.0, u_max=3.0)  # scalar -> broadcast to (2,2)
+
+    logs = run_sim(src, sat)
+    expected = np.array([[3.0, 0.0],
+                         [2.0, 3.0]])
+    assert np.allclose(logs[0], expected)
+
+
+# ------------------------------------------------------------
+# 7) Matrix input with vector bounds (broadcast across columns)
+# ------------------------------------------------------------
+def test_saturation_matrix_vector_bounds_broadcast_columns():
+    src = Constant("src", [[10.0, -10.0, 2.0],
+                           [5.0,   6.0, -7.0]])  # (2,3)
+
+    # bounds as (2,1) -> broadcast across columns
+    sat = Saturation("sat", u_min=[0.0, -2.0], u_max=[3.0, 1.0])
+
+    logs = run_sim(src, sat)
+
+    # row1 clipped to [0,3], row2 clipped to [-2,1]
+    expected = np.array([[3.0, 0.0, 2.0],
+                         [1.0, 1.0, -2.0]])
+    assert np.allclose(logs[0], expected)
+
+
+# ------------------------------------------------------------
+# 8) Passthrough with no bounds
+# ------------------------------------------------------------
+def test_saturation_no_bounds():
+    src = Step("src", value_before=0.0, value_after=10.0, start_time=0.0)
+    sat = Saturation("sat")
+
+    logs = run_sim(src, sat)
+    assert np.allclose(logs[0], [[10.0]])
+
+# ------------------------------------------------------------
+# 9) Invalid bounds (after resolution)
+# ------------------------------------------------------------
+def test_saturation_bounds_componentwise_ok():
+    s = Saturation("sat", u_min=[1.0, 5.0], u_max=[2.0, 8.0])
+    s.inputs["in"] = np.array([[0.0], [10.0]])
+    s.initialize(0.0)
+    assert np.allclose(s.outputs["out"], [[1.0], [8.0]])
+
+# ------------------------------------------------------------
+# 10) Invalid bounds (after resolution)
+# ------------------------------------------------------------
+def test_saturation_invalid_bounds_scalar():
+    with pytest.raises(ValueError):
+        s = Saturation("sat", u_min=2.0, u_max=1.0)
+        s.inputs["in"] = np.array([[0.0]])
+        s.initialize(0.0)
+
+
+# ------------------------------------------------------------
+# 11) Missing input at initialization
+# ------------------------------------------------------------
+def test_saturation_missing_input():
+    sat = Saturation("sat", u_min=0.0, u_max=1.0)
+    m = Model()
+    m.add_block(sat)
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError):
+        sim.initialize()
+
+
+if __name__ == "__main__":
+    test_saturation_invalid_bounds_scalar()

tests/blocks/operators/test_sum.py

@@ -0,0 +1,183 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core.model import Model
+from pySimBlocks.core.simulator import Simulator
+from pySimBlocks.core.config import SimulationConfig
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.operators.sum import Sum
+
+
+# ------------------------------------------------------------
+# Helper
+# ------------------------------------------------------------
+def run_two_inputs(v1, v2, signs="++", dt=0.1):
+    m = Model()
+
+    s1 = Constant("s1", v1)
+    s2 = Constant("s2", v2)
+
+    m.add_block(s1)
+    m.add_block(s2)
+
+    sm = Sum("S", signs=signs)
+    m.add_block(sm)
+
+    m.connect("s1", "out", "S", "in1")
+    m.connect("s2", "out", "S", "in2")
+
+    sim_cfg = SimulationConfig(dt, dt, logging=["S.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs["S.outputs.out"][-1]
+
+
+# ------------------------------------------------------------
+# 1) Basic sum: u1 + u2
+# ------------------------------------------------------------
+def test_sum_basic():
+    out = run_two_inputs([[1.0]], [[2.0]])
+    assert np.allclose(out, [[3.0]])
+
+
+# ------------------------------------------------------------
+# 2) Subtraction: u1 - u2
+# ------------------------------------------------------------
+def test_sum_subtraction():
+    out = run_two_inputs([[5.0]], [[3.0]], signs="+-")
+    assert np.allclose(out, [[2.0]])
+
+
+# ------------------------------------------------------------
+# 3) Automatic default signs = ++
+# ------------------------------------------------------------
+def test_sum_default_signs():
+    sm = Sum("S")
+    assert sm.signs == [1.0, 1.0]
+    assert sm.num_inputs == 2
+
+
+# ------------------------------------------------------------
+# 4) Matrix sum supported
+# ------------------------------------------------------------
+def test_sum_matrix_supported():
+    u1 = np.array([[1.0, 2.0],
+                   [3.0, 4.0]])
+    u2 = np.array([[10.0, 20.0],
+                   [30.0, 40.0]])
+    out = run_two_inputs(u1, u2, signs="++")
+    assert np.allclose(out, u1 + u2)
+
+
+# ------------------------------------------------------------
+# 5) Scalar broadcast to matrix supported (only (1,1) allowed)
+# ------------------------------------------------------------
+def test_sum_scalar_broadcast_to_matrix():
+    u1 = np.array([[1.0, 2.0],
+                   [3.0, 4.0]])
+    u2 = np.array([[5.0]])  # scalar (1,1) broadcast
+    out = run_two_inputs(u1, u2, signs="++")
+    assert np.allclose(out, u1 + 5.0)
+
+
+# ------------------------------------------------------------
+# 6) Shape mismatch among non-scalars must raise RuntimeError
+#    (sim wraps ValueError into RuntimeError)
+# ------------------------------------------------------------
+def test_sum_shape_mismatch_non_scalars():
+    m = Model()
+
+    s1 = Constant("s1", np.zeros((2, 2)))
+    s2 = Constant("s2", np.zeros((2, 3)))  # mismatch
+
+    sm = Sum("S", "++")
+    m.add_block(s1)
+    m.add_block(s2)
+    m.add_block(sm)
+
+    m.connect("s1", "out", "S", "in1")
+    m.connect("s2", "out", "S", "in2")
+
+    dt = 0.1
+    sim_cfg = SimulationConfig(dt, dt, logging=["S.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError) as err:
+        sim.run(T=0.1)
+
+    assert "Inconsistent input shapes for Sum" in str(err.value)
+
+
+# ------------------------------------------------------------
+# 7) Vector-to-matrix implicit broadcast is NOT allowed
+# ------------------------------------------------------------
+def test_sum_vector_to_matrix_not_allowed():
+    m = Model()
+
+    s1 = Constant("s1", np.zeros((2, 2)))      # non-scalar target shape
+    s2 = Constant("s2", np.zeros((2, 1)))      # non-scalar but different shape (not scalar)
+
+    sm = Sum("S", "++")
+    m.add_block(s1)
+    m.add_block(s2)
+    m.add_block(sm)
+
+    m.connect("s1", "out", "S", "in1")
+    m.connect("s2", "out", "S", "in2")
+
+    dt = 0.1
+    sim_cfg = SimulationConfig(dt, dt, logging=["S.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError) as err:
+        sim.run(T=0.1)
+
+    # depending on where it fails, message can be either "Inconsistent input shapes..."
+    # or "Only scalar (1,1) inputs can be broadcast."
+    assert (
+        "Inconsistent input shapes for Sum" in str(err.value)
+        or "Only scalar (1,1) inputs can be broadcast" in str(err.value)
+    )
+
+
+# ------------------------------------------------------------
+# 8) Invalid signs list
+# ------------------------------------------------------------
+def test_sum_invalid_signs():
+    with pytest.raises(ValueError):
+        Sum("S", signs="+/")  # invalid character
+
+
+# ------------------------------------------------------------
+# 9) Inferred num_inputs from signs only
+# ------------------------------------------------------------
+def test_sum_infer_num_inputs_from_signs():
+    sm = Sum("S", signs="+")
+    assert sm.num_inputs == 1
+    assert sm.signs == [1.0]
+
+
+# ------------------------------------------------------------
+# 10) Check output initialization (inputs connected)
+# ------------------------------------------------------------
+def test_sum_initial_output():
+    m = Model()
+
+    s1 = Constant("s1", [[1.0]])
+    s2 = Constant("s2", [[2.0]])
+
+    sm = Sum("S", signs="++")
+
+    m.add_block(s1)
+    m.add_block(s2)
+    m.add_block(sm)
+
+    m.connect("s1", "out", "S", "in1")
+    m.connect("s2", "out", "S", "in2")
+
+    dt = 0.1
+    sim_cfg = SimulationConfig(dt, dt, logging=["S.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    sim.initialize(0.0)
+
+    assert np.allclose(sm.outputs["out"], [[3.0]])

tests/blocks/operators/test_zero_order_hold.py

@@ -0,0 +1,106 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.sinusoidal import Sinusoidal
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.operators.zero_order_hold import ZeroOrderHold
+
+
+def run_sim(src, block, dt=0.01, T=0.1):
+    model = Model("test")
+    model.add_block(src)
+    model.add_block(block)
+    model.connect(src.name, "out", block.name, "in")
+
+    sim_cfg = SimulationConfig(dt, T, logging=[f"{block.name}.outputs.out"])
+    sim = Simulator(model, sim_cfg)
+    logs = sim.run()
+    return logs[f"{block.name}.outputs.out"]
+
+
+# ------------------------------------------------------------------
+
+def test_zoh_passthrough_first_sample():
+    src = Constant("src", 3.0)
+    zoh = ZeroOrderHold("zoh", sample_time=0.1)
+
+    logs = run_sim(src, zoh, dt=0.01, T=0.03)
+
+    assert np.allclose(logs[0], [[3.0]])
+    assert np.allclose(logs[1], [[3.0]])
+
+
+# ------------------------------------------------------------------
+
+def test_zoh_hold_behavior():
+    """
+    sample_time=0.05s, dt=0.01s -> update expected at k=0,5,10...
+    We check:
+      - values constant between k=0..4
+      - change occurs at k=5 (very likely for sinusoidal)
+    """
+    src = Sinusoidal("src", amplitude=1.0, frequency=1.0, offset=0.0, phase=0.0)
+    zoh = ZeroOrderHold("zoh", sample_time=0.05)
+
+    logs = run_sim(src, zoh, dt=0.01, T=0.11)
+
+    # held constant over [0..4]
+    for k in range(1, 5):
+        assert np.allclose(logs[k], logs[0])
+
+    # at k=5, new sample should be taken (may still coincidentally match,
+    # but extremely unlikely; we keep a strict "not allclose" check)
+    assert not np.allclose(logs[5], logs[0])
+
+    # held constant over [5..9]
+    for k in range(6, 10):
+        assert np.allclose(logs[k], logs[5])
+
+
+# ------------------------------------------------------------------
+
+def test_zoh_vector_signal():
+    src = Constant("src", [[1.0], [2.0]])
+    zoh = ZeroOrderHold("zoh", sample_time=0.05)
+
+    logs = run_sim(src, zoh, dt=0.01, T=0.03)
+
+    assert np.allclose(logs[0], [[1.0], [2.0]])
+
+
+# ------------------------------------------------------------------
+
+def test_zoh_matrix_signal():
+    src = Constant("src", [[1.0, 2.0],
+                           [3.0, 4.0]])
+    zoh = ZeroOrderHold("zoh", sample_time=0.05)
+
+    logs = run_sim(src, zoh, dt=0.01, T=0.03)
+
+    assert np.allclose(logs[0], [[1.0, 2.0], [3.0, 4.0]])
+    assert logs[0].shape == (2, 2)
+
+
+# ------------------------------------------------------------------
+
+def test_zoh_shape_change_raises():
+    # block-only: ZOH must reject shape changes once initialized
+    zoh = ZeroOrderHold("zoh", sample_time=0.05)
+
+    zoh.inputs["in"] = np.array([[1.0]])  # (1,1)
+    zoh.initialize(0.0)
+
+    zoh.inputs["in"] = np.array([[1.0, 2.0],
+                                 [3.0, 4.0]])  # (2,2)
+    with pytest.raises(ValueError) as err:
+        zoh.output_update(0.01, 0.01)
+
+    assert "shape" in str(err.value).lower()
+
+
+# ------------------------------------------------------------------
+
+def test_zoh_invalid_sample_time():
+    with pytest.raises(ValueError):
+        ZeroOrderHold("zoh", sample_time=0.0)

tests/blocks/sources/test_chirp.py

@@ -0,0 +1,157 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.sources.chirp import Chirp
+
+
+# ----------------------------------------------------------
+# 1) Scalar parameters
+# ----------------------------------------------------------
+def test_chirp_scalar_at_start():
+    c = Chirp(
+        "c",
+        amplitude=2.0,
+        f0=1.0,
+        f1=5.0,
+        duration=2.0,
+        offset=0.5,
+        phase=0.0,
+    )
+    c.initialize(0.0)
+    # tau = 0 -> sin(0)=0
+    assert np.allclose(c.outputs["out"], [[0.5]])
+
+
+def test_chirp_scalar_mid_sweep():
+    c = Chirp("c", 1.0, 1.0, 3.0, 2.0)
+    c.output_update(1.0, 0.1)
+
+    # expected phase manually
+    k = (3.0 - 1.0) / 2.0
+    tau = 1.0
+    phi = 2 * np.pi * (1.0 * tau + 0.5 * k * tau**2)
+    expected = np.sin(phi)
+
+    assert np.allclose(c.outputs["out"], [[expected]])
+
+
+# ----------------------------------------------------------
+# 2) After sweep duration (constant frequency f1)
+# ----------------------------------------------------------
+def test_chirp_after_duration_continuity():
+    c = Chirp("c", 1.0, 1.0, 3.0, 2.0)
+
+    c.output_update(2.0, 0.1)  # end of sweep
+    y_end = c.outputs["out"].copy()
+
+    c.output_update(3.0, 0.1)  # after sweep
+    y_after = c.outputs["out"]
+
+    # just verify finite and defined (continuity handled in block)
+    assert np.isfinite(y_end).all()
+    assert np.isfinite(y_after).all()
+
+
+# ----------------------------------------------------------
+# 3) Vector parameters
+# ----------------------------------------------------------
+def test_chirp_vector_parameters():
+    c = Chirp(
+        "c",
+        amplitude=[1.0, 2.0],
+        f0=[1.0, 2.0],
+        f1=[3.0, 4.0],
+        duration=[2.0, 2.0],
+        offset=[0.0, 10.0],
+        phase=[0.0, 0.0],
+    )
+
+    c.output_update(0.0, 0.1)
+
+    # tau=0 -> sin(0)=0
+    assert np.allclose(c.outputs["out"], [[0.0], [10.0]])
+
+
+# ----------------------------------------------------------
+# 4) Broadcasting scalar (allowed only (1,1))
+# ----------------------------------------------------------
+def test_chirp_broadcast_scalar_duration():
+    c = Chirp(
+        "c",
+        amplitude=[1.0, 1.0, 1.0],
+        f0=[1.0, 2.0, 3.0],
+        f1=[2.0, 3.0, 4.0],
+        duration=2.0,  # scalar broadcast
+    )
+
+    c.output_update(0.5, 0.1)
+    assert c.outputs["out"].shape == (3, 1)
+
+
+# ----------------------------------------------------------
+# 5) Matrix parameters (Option B)
+# ----------------------------------------------------------
+def test_chirp_matrix_same_shape():
+    A = np.array([[1.0, 2.0],
+                  [3.0, 4.0]])
+    F0 = np.array([[1.0, 1.0],
+                   [1.0, 1.0]])
+    F1 = np.array([[2.0, 2.0],
+                   [2.0, 2.0]])
+    D = np.array([[2.0, 2.0],
+                  [2.0, 2.0]])
+
+    c = Chirp("c", amplitude=A, f0=F0, f1=F1, duration=D)
+    c.output_update(0.0, 0.1)
+
+    assert np.allclose(c.outputs["out"], np.zeros((2, 2)))
+
+
+def test_chirp_matrix_broadcast_scalar_offset():
+    A = np.array([[1.0, 2.0],
+                  [3.0, 4.0]])
+    F0 = np.ones((2, 2))
+    F1 = 2 * np.ones((2, 2))
+    D = 2 * np.ones((2, 2))
+
+    c = Chirp("c", amplitude=A, f0=F0, f1=F1, duration=D, offset=5.0)
+    c.output_update(0.0, 0.1)
+
+    assert np.allclose(c.outputs["out"], np.full((2, 2), 5.0))
+
+
+# ----------------------------------------------------------
+# 6) Inconsistent shapes among non-scalars -> error
+# ----------------------------------------------------------
+def test_chirp_inconsistent_shapes():
+    with pytest.raises(ValueError):
+        Chirp(
+            "c",
+            amplitude=np.zeros((2, 2)),
+            f0=np.zeros((2, 3)),  # mismatch
+            f1=1.0,
+            duration=1.0,
+        )
+
+
+# ----------------------------------------------------------
+# 7) Illegal ndim (>2) -> error
+# ----------------------------------------------------------
+def test_chirp_illegal_ndim():
+    with pytest.raises(ValueError):
+        Chirp(
+            "c",
+            amplitude=np.zeros((2, 2, 2)),
+            f0=1.0,
+            f1=2.0,
+            duration=1.0,
+        )
+
+
+# ----------------------------------------------------------
+# 8) Invalid duration (<=0) -> error
+# ----------------------------------------------------------
+def test_chirp_invalid_duration():
+    with pytest.raises(ValueError):
+        Chirp("c", 1.0, 1.0, 2.0, duration=0.0)
+

tests/blocks/sources/test_constant.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.sources.constant import Constant
+
+
+# ------------------------------------------------------------
+# 1) Test valeur simple (scalaire)
+# ------------------------------------------------------------
+def test_constant_scalar():
+    c = Constant("c", 5.0)
+    c.initialize(0.0)
+    assert np.allclose(c.outputs["out"], [[5.0]])
+
+
+# ------------------------------------------------------------
+# 2) Test vecteur colonne (n,1)
+# ------------------------------------------------------------
+def test_constant_vector():
+    c = Constant("c", [[1.0], [2.0], [3.0]])
+    c.initialize(0.0)
+    assert np.allclose(c.outputs["out"], [[1.0], [2.0], [3.0]])
+
+
+# ------------------------------------------------------------
+# 3) Test reshape depuis vecteur ligne ou liste 1D
+# ------------------------------------------------------------
+def test_constant_1d_list():
+    c = Constant("c", [10.0, 20.0])
+    c.initialize(0.0)
+    assert np.allclose(c.outputs["out"], [[10.0], [20.0]])
+
+# ------------------------------------------------------------
+# 4) Test matrice (m,n)
+# ------------------------------------------------------------
+def test_constant_matrix():
+    c = Constant("c", [[1.0, 2.0], [3.0, 4.0]])
+    c.initialize(0.0)
+    assert np.allclose(c.outputs["out"], [[1.0, 2.0], [3.0, 4.0]])
+
+
+# ------------------------------------------------------------
+# 5) Test erreur : valeur non numérique
+# ------------------------------------------------------------
+def test_constant_invalid_type():
+    with pytest.raises(TypeError):
+        Constant("c", value="not numeric")
+
+
+# ------------------------------------------------------------
+# 6) Test erreur : mauvaise forme (simulateur ne joue pas de rôle ici)
+# ------------------------------------------------------------
+def test_constant_bad_shape():
+    with pytest.raises(ValueError):
+        Constant("c", value=np.zeros((2, 3, 2)))