pySimBlocks 0.1.0__py3-none-any.whl

tests/blocks/sources/test_file_source.py

@@ -0,0 +1,185 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.sources.file_source import FileSource
+
+
+def test_file_source_npz_single_array(tmp_path: Path):
+    path = tmp_path / "data.npz"
+    np.savez(path, y=np.array([[1.0, 2.0], [3.0, 4.0]]))
+
+    blk = FileSource("src", file_path=str(path), key="y")
+    blk.initialize(0.0)
+    assert np.allclose(blk.outputs["out"], [[1.0], [2.0]])
+
+    blk.output_update(0.0, 0.1)
+    assert np.allclose(blk.outputs["out"], [[1.0], [2.0]])
+
+    blk.output_update(0.1, 0.1)
+    assert np.allclose(blk.outputs["out"], [[3.0], [4.0]])
+
+
+def test_file_source_npz_requires_key(tmp_path: Path):
+    path = tmp_path / "data.npz"
+    np.savez(path, a=np.array([1.0]), b=np.array([2.0]))
+
+    with pytest.raises(ValueError):
+        FileSource("src", file_path=str(path))
+
+
+def test_file_source_npz_invalid_key(tmp_path: Path):
+    path = tmp_path / "data.npz"
+    np.savez(path, a=np.array([1.0]))
+
+    with pytest.raises(KeyError):
+        FileSource("src", file_path=str(path), key="missing")
+
+
+def test_file_source_csv(tmp_path: Path):
+    path = tmp_path / "data.csv"
+    path.write_text("a,b\n1.0,2.0\n3.0,4.0\n", encoding="utf-8")
+
+    blk = FileSource("src", file_path=str(path), key="b")
+    blk.initialize(0.0)
+    assert np.allclose(blk.outputs["out"], [[2.0]])
+
+    blk.output_update(0.0, 0.1)
+    assert np.allclose(blk.outputs["out"], [[2.0]])
+
+    blk.output_update(0.1, 0.1)
+    assert np.allclose(blk.outputs["out"], [[4.0]])
+
+
+def test_file_source_repeat_false_outputs_zeros_after_end(tmp_path: Path):
+    path = tmp_path / "data.npz"
+    np.savez(path, y=np.array([[5.0], [7.0]]))
+
+    blk = FileSource(
+        "src",
+        file_path=str(path),
+        key="y",
+        repeat=False,
+    )
+    blk.initialize(0.0)
+    assert np.allclose(blk.outputs["out"], [[5.0]])
+
+    blk.output_update(0.0, 0.1)
+    assert np.allclose(blk.outputs["out"], [[5.0]])
+
+    blk.output_update(0.1, 0.1)
+    assert np.allclose(blk.outputs["out"], [[7.0]])
+
+    blk.output_update(0.2, 0.1)
+    assert np.allclose(blk.outputs["out"], [[0.0]])
+
+
+def test_file_source_repeat_true_restarts_after_end(tmp_path: Path):
+    path = tmp_path / "data.npy"
+    np.save(path, np.array([[10.0], [20.0]]))
+
+    blk = FileSource(
+        "src",
+        file_path=str(path),
+        repeat=True,
+    )
+    blk.initialize(0.0)
+    assert np.allclose(blk.outputs["out"], [[10.0]])
+
+    blk.output_update(0.0, 0.1)
+    assert np.allclose(blk.outputs["out"], [[10.0]])
+
+    blk.output_update(0.1, 0.1)
+    assert np.allclose(blk.outputs["out"], [[20.0]])
+
+    blk.output_update(0.2, 0.1)
+    assert np.allclose(blk.outputs["out"], [[10.0]])
+
+
+def test_file_source_npy_key_not_allowed(tmp_path: Path):
+    path = tmp_path / "data.npy"
+    np.save(path, np.array([1.0, 2.0]))
+
+    with pytest.raises(ValueError):
+        FileSource("src", file_path=str(path), key="k")
+
+
+def test_file_source_npy_use_time_not_allowed(tmp_path: Path):
+    path = tmp_path / "data.npy"
+    np.save(path, np.array([1.0, 2.0]))
+
+    with pytest.raises(ValueError):
+        FileSource("src", file_path=str(path), use_time=True)
+
+
+def test_file_source_csv_missing_key(tmp_path: Path):
+    path = tmp_path / "data.csv"
+    path.write_text("a,b\n1.0,2.0\n", encoding="utf-8")
+
+    with pytest.raises(ValueError):
+        FileSource("src", file_path=str(path))
+
+
+def test_file_source_invalid_extension(tmp_path: Path):
+    path = tmp_path / "data.txt"
+    path.write_text("1.0\n", encoding="utf-8")
+    with pytest.raises(ValueError):
+        FileSource("src", file_path=str(path))
+
+
+def test_file_source_missing_file():
+    with pytest.raises(FileNotFoundError):
+        FileSource("src", file_path="does-not-exist.npz")
+
+
+def test_file_source_npz_use_time_zoh(tmp_path: Path):
+    path = tmp_path / "data.npz"
+    t = np.array([0.0, 0.2, 0.5], dtype=float)
+    y = np.array([[10.0], [20.0], [50.0]], dtype=float)
+    np.savez(path, time=t, y=y)
+
+    blk = FileSource("src", file_path=str(path), key="y", use_time=True)
+
+    blk.initialize(0.0)
+    assert np.allclose(blk.outputs["out"], [[10.0]])
+
+    blk.output_update(0.19, 0.1)
+    assert np.allclose(blk.outputs["out"], [[10.0]])
+
+    blk.output_update(0.20, 0.1)
+    assert np.allclose(blk.outputs["out"], [[20.0]])
+
+    blk.output_update(0.8, 0.1)
+    assert np.allclose(blk.outputs["out"], [[50.0]])
+
+
+def test_file_source_csv_use_time_zoh(tmp_path: Path):
+    path = tmp_path / "data.csv"
+    path.write_text(
+        "time,y\n0.0,1.0\n0.5,2.0\n1.0,3.0\n",
+        encoding="utf-8",
+    )
+
+    blk = FileSource("src", file_path=str(path), key="y", use_time=True)
+    blk.initialize(0.1)
+    assert np.allclose(blk.outputs["out"], [[1.0]])
+
+    blk.output_update(0.75, 0.1)
+    assert np.allclose(blk.outputs["out"], [[2.0]])
+
+
+def test_file_source_npz_time_must_be_strictly_increasing(tmp_path: Path):
+    path = tmp_path / "data.npz"
+    np.savez(path, time=np.array([0.0, 0.2, 0.2]), y=np.array([1.0, 2.0, 3.0]))
+
+    with pytest.raises(ValueError):
+        FileSource("src", file_path=str(path), key="y", use_time=True)
+
+
+def test_file_source_csv_use_time_requires_time_column(tmp_path: Path):
+    path = tmp_path / "data.csv"
+    path.write_text("y\n1.0\n2.0\n", encoding="utf-8")
+
+    with pytest.raises(KeyError):
+        FileSource("src", file_path=str(path), key="y", use_time=True)

