pySimBlocks 0.1.0__py3-none-any.whl

pySimBlocks/gui/blocks/operators/discrete_derivator.py

@@ -0,0 +1,67 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pySimBlocks.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class DiscreteDerivatorMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "DiscreteDerivator"
+        self.category = "operators"
+        self.type = "discrete_derivator"
+        self.summary = "Discrete-time differentiator block."
+        self.description = (
+            "Computes a backward finite-difference approximation of the derivative:\n"
+            "$$\n"
+            "y[k] = \\frac{u[k] - u[k-1]}{dt}\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="initial_output",
+                type="scalar | vector | matrix"
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float"
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="in",
+                shape=["n", "m"],
+                description="Input signal."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Discrete-time derivative of the input."
+            )
+        ]

pySimBlocks/gui/blocks/operators/discrete_integrator.py

@@ -0,0 +1,80 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pySimBlocks.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class DiscreteIntegratorMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "DiscreteIntegrator"
+        self.category = "operators"
+        self.type = "discrete_integrator"
+        self.summary = "Discrete-time integrator block."
+        self.description = (
+            "Implements a discrete-time integration of the input signal.\n"
+            "The state evolves according to:\n"
+            "$$\n"
+            "x[k+1] = x[k] + dt \\, u[k]\n"
+            "$$\n"
+            "with output:\n"
+            "$$\n"
+            "y[k] = x[k]\n"
+            "$$\n"
+            "for forward Euler integration."
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="initial_state",
+                type="scalar | vector | matrix"
+            ),
+            ParameterMeta(
+                name="method",
+                type="enum",
+                autofill=True,
+                default="euler forward",
+                enum=["euler forward", "euler backward"]
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float"
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="in",
+                shape=["n", "m"],
+                description="Input signal to integrate."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Integrated output signal."
+            )
+        ]

pySimBlocks/gui/blocks/operators/gain.py

@@ -0,0 +1,79 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pySimBlocks.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class GainMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Gain"
+        self.category = "operators"
+        self.type = "gain"
+        self.summary = "Static linear gain block."
+        self.description = (
+            "Computes:\n"
+            "$$\n"
+            "y = K \\cdot u\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="gain",
+                type="scalar | vector | matrix",
+                required=True,
+                autofill=True,
+                default=1.0,
+                description="Gain coefficient."
+            ),
+            ParameterMeta(
+                name="multiplication",
+                type="enum",
+                autofill=True,
+                default="Element wise (K * u)",
+                enum=["Element wise (K * u)", "Matrix (K @ u)", "Matrix (u @ K)"],
+                description="Type of multiplication operation."
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float"
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="in",
+                shape=["n", "m"],
+                description="Input signal."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["m", "m"],
+                description="Output signal."
+            )
+        ]

pySimBlocks/gui/blocks/operators/mux.py

@@ -0,0 +1,100 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from typing import Literal
+from pySimBlocks.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+from pySimBlocks.gui.models import BlockInstance, PortInstance
+
+
+class MuxMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Mux"
+        self.category = "operators"
+        self.type = "mux"
+        self.summary = "Vertical signal concatenation block."
+        self.description = (
+            "Concatenates multiple input column vectors vertically:\n"
+            "$$\n"
+            "\\mathrm{out} =\n"
+            "\\begin{bmatrix}\n"
+            "\\mathrm{in}_1 \\\\\n"
+            "\\mathrm{in}_2 \\\\\n"
+            "\\vdots \\\\\n"
+            "\\mathrm{in}_N\n"
+            "\\end{bmatrix}\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="num_inputs",
+                type="int",
+                autofill=True,
+                default=2
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float"
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="",
+                shape=["n", 1],
+                description="Input column vectors to concatenate."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["m", 1],
+                description="Vertically concatenated output vector."
+            )
+        ]
+
+    def resolve_port_group(self, 
+                           port_meta: PortMeta,
+                           direction: Literal['input', 'output'], 
+                           instance: "BlockInstance"
+        ) -> list["PortInstance"]:
+
+        if direction == "input" and port_meta.name == "in":
+            num_inputs = instance.parameters.get("num_inputs", 0)
+            ports = []
+            for i in range(1, num_inputs + 1):
+                ports.append(
+                    PortInstance(
+                        name=f"{port_meta.name}{i}",
+                        display_as="",
+                        direction="input",
+                        block=instance
+                    )
+                )
+
+            return ports
+
+        return super().resolve_port_group(port_meta, direction, instance)

pySimBlocks/gui/blocks/operators/product.py

