pySimBlocks 0.1.0__py3-none-any.whl

tests/blocks/operators/test_gain.py

@@ -0,0 +1,182 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.operators.gain import Gain
+
+
+# ------------------------------------------------------------
+# Helper : run a tiny simulation and return last output sample
+# ------------------------------------------------------------
+def run_sim(const_value, gain_block, dt=0.1):
+    m = Model()
+
+    src = Constant("src", const_value)
+    m.add_block(src)
+    m.add_block(gain_block)
+
+    m.connect("src", "out", gain_block.name, "in")
+
+    sim_cfg = SimulationConfig(dt, dt, logging=[f"{gain_block.name}.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs[f"{gain_block.name}.outputs.out"][-1]
+
+
+# ------------------------------------------------------------
+# 1) Element-wise mode (default)
+# ------------------------------------------------------------
+def test_gain_elementwise_scalar():
+    out = run_sim([[2.0]], Gain("G", gain=3.0))
+    assert np.allclose(out, [[6.0]])
+
+
+def test_gain_elementwise_vector_row_scaling():
+    # gain vector scales rows: y = [2,3]^T * u
+    # u must have shape (2, ncols)
+    out = run_sim([[1.0], [1.0]], Gain("G", gain=[2.0, 3.0]))
+    assert np.allclose(out, [[2.0], [3.0]])
+
+
+def test_gain_elementwise_vector_bad_u_rows():
+    g = Gain("G", gain=[1.0, 2.0])  # len=2, expects u.shape[0]==2
+
+    m = Model()
+    src = Constant("src", [[1.0], [2.0], [3.0]])  # shape (3,1) incompatible
+    m.add_block(src)
+    m.add_block(g)
+    m.connect("src", "out", "G", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+    with pytest.raises(RuntimeError) as err:
+        sim.initialize()
+
+    # Simulator wraps the exception message during initialization
+    assert "Element-wise mode requires u.shape[0] == len(gain)" in str(err.value)
+
+
+def test_gain_elementwise_matrix_same_shape():
+    K = np.array([[2.0, 0.0],
+                  [1.0, -1.0]])
+    u = np.array([[3.0, 4.0],
+                  [1.0, 2.0]])
+    out = run_sim(u, Gain("G", gain=K))
+    assert np.allclose(out, K * u)
+
+
+def test_gain_elementwise_matrix_bad_shape():
+    K = np.zeros((2, 2))
+    g = Gain("G", gain=K)
+
+    m = Model()
+    src = Constant("src", np.zeros((2, 3)))  # mismatch
+    m.add_block(src)
+    m.add_block(g)
+    m.connect("src", "out", "G", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+    with pytest.raises(RuntimeError) as err:
+        sim.initialize()
+
+    assert "Element-wise mode with matrix gain requires u.shape == gain.shape" in str(err.value)
+
+
+# ------------------------------------------------------------
+# 2) Matrix (K @ u)
+# ------------------------------------------------------------
+def test_gain_left_matrix_product():
+    K = [[2.0, 0.0],
+         [1.0, -1.0]]
+    G = Gain("G", gain=K, multiplication="Matrix (K @ u)")
+
+    out = run_sim([[3.0], [1.0]], G)
+    # Expected: [[2*3 + 0*1], [1*3 + -1*1]] = [[6], [2]]
+    assert np.allclose(out, [[6.0], [2.0]])
+
+
+def test_gain_left_matrix_bad_dimensions():
+    K = [[1.0, 2.0]]  # shape (1,2)
+    g = Gain("G", gain=K, multiplication="Matrix (K @ u)")
+
+    m = Model()
+    src = Constant("src", [[1.0], [2.0], [3.0]])  # shape (3,1), incompatible
+    m.add_block(src)
+    m.add_block(g)
+    m.connect("src", "out", "G", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+    with pytest.raises(RuntimeError) as err:
+        sim.initialize()
+
+    assert "Left matrix product requires u.shape[0] == gain.shape[1]" in str(err.value)
+
+
+def test_gain_left_matrix_requires_matrix_gain():
+    g = Gain("G", gain=2.0, multiplication="Matrix (K @ u)")  # scalar gain not allowed here
+    m = Model()
+    src = Constant("src", [[1.0]])
+    m.add_block(src)
+    m.add_block(g)
+    m.connect("src", "out", "G", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+    with pytest.raises(RuntimeError) as err:
+        sim.initialize()
+
+    assert "requires a 2D matrix gain" in str(err.value)
+
+
+# ------------------------------------------------------------
+# 3) Matrix (u @ K)
+# ------------------------------------------------------------
+def test_gain_right_matrix_product():
+    # u shape (1,2), K shape (2,3) => out shape (1,3)
+    K = np.array([[1.0, 2.0, 3.0],
+                  [4.0, 5.0, 6.0]])
+    G = Gain("G", gain=K, multiplication="Matrix (u @ K)")
+
+    u = np.array([[10.0, 1.0]])
+    out = run_sim(u, G)
+    expected = (u @ K).T
+    assert np.allclose(out, expected)
+
+
+def test_gain_right_matrix_bad_dimensions():
+    K = np.zeros((2, 3))
+    g = Gain("G", gain=K, multiplication="Matrix (u @ K)")
+
+    m = Model()
+    src = Constant("src", np.zeros((2, 4)))  # u.shape[1]=4, expected 2
+    m.add_block(src)
+    m.add_block(g)
+    m.connect("src", "out", "G", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+    with pytest.raises(RuntimeError) as err:
+        sim.initialize()
+
+    assert "Right matrix product requires u.shape[1] == gain.shape[0]" in str(err.value)
+
+
+# ------------------------------------------------------------
+# 4) Initialization sanity
+# ------------------------------------------------------------
+def test_initialization_output_elementwise_default():
+    G = Gain("G", gain=2.0)  # default: Element wise
+    m = Model()
+    src = Constant("src", [[1.5]])
+    m.add_block(src)
+    m.add_block(G)
+    m.connect("src", "out", "G", "in")
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+    sim.initialize(0.0)
+
+    assert np.allclose(G.outputs["out"], [[3.0]])

tests/blocks/operators/test_mux.py

@@ -0,0 +1,101 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.core import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources.constant import Constant
+from pySimBlocks.blocks.operators.mux import Mux
+
+
+# ------------------------------------------------------------
+def run_sim(values, mux):
+    m = Model()
+
+    const_blocks = []
+    for i, val in enumerate(values):
+        c = Constant(f"c{i+1}", val)
+        m.add_block(c)
+        const_blocks.append(c)
+
+    m.add_block(mux)
+    for i, c in enumerate(const_blocks):
+        m.connect(c.name, "out", mux.name, f"in{i+1}")
+
+    sim_cfg = SimulationConfig(0.1, 0.1, logging=[f"{mux.name}.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs[f"{mux.name}.outputs.out"][-1]
+
+
+# ------------------------------------------------------------
+def test_mux_basic_concatenation():
+    mux = Mux("M", num_inputs=2)
+    out = run_sim([[[1.0]], [[2.0]]], mux)
+    assert np.allclose(out, [[1.0], [2.0]])
+
+
+# ------------------------------------------------------------
+def test_mux_multi_dimensional_inputs():
+    mux = Mux("M", num_inputs=3)
+    out = run_sim(
+        [
+            [[1.0], [2.0]],              # (2,1)
+            [[3.0]],                     # (1,1)
+            [[4.0], [5.0], [6.0]],       # (3,1)
+        ],
+        mux,
+    )
+
+    expected = np.array([[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]])
+    assert np.allclose(out, expected)
+
+
+# ------------------------------------------------------------
+def test_mux_scalar_inputs_allowed():
+    mux = Mux("M", num_inputs=3)
+    out = run_sim([1.0, 2.0, 3.0], mux)  # scalars -> (1,1) each
+    expected = np.array([[1.0], [2.0], [3.0]])
+    assert np.allclose(out, expected)
+
+
+# ------------------------------------------------------------
+def test_mux_missing_input_raises():
+    m = Model()
+    c1 = Constant("c1", [[1.0]])
+    mux = Mux("M", num_inputs=2)
+
+    m.add_block(c1)
+    m.add_block(mux)
+
+    m.connect("c1", "out", "M", "in1")
+    # in2 not connected
+
+    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_mux_invalid_shape_rejected():
+    # in2 is a matrix (2,2) -> must raise
+    m = Model()
+    c1 = Constant("c1", [[1.0]])                     # OK
+    c2 = Constant("c2", [[1.0, 2.0], [3.0, 4]])
+
+    mux = Mux("M", num_inputs=2)
+    m.add_block(c1)
+    m.add_block(c2)
+    m.add_block(mux)
+
+    m.connect("c1", "out", "M", "in1")
+    m.connect("c2", "out", "M", "in2")
+
+    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" in str(err.value)

tests/blocks/operators/test_product.py

@@ -0,0 +1,171 @@
+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.product import Product
+
+
+# ------------------------------------------------------------
+# Helper
+# ------------------------------------------------------------
+def run_two_inputs(v1, v2, operations="*", multiplication="Element-wise (*)", dt=0.1):
+    m = Model()
+
+    s1 = Constant("s1", v1)
+    s2 = Constant("s2", v2)
+
+    m.add_block(s1)
+    m.add_block(s2)
+
+    pr = Product("P", operations=operations, multiplication=multiplication)
+    m.add_block(pr)
+
+    m.connect("s1", "out", "P", "in1")
+    m.connect("s2", "out", "P", "in2")
+
+    sim_cfg = SimulationConfig(dt, dt, logging=["P.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs["P.outputs.out"][-1]
+
+
+# ------------------------------------------------------------
+# 1) Basic product: u1 * u2
+# ------------------------------------------------------------
+def test_product_basic():
+    out = run_two_inputs([[2.0]], [[3.0]])
+    assert np.allclose(out, [[6.0]])
+
+
+# ------------------------------------------------------------
+# 2) Division: u1 / u2
+# ------------------------------------------------------------
+def test_product_division():
+    out = run_two_inputs([[6.0]], [[3.0]], operations="/")
+    assert np.allclose(out, [[2.0]])
+
+
+# ------------------------------------------------------------
+# 3) Scalar × vector (broadcast scalar (1,1) only)
+# ------------------------------------------------------------
+def test_product_scalar_vector():
+    out = run_two_inputs([[2.0]], [[1.0], [3.0], [4.0]])
+    assert np.allclose(out, [[2.0], [6.0], [8.0]])
+
+
+# ------------------------------------------------------------
+# 4) Vector × vector (same shape)
+# ------------------------------------------------------------
+def test_product_vector_vector():
+    out = run_two_inputs([[2.0], [3.0]], [[4.0], [5.0]])
+    assert np.allclose(out, [[8.0], [15.0]])
+
+
+# ------------------------------------------------------------
+# 5) Matrix element-wise product (same shape)
+# ------------------------------------------------------------
+def test_product_matrix_elementwise():
+    A = [[1.0, 2.0], [3.0, 4.0]]
+    B = [[2.0, 0.5], [1.0, 2.0]]
+    out = run_two_inputs(A, B, multiplication="Element-wise (*)")
+    assert np.allclose(out, np.array(A) * np.array(B))
+
+
+# ------------------------------------------------------------
+# 6) Scalar × matrix (element-wise scalar broadcast)
+# ------------------------------------------------------------
+def test_product_scalar_matrix_elementwise():
+    out = run_two_inputs([[2.0]], [[1.0, 2.0], [3.0, 4.0]], multiplication="Element-wise (*)")
+    assert np.allclose(out, 2.0 * np.array([[1.0, 2.0], [3.0, 4.0]]))
+
+
+# ------------------------------------------------------------
+# 7) Incompatible shapes in element-wise must raise
+# ------------------------------------------------------------
+def test_product_shape_mismatch_elementwise():
+    m = Model()
+
+    s1 = Constant("s1", [[1.0], [2.0]])           # (2,1)
+    s2 = Constant("s2", [[3.0, 4.0, 5.0]])        # (1,3) -> mismatch
+    pr = Product("P", operations="*", multiplication="Element-wise (*)")
+
+    m.add_block(s1)
+    m.add_block(s2)
+    m.add_block(pr)
+
+    m.connect("s1", "out", "P", "in1")
+    m.connect("s2", "out", "P", "in2")
+
+    sim_cfg = SimulationConfig(0.1, 0.1, logging=["P.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError) as err:
+        sim.run(T=0.1)
+
+    assert "incompatible input shapes" in str(err.value).lower()
+
+
+# ------------------------------------------------------------
+# 8) Matrix multiplication (@) basic
+# ------------------------------------------------------------
+def test_product_matrix_multiplication():
+    A = [[1.0, 2.0],
+         [3.0, 4.0]]          # (2,2)
+    B = [[5.0],
+         [6.0]]               # (2,1)
+
+    out = run_two_inputs(A, B, operations="*", multiplication="Matrix (@)")
+    assert np.allclose(out, np.array(A) @ np.array(B))
+    assert out.shape == (2, 1)
+
+
+# ------------------------------------------------------------
+# 9) Matrix multiplication rejects division
+# ------------------------------------------------------------
+def test_product_matrix_mode_rejects_division():
+    with pytest.raises(ValueError):
+        Product("P", operations="/", multiplication="Matrix (@)")
+
+
+# ------------------------------------------------------------
+# 10) Invalid operations string
+# ------------------------------------------------------------
+def test_product_invalid_operations():
+    with pytest.raises(ValueError):
+        Product("P", operations="*+")
+
+
+# ------------------------------------------------------------
+# 11) Inferred num_inputs from operations
+# ------------------------------------------------------------
+def test_product_infer_num_inputs_from_operations():
+    pr = Product("P", operations="*/")
+    assert pr.num_inputs == 3
+
+
+# ------------------------------------------------------------
+# 12) Check output initialization
+# ------------------------------------------------------------
+def test_product_initial_output():
+    m = Model()
+
+    s1 = Constant("s1", [[2.0]])
+    s2 = Constant("s2", [[3.0]])
+
+    pr = Product("P", operations="*", multiplication="Element-wise (*)")
+
+    m.add_block(s1)
+    m.add_block(s2)
+    m.add_block(pr)
+
+    m.connect("s1", "out", "P", "in1")
+    m.connect("s2", "out", "P", "in2")
+
+    sim_cfg = SimulationConfig(0.1, 0.1, logging=["P.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    sim.initialize(0.0)
+
+    assert np.allclose(pr.outputs["out"], [[6.0]])

tests/blocks/operators/test_rate_limiter.py

@@ -0,0 +1,166 @@
+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.sources.ramp import Ramp
+from pySimBlocks.blocks.operators.rate_limiter import RateLimiter
+
+
+# ------------------------------------------------------------
+def run_sim(src_block, rate_block, dt=0.1, T=0.3):
+    m = Model()
+    m.add_block(src_block)
+    m.add_block(rate_block)
+    m.connect(src_block.name, "out", rate_block.name, "in")
+
+    sim_cfg = SimulationConfig(dt, T, logging=[f"{rate_block.name}.outputs.out"])
+    sim = Simulator(m, sim_cfg)
+    logs = sim.run()
+    return logs[f"{rate_block.name}.outputs.out"]
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_passthrough_without_initial_output():
+    src = Step("src", start_time=0.0, value_before=0.0, value_after=10.0)
+    R = RateLimiter("R", rising_slope=1.0, falling_slope=-1.0)
+
+    logs = run_sim(src, R, dt=0.1, T=0.2)
+
+    assert np.allclose(logs[0], [[10.0]])
+    assert np.allclose(logs[1], [[10.0]])
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_scalar_with_initial_output():
+    src = Constant("src", 10.0)
+    R = RateLimiter("R", rising_slope=1.0, falling_slope=-1.0, initial_output=0.0)
+
+    logs = run_sim(src, R, dt=0.1, T=0.3)
+
+    assert np.allclose(logs[0], [[0.1]])
+    assert np.allclose(logs[1], [[0.2]])
+    assert np.allclose(logs[2], [[0.3]])
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_no_active_limitation():
+    src = Ramp("src", slope=0.5, offset=1.0)
+    R = RateLimiter("R", rising_slope=5.0, falling_slope=-5.0)
+
+    logs = run_sim(src, R, dt=0.1, T=0.3)
+
+    for k in range(1, len(logs)):
+        assert np.allclose(logs[k] - logs[k - 1], [[0.05]])
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_vector():
+    src = Step(
+        "src",
+        start_time=0.0,
+        value_before=[[0.0], [0.0]],
+        value_after=[[4.0], [-4.0]],
+    )
+
+    R = RateLimiter(
+        "R",
+        rising_slope=[1.0, 0.5],
+        falling_slope=[-1.0, -0.5],
+        initial_output=[[0.0], [0.0]],
+    )
+
+    logs = run_sim(src, R, dt=0.1, T=0.2)
+
+    assert np.allclose(logs[0], [[0.1], [-0.05]])
+    assert np.allclose(logs[1], [[0.2], [-0.1]])
+    assert np.allclose(logs[2], [[0.3], [-0.15]])
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_matrix_scalar_slopes():
+    src = Step(
+        "src",
+        start_time=0.0,
+        value_before=[[0.0, 0.0],
+                      [0.0, 0.0]],
+        value_after=[[10.0, -10.0],
+                     [5.0,  -5.0]],
+    )
+
+    R = RateLimiter("R", rising_slope=1.0, falling_slope=-1.0, initial_output=0.0)
+
+    logs = run_sim(src, R, dt=0.1, T=0.1)
+
+    # dt=0.1, slopes +/-1 => max delta per step = +/-0.1 everywhere
+    expected = np.array([[0.1, -0.1],
+                         [0.1, -0.1]])
+    assert np.allclose(logs[0], expected)
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_matrix_vector_slopes_broadcast_columns():
+    # input is (2,3)
+    src = Step(
+        "src",
+        start_time=0.0,
+        value_before=[[0.0, 0.0, 0.0],
+                      [0.0, 0.0, 0.0]],
+        value_after=[[10.0, -10.0, 2.0],
+                     [5.0,   6.0, -7.0]],
+    )
+
+    # slopes as (2,1) via 1D -> (2,1); should broadcast across 3 columns
+    R = RateLimiter(
+        "R",
+        rising_slope=[1.0, 0.5],
+        falling_slope=[-1.0, -0.5],
+        initial_output=0.0,
+    )
+
+    logs = run_sim(src, R, dt=0.1, T=0.1)
+
+    # row1 limited to +/-0.1, row2 limited to +/-0.05
+    expected = np.array([[0.1, -0.1, 0.1],
+                         [0.05, 0.05, -0.05]])
+    assert np.allclose(logs[0], expected)
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_missing_input():
+    R = RateLimiter("R", rising_slope=1.0, falling_slope=-1.0)
+    m = Model()
+    m.add_block(R)
+
+    sim_cfg = SimulationConfig(0.1, 0.1)
+    sim = Simulator(m, sim_cfg)
+
+    with pytest.raises(RuntimeError):
+        sim.initialize()
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_invalid_slopes():
+    with pytest.raises(ValueError):
+        RateLimiter("R", rising_slope=-1.0, falling_slope=-1.0)
+
+    with pytest.raises(ValueError):
+        RateLimiter("R", rising_slope=1.0, falling_slope=1.0)
+
+
+# ------------------------------------------------------------
+def test_rate_limiter_input_shape_change_raises():
+    # Direct block test: once initialized with (1,1), shape cannot change
+    R = RateLimiter("R", rising_slope=1.0, falling_slope=-1.0, initial_output=0.0)
+
+    R.inputs["in"] = np.array([[1.0]])
+    R.initialize(0.0)
+    R.output_update(0.0, 0.1)
+
+    R.inputs["in"] = np.array([[1.0, 2.0],
+                               [3.0, 4.0]])
+    with pytest.raises(ValueError) as err:
+        R.output_update(0.1, 0.1)
+
+    assert "shape changed" in str(err.value) or "shape" in str(err.value)