tests/blocks/sources/test_function_source.py

@@ -0,0 +1,135 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.sources.function_source import FunctionSource
+
+
+def test_function_source_single_output():
+    def f(t, dt):
+        return {"y": 2.0 * t + dt}
+
+    src = FunctionSource(name="f", function=f, output_keys=["y"])
+    src.initialize(0.0)
+    assert np.allclose(src.outputs["y"], [[0.0]])
+
+    src.output_update(1.0, 0.1)
+    assert np.allclose(src.outputs["y"], [[2.1]])
+
+
+def test_function_source_multiple_outputs():
+    def f(t, dt):
+        return {
+            "y1": np.array([t, t + dt]),
+            "y2": np.array([[2.0 * t]]),
+        }
+
+    src = FunctionSource(name="f", function=f, output_keys=["y1", "y2"])
+    src.initialize(0.0)
+    src.output_update(0.2, 0.1)
+
+    assert src.outputs["y1"].shape == (2, 1)
+    assert np.allclose(src.outputs["y1"], [[0.2], [0.3]])
+    assert np.allclose(src.outputs["y2"], [[0.4]])
+
+
+def test_function_source_signature_mismatch_raises():
+    def f(t, dt, u):
+        return {"out": np.array([[u]])}
+
+    src = FunctionSource(name="f", function=f)
+    with pytest.raises(ValueError):
+        src.initialize(0.0)
+
+
+def test_function_source_function_error_is_wrapped():
+    def f(t, dt):
+        raise RuntimeError("boom")
+
+    src = FunctionSource(name="f", function=f)
+    with pytest.raises(RuntimeError) as err:
+        src.initialize(0.0)
+
+    assert "function call error" in str(err.value).lower()
+
+
+def test_function_source_return_not_dict_raises():
+    def f(t, dt):
+        return np.array([[1.0]])
+
+    src = FunctionSource(name="f", function=f, output_keys=["out"])
+
+    with pytest.raises(RuntimeError) as err:
+        src.initialize(0.0)
+
+    assert "must return a dict" in str(err.value).lower()
+
+
+def test_function_source_output_keys_mismatch_raises():
+    def f(t, dt):
+        return {"z": np.array([[1.0]])}
+
+    src = FunctionSource(name="f", function=f, output_keys=["out"])
+
+    with pytest.raises(RuntimeError) as err:
+        src.initialize(0.0)
+
+    assert "output keys mismatch" in str(err.value).lower()
+
+
+def test_function_source_output_shape_change_raises_per_key():
+    def f(t, dt):
+        if t < 0.1:
+            return {"y1": np.array([[1.0]]), "y2": np.array([[2.0]])}
+        return {"y1": np.array([[1.0, 2.0]]), "y2": np.array([[2.0]])}
+
+    src = FunctionSource(name="f", function=f, output_keys=["y1", "y2"])
+    src.initialize(0.0)
+
+    with pytest.raises(ValueError) as err:
+        src.output_update(0.1, 0.1)
+
+    assert "shape changed" in str(err.value).lower()
+
+
+def test_function_source_adapt_params_loads_function(tmp_path):
+    py_file = tmp_path / "my_function.py"
+    py_file.write_text(
+        "def my_source(t, dt):\n"
+        "    return {'y': [[t + dt]]}\n",
+        encoding="utf-8",
+    )
+
+    adapted = FunctionSource.adapt_params(
+        {
+            "file_path": "my_function.py",
+            "function_name": "my_source",
+            "output_keys": ["y"],
+        },
+        params_dir=tmp_path,
+    )
+    src = FunctionSource(name="f", **adapted)
+
+    src.initialize(0.0)
+    src.output_update(0.2, 0.1)
+    assert np.allclose(src.outputs["y"], [[0.3]])
+
+
+def test_function_source_adapt_params_missing_key_raises():
+    with pytest.raises(ValueError):
+        FunctionSource.adapt_params({"file_path": "foo.py"}, params_dir=None)
+
+
+def test_function_source_adapt_params_sets_default_output_keys(tmp_path):
+    py_file = tmp_path / "my_function.py"
+    py_file.write_text(
+        "def my_source(t, dt):\n"
+        "    return {'out': [[t + dt]]}\n",
+        encoding="utf-8",
+    )
+
+    adapted = FunctionSource.adapt_params(
+        {"file_path": "my_function.py", "function_name": "my_source"},
+        params_dir=tmp_path,
+    )
+
+    assert adapted["output_keys"] == ["out"]