@@ -0,0 +1,109 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+import enum
+from typing import Literal
+from pySimBlocks.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+from pySimBlocks.gui.models import BlockInstance, PortInstance
+
+
+class ProductMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Product"
+        self.category = "operators"
+        self.type = "product"
+        self.summary = "Multi-input product block."
+        self.description = (
+            "If \"Element-wise (*)\" is selected, this block computes the element-wise:\n"
+            "$$\n"
+            "y = u_1 operations_1 u_2 operations_2 ... operations_m-1 u_m\n"
+            "$$\n"
+            "where u_i are the input signals and operations_i are the operations selected * or /.\n\n"
+            "If \"Matrix (@)\" is selected, this block computes the matrix product:\n"
+            "$$\n"
+            "y = u_1 operations_1 u_2 operations_2 ... operations_m-1 u_m\n"
+            "$$\n"
+            "where u_i are the input signals and operations_i are the operations selected * (@) or / (inverse)."
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="operations",
+                type="str",
+                autofill=True,
+                default="*"
+            ),
+            ParameterMeta(
+                name="multiplication",
+                type="enum",
+                autofill=True,
+                default="Element-wise (*)",
+                enum=["Element-wise (*)", "Matrix (@)"]
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float"
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="",
+                shape=["n", "m"],
+                description="Input signals."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Output signal."
+            )
+        ]
+
+    def resolve_port_group(
+        self,
+        port_meta: PortMeta,
+        direction: Literal['input', 'output'],
+        instance: "BlockInstance"
+    ) -> list["PortInstance"]:
+
+        if direction == "input" and port_meta.name == "in":
+            operations_str = instance.parameters.get("operations", "")
+            ports = []
+            for i, op in enumerate(operations_str):
+                ports.append(
+                    PortInstance(
+                        name=f"{port_meta.name}_{i}",
+                        display_as=op,
+                        direction="input",
+                        block=instance
+                    )
+                )
+
+            return ports
+
+        return super().resolve_port_group(port_meta, direction, instance)

pySimBlocks/gui/blocks/operators/rate_limiter.py

@@ -0,0 +1,79 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pySimBlocks.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class RateLimiterMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "RateLimiter"
+        self.category = "operators"
+        self.type = "rate_limiter"
+        self.summary = "Discrete-time rate limiter block."
+        self.description = (
+            "Limits the rate of change of the output signal according to:\n"
+            "$$\n"
+            "\\Delta u = u[k] - y[k-1]\n"
+            "$$\n"
+            "$$\n"
+            "y[k] = y[k-1] + \\mathrm{clip}(\\Delta u,\\; s^{-} dt,\\; s^{+} dt)\n"
+            "$$\n"
+            "where $s^{+}$ is the rising slope and $s^{-}$ is the falling slope."
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="rising_slope",
+                type="scalar | vector | matrix"
+            ),
+            ParameterMeta(
+                name="falling_slope",
+                type="scalar | vector | matrix"
+            ),
+            ParameterMeta(
+                name="initial_output",
+                type="scalar | vector | matrix"
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float"
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="in",
+                shape=["n", "m"],
+                description="Input signal."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Rate-limited output signal."
+            )
+        ]

pySimBlocks/gui/blocks/operators/saturation.py

@@ -0,0 +1,72 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pySimBlocks.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.blocks.parameter_meta import ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+
+
+class SaturationMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Saturation"
+        self.category = "operators"
+        self.type = "saturation"
+        self.summary = "Discrete-time saturation operator."
+        self.description = (
+            "Applies element-wise saturation to the input signal:\n"
+            "$$\n"
+            "y[k] = \\mathrm{clip}(u[k], u_{\\min}, u_{\\max})\n"
+            "$$\n"
+            "where $u_{\\min}$ and $u_{\\max}$ define the lower and upper bounds."
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="u_min",
+                type="scalar | vector | matrix"
+            ),
+            ParameterMeta(
+                name="u_max",
+                type="scalar | vector | matrix"
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float"
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="in",
+                shape=["n", 1],
+                description="Input signal."
+            )
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"],
+                description="Saturated output signal."
+            )
+        ]

pySimBlocks/gui/blocks/operators/sum.py

@@ -0,0 +1,91 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+
+from typing import Literal
+from pySimBlocks.gui.blocks.block_meta import BlockMeta, ParameterMeta
+from pySimBlocks.gui.blocks.port_meta import PortMeta
+from pySimBlocks.gui.models import BlockInstance, PortInstance
+
+class SumMeta(BlockMeta):
+
+    def __init__(self):
+        self.name = "Sum"
+        self.category = "operators"
+        self.type = "sum"
+        self.summary = "Multi-input summation block."
+        self.description = (
+            "Computes:\n"
+            "$$\n"
+            r"y = \sum_i s_i \cdot u_i""\n"
+            "$$\n"
+        )
+
+        self.parameters = [
+            ParameterMeta(
+                name="signs",
+                type="str",
+                autofill=True,
+                default="++"
+            ),
+            ParameterMeta(
+                name="sample_time",
+                type="float"
+            )
+        ]
+
+        self.inputs = [
+            PortMeta(
+                name="in",
+                display_as="",
+                shape=["n", "m"]
+            ),
+        ]
+
+        self.outputs = [
+            PortMeta(
+                name="out",
+                display_as="out",
+                shape=["n", "m"]
+            ),
+        ]
+    
+    def resolve_port_group(self, 
+                           port_meta: PortMeta,
+                           direction: Literal['input', 'output'], 
+                           instance: "BlockInstance"
+        ) -> list["PortInstance"]:
+
+        if direction == "input" and port_meta.name == "in":
+            signs = instance.parameters.get("signs", "")
+            ports = []
+
+            for i, sign in enumerate(signs):
+                ports.append(
+                    PortInstance(
+                        name=f"{port_meta.name}{i + 1}",
+                        display_as=sign,
+                        direction="input",
+                        block=instance
+                    )
+                )
+            return ports
+        
+        return super().resolve_port_group(port_meta, direction, instance)