tests/blocks/sources/test_ramp.py

@@ -0,0 +1,110 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.sources.ramp import Ramp
+
+
+# ----------------------------------------------------------
+# 1) Scalar slope and scalar start_time
+# ----------------------------------------------------------
+def test_ramp_scalar_before_start():
+    r = Ramp("r", slope=2.0, start_time=1.0, offset=0.0)
+    r.initialize(0.0)
+    assert np.allclose(r.outputs["out"], [[0.0]])  # before start_time
+
+
+def test_ramp_scalar_after_start():
+    r = Ramp("r", slope=2.0, start_time=1.0, offset=0.0)
+    r.output_update(2.0, 0.1)
+    assert np.allclose(r.outputs["out"], [[2.0]])  # slope * (2 - 1) = 2
+
+
+# ----------------------------------------------------------
+# 2) Vector parameters (still valid)
+# ----------------------------------------------------------
+def test_ramp_vector_parameters():
+    r = Ramp(
+        "r",
+        slope=[1.0, 2.0],
+        start_time=[0.0, 1.0],
+        offset=[0.0, 10.0],
+    )
+    r.output_update(2.0, 0.1)
+    # first: 0 + 1*(2-0)=2
+    # second: 10 + 2*(2-1)=12
+    assert np.allclose(r.outputs["out"], [[2.0], [12.0]])
+
+
+# ----------------------------------------------------------
+# 3) Broadcasting scalar to match non-scalar shape
+#    (broadcast allowed ONLY for scalar (1,1))
+# ----------------------------------------------------------
+def test_ramp_broadcast_scalar_start_time():
+    r = Ramp(
+        "r",
+        slope=[1.0, 1.0, 1.0],
+        start_time=0.0,  # scalar broadcast
+        offset=0.0,      # scalar broadcast
+    )
+    r.output_update(2.0, 0.1)
+    assert np.allclose(r.outputs["out"], [[2.0], [2.0], [2.0]])
+
+
+# ----------------------------------------------------------
+# 4) Matrix parameters (Option B)
+# ----------------------------------------------------------
+def test_ramp_matrix_parameters_same_shape():
+    slope = np.array([[1.0, 2.0],
+                      [3.0, 4.0]])
+    start_time = np.array([[0.0, 1.0],
+                           [1.0, 0.0]])
+    offset = np.array([[10.0, 20.0],
+                       [30.0, 40.0]])
+
+    r = Ramp("r", slope=slope, start_time=start_time, offset=offset)
+    r.output_update(2.0, 0.1)
+
+    # dt = max(0, t - start_time)
+    dt_mat = np.maximum(0.0, 2.0 - start_time)
+    expected = offset + slope * dt_mat
+    assert np.allclose(r.outputs["out"], expected)
+
+
+def test_ramp_matrix_broadcast_scalar_offset():
+    slope = np.array([[1.0, 2.0],
+                      [3.0, 4.0]])
+    start_time = np.array([[0.0, 1.0],
+                           [1.0, 0.0]])
+
+    r = Ramp("r", slope=slope, start_time=start_time, offset=5.0)  # scalar broadcast
+    r.output_update(2.0, 0.1)
+
+    dt_mat = np.maximum(0.0, 2.0 - start_time)
+    expected = np.full((2, 2), 5.0) + slope * dt_mat
+    assert np.allclose(r.outputs["out"], expected)
+
+
+# ----------------------------------------------------------
+# 5) Inconsistent shapes among non-scalars -> error
+# ----------------------------------------------------------
+def test_ramp_inconsistent_dimensions():
+    with pytest.raises(ValueError):
+        Ramp(
+            "r",
+            slope=np.zeros((2, 2)),
+            start_time=np.zeros((2, 3)),  # mismatch
+            offset=0.0,
+        )
+
+
+# ----------------------------------------------------------
+# 6) Illegal ndims (>2) -> error
+# ----------------------------------------------------------
+def test_ramp_illegal_ndim():
+    with pytest.raises(ValueError):
+        Ramp(
+            "r",
+            slope=np.zeros((2, 2, 2)),  # ndim=3 forbidden
+            start_time=0.0,
+            offset=0.0,
+        )

tests/blocks/sources/test_sinusoidal.py

@@ -0,0 +1,113 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.sources.sinusoidal import Sinusoidal
+
+
+# ----------------------------------------------------------
+# 1) Scalar parameters
+# ----------------------------------------------------------
+def test_sinusoidal_scalar():
+    s = Sinusoidal("s", amplitude=2.0, frequency=1.0, offset=0.5, phase=0.0)
+    s.initialize(0.0)
+    assert np.allclose(s.outputs["out"], [[0.5]])  # sin(0)=0
+
+
+def test_sinusoidal_scalar_time():
+    s = Sinusoidal("s", 2.0, 1.0, 0.0, 0.0)
+    s.output_update(0.25, 0.1)  # sin(2π * 1 * 0.25) = sin(π/2) = 1
+    assert np.allclose(s.outputs["out"], [[2.0]])
+
+
+# ----------------------------------------------------------
+# 2) Vector parameters (still valid)
+# ----------------------------------------------------------
+def test_sinusoidal_vector():
+    s = Sinusoidal(
+        "s",
+        amplitude=[1.0, 2.0],
+        frequency=[1.0, 0.5],
+        offset=[0.0, 10.0],
+        phase=[0.0, np.pi / 2],
+    )
+    s.output_update(0.0, 0.1)
+    # out(0): [1*sin(0)+0, 2*sin(pi/2)+10] = [0, 12]
+    assert np.allclose(s.outputs["out"], [[0.0], [12.0]])
+
+
+# ----------------------------------------------------------
+# 3) Broadcasting scalar to match non-scalar shape
+#    (allowed only for scalar (1,1))
+# ----------------------------------------------------------
+def test_sinusoidal_broadcast_scalar_frequency():
+    s = Sinusoidal(
+        "s",
+        amplitude=[1.0, 1.0, 1.0],
+        frequency=0.5,  # scalar broadcast
+        offset=0.0,
+        phase=0.0,
+    )
+    s.output_update(1.0, 0.1)
+    expected = np.sin(2 * np.pi * 0.5 * 1.0) * np.ones((3, 1))
+    assert np.allclose(s.outputs["out"], expected)
+
+
+# ----------------------------------------------------------
+# 4) Matrix parameters (Option B)
+# ----------------------------------------------------------
+def test_sinusoidal_matrix_same_shape():
+    A = np.array([[1.0, 2.0],
+                  [3.0, 4.0]])
+    F = np.array([[1.0, 0.5],
+                  [2.0, 1.0]])
+    O = np.array([[0.0, 10.0],
+                  [20.0, 30.0]])
+    P = np.array([[0.0, np.pi / 2],
+                  [np.pi, 0.0]])
+
+    s = Sinusoidal("s", amplitude=A, frequency=F, offset=O, phase=P)
+    s.output_update(0.0, 0.1)
+
+    expected = A * np.sin(2 * np.pi * F * 0.0 + P) + O
+    assert np.allclose(s.outputs["out"], expected)
+
+
+def test_sinusoidal_matrix_broadcast_scalar_phase():
+    A = np.array([[1.0, 2.0],
+                  [3.0, 4.0]])
+    F = np.array([[1.0, 0.5],
+                  [2.0, 1.0]])
+
+    s = Sinusoidal("s", amplitude=A, frequency=F, offset=0.0, phase=0.0)  # scalars broadcast
+    s.output_update(0.0, 0.1)
+
+    expected = A * np.sin(2 * np.pi * F * 0.0 + 0.0) + 0.0
+    assert np.allclose(s.outputs["out"], expected)
+
+
+# ----------------------------------------------------------
+# 5) Inconsistent parameter shapes among non-scalars -> error
+# ----------------------------------------------------------
+def test_sinusoidal_inconsistent_shapes():
+    with pytest.raises(ValueError):
+        Sinusoidal(
+            "s",
+            amplitude=np.zeros((2, 2)),
+            frequency=np.zeros((2, 3)),  # mismatch
+            offset=0.0,
+            phase=0.0,
+        )
+
+
+# ----------------------------------------------------------
+# 6) Illegal ndims (>2) -> error
+# ----------------------------------------------------------
+def test_sinusoidal_illegal_ndim():
+    with pytest.raises(ValueError):
+        Sinusoidal(
+            "s",
+            amplitude=np.zeros((2, 2, 2)),  # ndim=3 forbidden
+            frequency=1.0,
+            offset=0.0,
+            phase=0.0,
+        )

tests/blocks/sources/test_step.py

@@ -0,0 +1,76 @@
+import numpy as np
+import pytest
+
+from pySimBlocks.blocks.sources.step import Step
+
+
+def test_step_scalar_before_after():
+    s = Step("s", 0.0, 1.0, start_time=1.0)
+    s.initialize(0.0)
+    assert np.allclose(s.outputs["out"], [[0.0]])
+    s.initialize(2.0)
+    assert np.allclose(s.outputs["out"], [[1.0]])
+
+
+def test_step_vector():
+    s = Step("s", [0, 0], [1, 2], start_time=1.0)
+    s.initialize(0.0)
+    assert np.allclose(s.outputs["out"], [[0.0], [0.0]])
+    s.initialize(2.0)
+    assert np.allclose(s.outputs["out"], [[1.0], [2.0]])
+
+
+def test_step_matrix_same_shape():
+    vb = np.array([[0.0, 0.5],
+                   [1.0, 1.5]])
+    va = np.array([[2.0, 2.5],
+                   [3.0, 3.5]])
+    s = Step("s", vb, va, start_time=1.0)
+
+    s.initialize(0.0)
+    assert np.allclose(s.outputs["out"], vb)
+    s.initialize(2.0)
+    assert np.allclose(s.outputs["out"], va)
+
+
+def test_step_scalar_broadcast_to_matrix_before():
+    # value_before scalar, value_after matrix -> broadcast before
+    vb = 0.0
+    va = np.array([[1.0, 2.0],
+                   [3.0, 4.0]])
+    s = Step("s", vb, va, start_time=1.0)
+
+    s.initialize(0.0)
+    assert np.allclose(s.outputs["out"], np.zeros((2, 2)))
+    s.initialize(2.0)
+    assert np.allclose(s.outputs["out"], va)
+
+
+def test_step_scalar_broadcast_to_matrix_after():
+    # value_before matrix, value_after scalar -> broadcast after
+    vb = np.array([[1.0, 2.0],
+                   [3.0, 4.0]])
+    va = 0.0
+    s = Step("s", vb, va, start_time=1.0)
+
+    s.initialize(0.0)
+    assert np.allclose(s.outputs["out"], vb)
+    s.initialize(2.0)
+    assert np.allclose(s.outputs["out"], np.zeros((2, 2)))
+
+
+def test_step_shape_mismatch_non_scalars():
+    vb = np.zeros((2, 2))
+    va = np.zeros((2, 3))
+    with pytest.raises(ValueError):
+        Step("s", vb, va, start_time=1.0)
+
+
+def test_step_bad_start_time_type():
+    with pytest.raises(TypeError):
+        Step("s", 0, 1, start_time=[1.0])
+
+
+def test_step_bad_ndim():
+    with pytest.raises(ValueError):
+        Step("s", np.zeros((2, 2, 2)), 1.0, start_time=1.0)