pathsim 0.2.0__py3-none-any.whl

pathsim/utils/statespacerealizations.py

@@ -0,0 +1,116 @@
+########################################################################################
+##
+##                       METHODS FOR STATESPACE REALIZATIONS
+##                        (utils/statespacerealizations.py)
+##
+##                                Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+
+# STATESPACE REALIZATION ===============================================================
+
+def gilbert_realization(Poles=[], Residues=[], Const=0.0, tolerance=1e-9):
+        
+    """
+    Build real valued statespace model from transfer function 
+    in pole residue form by Gilberts method and an additional 
+    similarity transformation to get fully real valued matrices.
+
+    pole residue form:
+        H(s) = Const + sum( Residues / (s - Poles) )
+    
+    statespace form:
+        H(s) = C * (s*I - A)^-1 * B + D 
+    
+    NOTE :  
+        The resulting system is identical to the so-called 
+        'Modal Form' and is a minimal realization.
+
+    INPUTS : 
+        Poles     : (array) real and complex poles
+        Residues  : (array) array of real and complex residue matrices
+        Const     : (array) matrix for constant term
+        tolerance : (float) relative tolerance for checking real poles
+    """
+
+    #check validity of args
+    if not Poles or not Residues:
+        raise ValueError("No 'Poles' and 'Residues' defined!")
+
+    if len(Poles) != len(Residues):
+        raise ValueError("Same number of 'Poles' and 'Residues' have to be given!")
+
+    #make array
+    Residues = np.asarray(Residues)
+
+    #check shape of residues for MIMO, etc
+    if Residues.ndim == 1:
+        N, m, n = Residues.size, 1, 1
+        Residues = np.reshape(Residues, (N, m, n))
+    elif Residues.ndim == 2:
+        N, m, n = *Residues.shape, 1
+        Residues = np.reshape(Residues, (N, m, n))
+    elif Residues.ndim == 3:
+        N, m, n = Residues.shape
+    else:
+        raise ValueError(f"shape mismatch of 'Residues': Residues.shape={Residues.shape}")
+
+    # #dimension checks for residue matrices
+    # if isinstance(Residues, (list, tuple)) or Residues.size == len(Residues):
+    #     Residues = np.reshape(Residues, (len(Residues), 1, 1))
+
+    # #get dimensions for MIMO
+    # N, m, n = Residues.shape
+
+    #initialize companion matrix
+    a = np.zeros((N, N))
+    b = np.zeros(N)
+        
+    #residues
+    C = np.ones((m, n*N))
+    
+    #go through poles and handle conjugate pairs
+    _Poles, _Residues = [], []
+    for p, R in zip(Poles, Residues):
+
+        #real pole
+        if np.isreal(p) or abs(np.imag(p) / np.real(p)) < tolerance:
+            _Poles.append(p.real)
+            _Residues.append(R.real)
+
+        #complex conjugate pair
+        elif np.imag(p) > 0.0:
+            _Poles.extend([p, np.conj(p)])
+            _Residues.extend([R, np.conj(R)])
+
+    #build real companion matrix from the poles
+    p_old = 0.0
+    for k, (p, R) in enumerate(zip(_Poles, _Residues)):
+        
+        #check if complex conjugate
+        is_cc = (p.imag != 0.0 and p == np.conj(p_old))
+        p_old = p
+        
+        a[k,k] = np.real(p)
+        b[k] = 1.0
+        if is_cc:
+            a[k, k-1] = - np.imag(p)
+            a[k-1, k] = np.imag(p)
+            b[k]   = 0.0
+            b[k-1] = 2.0
+            
+        #iterate columns of residue
+        for i in range(n):
+            C[:,k+N*i] = np.imag(R[:,i]) if is_cc else np.real(R[:,i])  
+                
+    #build block diagonal
+    A = np.kron(np.eye(n, dtype=float), a)
+    B = np.kron(np.eye(n, dtype=float), b).T
+    D = Const
+
+    return  A, B, C, D

pathsim/utils/waveforms.py

@@ -0,0 +1,36 @@
+########################################################################################
+##
+##                              WAVEFORM FUNCTIONS (utils/waveforms.py)
+##
+##                                   Milan Rother 2023/24
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+
+# WAVEFORMS ============================================================================
+
+def gaussian(t, f_max):
+    """
+    gaussian pulse with its maximum at t=0
+    """
+    tau = 0.5 / f_max
+    return np.exp(-(t/tau)**2)
+
+
+def triangle_wave(t, f):
+    """
+    triangle wave with amplitude '1' and frequency 'f'
+    """
+    return 2 * abs(t*f - np.floor(t*f + 0.5)) - 1
+
+
+def square_wave(t, f):
+    """
+    square wave with amplitude '1' and frequency 'f'
+    """
+    return np.sign(np.sin(2*np.pi*f*t))
+

pathsim-0.2.0.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Milan Rother
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pathsim-0.2.0.dist-info/METADATA

@@ -0,0 +1,149 @@
+Metadata-Version: 2.1
+Name: pathsim
+Version: 0.2.0
+Summary: A block based time domain system simulation framework.
+Home-page: https://github.com/milanofthe/pathsim
+Author: Milan Rother
+Author-email: milan.rother@gmx.de
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+
+# PathSim: A Time-Domain System Simulation Framework
+
+
+## Overview
+
+PathSim is a minimalistic and flexible block-based time-domain system simulation framework in Python. It provides a modular and intuitive approach to modeling and simulating complex dynamical systems using a directed computational graph. It is similar to Matlab Simulink in spirit but works very differently under the hood.
+
+Key features of PathSim include:
+
+- Decentralized architecture where each dynamical block has their own numerical integration engine.
+- The system is solved directly on the computational graph instead of compiling a unified differential algebraic system.
+- This has some advantages such as hot-swappable blocks during simulation and reading simulation results directly from the scopes.
+- The block execution is decoupled from the data transfer, which enables parallelization (future) and linear computational complexity scaling for sparsely connected systems.
+- Support for MIMO (Multiple Input, Multiple Output) blocks, enabling the creation of complex interconnected system topologies.
+- Fixed-point iteration approach with path length estimation to efficiently resolve algebraic loops.
+- Wide range of numerical solvers, including implicit and explicit multi-stage, and adaptive Runge-Kutta methods such as `RKDP54` or `ESDIRK54`.
+- Modular and hierarchical modeling with (nested) subsystems.
+- Library of pre-defined blocks, including mathematical operations, integrators, delays, transfer functions, and more.
+- Easy extensibility, allowing users to define custom blocks by subclassing the base `Block` class and implementing just a handful of methods.
+
+
+
+## Installation
+
+Version `0.1.0` of pathsim is pip installable
+
+```console
+$ pip install pathsim
+```
+
+## Getting Started
+
+To get started with PathSim, you need to import the necessary modules and classes. The main components of the package are:
+
+- `Simulation`: The main class that handles the blocks, connections, and the simulation loop.
+- `Connection`: The class that defines the connections between blocks.
+- Various block classes from the `blocks` module, such as `Integrator`, `Amplifier`, `Adder`, `Scope`, etc.
+
+Here's an example that demonstrates how to create a basic simulation. 
+In this example, we create a simulation of the harmonic oscillator (a spring mass damper 2nd order system) initial value problem. The ODE that defines it is give by
+
+$$
+\ddot{x} + \frac{c}{m} \dot{x} + \frac{k}{m} x = 0
+$$
+
+where $c$ is the damping, $k$ the spring constant and $m$ the mass.
+
+It can be translated to a block diagram using integrators, amplifiers and adders in the following way:
+
+![png](README_files/harmonic_oscillator_blockdiagram.png)
+
+The topology of the block diagram above can be directly defined as blocks and connections in the PathSim framework. First we initialize the blocks needed to represent the dynamical systems with their respective arguments such as initial conditions and gain values, then the blocks are connected using `Connection` objects, forming two feedback loops. The `Simulation` instance manages the blocks and connections and advances the system in time with the timestep (`dt`). The `log` flag for logging the simulation progress is also set. Finally, we run the simulation for some number of seconds and plot the results using the `plot()` method of the scope block.
+
+
+
+```python
+from pathsim import Simulation
+from pathsim import Connection
+from pathsim.blocks import Integrator, Amplifier, Adder, Scope
+from pathsim.solvers import SSPRK22  # 2nd order fixed timestep, this is also the default
+
+#initial position and velocity
+x0, v0 = 2, 5
+
+#parameters (mass, damping, spring constant)
+m, c, k = 0.8, 0.2, 1.5
+
+# Create blocks 
+I1 = Integrator(v0)   # integrator for velocity
+I2 = Integrator(x0)   # integrator for position
+A1 = Amplifier(-c/m)
+A2 = Amplifier(-k/m)
+P1 = Adder()
+Sc = Scope(labels=["v(t)", "x(t)"])
+
+blocks = [I1, I2, A1, A2, P1, Sc]
+
+# Create connections
+connections = [
+    Connection(I1, I2, A1, Sc),   # one to many connection
+    Connection(I2, A2, Sc[1]),
+    Connection(A1, P1),           # default connection to port 0
+    Connection(A2, P1[1]),        # specific connection to port 1
+    Connection(P1, I1)
+    ]
+
+# Create a simulation instance from the blocks and connections
+Sim = Simulation(blocks, connections, dt=0.05, log=True, Solver=SSPRK22)
+
+# Run the simulation for 50 seconds
+Sim.run(duration=50.0)
+
+# Plot the results directly from the scope
+Sc.plot()
+
+# Read the results from the scope for further processing
+time, data = Sc.read()
+```
+
+    2024-08-30 14:20:10,361 - INFO - LOGGING enabled
+    2024-08-30 14:20:10,362 - INFO - SOLVER SSPRK22 adaptive=False implicit=False
+    2024-08-30 14:20:10,363 - INFO - PATH LENGTH ESTIMATE 2, 'iterations_min' set to 2
+    2024-08-30 14:20:10,364 - INFO - RESET
+    2024-08-30 14:20:10,365 - INFO - RUN duration=50.0
+    2024-08-30 14:20:10,366 - INFO - STARTING progress tracker
+    2024-08-30 14:20:10,367 - INFO - progress=0%
+    2024-08-30 14:20:10,400 - INFO - progress=10%
+    2024-08-30 14:20:10,429 - INFO - progress=20%
+    2024-08-30 14:20:10,455 - INFO - progress=30%
+    2024-08-30 14:20:10,480 - INFO - progress=40%
+    2024-08-30 14:20:10,504 - INFO - progress=50%
+    2024-08-30 14:20:10,528 - INFO - progress=60%
+    2024-08-30 14:20:10,553 - INFO - progress=70%
+    2024-08-30 14:20:10,578 - INFO - progress=80%
+    2024-08-30 14:20:10,603 - INFO - progress=90%
+    2024-08-30 14:20:10,628 - INFO - progress=100%
+    2024-08-30 14:20:10,629 - INFO - FINISHED steps(total)=1001(1001) runtime=262.03ms
+    
+
+
+    
+![png](README_files/README_4_1.png)
+    
+
+
+## Examples
+There are many examples of dynamical system simulations in the `examples` directory. They cover almost all the blocks currently available in PathSim as well as different solvers.
+
+
+```python
+
+```

pathsim-0.2.0.dist-info/RECORD

@@ -0,0 +1,109 @@
+pathsim/__init__.py,sha256=aNopp-VEK5mypHRIE4qipa09lb1_JxxLpObMLhc8GbM,115
+pathsim/connection.py,sha256=UtQrC1xXpA--Yub9e04BXHrz4HXTtV9AfyfMRin3FLQ,3801
+pathsim/simulation.py,sha256=tkZwrvJqGIgId9AosHILWatWAufdE1pzJGuokb78aMo,24663
+pathsim/subsystem.py,sha256=yBGL6127V4K2K_hdQ1r8sCACrUBM2QL315MKaoO4NoQ,9228
+pathsim/blocks/__init__.py,sha256=Hgb2olVDbPwuZUAhD9IDQENs-FecIU3_vugXqfcPd84,312
+pathsim/blocks/_block.py,sha256=WDcDjXBpgz4d7PDMfBCrYKURu_ERvgtxBvRM7T8qU-U,7477
+pathsim/blocks/adder.py,sha256=eDs33MtJ-ASBQuNRELCD4ygh8Ftjlp3dp6kO163X-5c,940
+pathsim/blocks/amplifier.py,sha256=8iYUf0-hyqLgynS5eewAOX7Z5E_cvx0WvXWng3h0ryY,1033
+pathsim/blocks/delay.py,sha256=Od1DhvdFQ3qHRMip-5d_oG_j1CNqfiMG9V-TgNO1Owo,1735
+pathsim/blocks/differentiator.py,sha256=jKXi-xoOS0nUW8sqg1EwXQO-exOFlI2vor3swcP48Oc,2358
+pathsim/blocks/function.py,sha256=zIjzqM8uaX6iHcpM6yuZxmQyAVwi4wXlhFH1RBj8FWE,2643
+pathsim/blocks/integrator.py,sha256=LHYScbLK4ngLy1KW7PddLp833Sxy2Z-IuF13ox8I870,1994
+pathsim/blocks/lti.py,sha256=rn_TL56YAuQdmRnK8AmY-zhA9SW1xrf0-FSQCitmJi4,5018
+pathsim/blocks/multiplier.py,sha256=wkij46eZmBPyL7xgJtg9NIsedUQU5IwcnGGq9387A-0,962
+pathsim/blocks/ode.py,sha256=YsI0yJkPL6UX9DvcO0_8S8It_W1HDNrtp2bigbThbfA,2734
+pathsim/blocks/rng.py,sha256=SQ8il4MMyHIu7P_-vfRUYp6qtvpb6PvEuq5cX3glT6A,1569
+pathsim/blocks/scope.py,sha256=OhrJSGq6hrQ_Kswobt7XBWYjsXh6I5gn31jHnhWQrPM,7619
+pathsim/blocks/sources.py,sha256=Xq9AGFnS63Lpot75XyD3018_yy5Dwu3Sh81sEH0KdtM,1879
+pathsim/blocks/spectrum.py,sha256=G5ByuLKYG5dHLV5NbQEIQrzSLIoCp-FiZ_hXUo4Ti3A,10737
+pathsim/blocks/rf/__init__.py,sha256=h1cuLIIy5XhMyumLFzbIdOEMOJbpXHMQcl2oB1wapsE,102
+pathsim/blocks/rf/filters.py,sha256=ccJgJZIPWz9jRUgTEyl_aMHA-PePPxnSa2-ufa12RCk,5143
+pathsim/blocks/rf/noise.py,sha256=zvTDlIbja6TybavSrSGgRHAPqQkdwpjtuoenCV6YAro,6645
+pathsim/blocks/rf/sources.py,sha256=HNS-GxIX2LMi8KwuOLCIquhQL5ZoMrgYU6vhQhAL9vA,4227
+pathsim/blocks/rf/wienerhammerstein.py,sha256=19Tx7woy9COXWR-ruhLnN6UqZSMaB8RDe_PylrPKHwA,11326
+pathsim/solvers/__init__.py,sha256=H3pyfkEdIGstc4kxx2F6jdnV5X5atnsipKiP_1ssyy4,470
+pathsim/solvers/_solver.py,sha256=VW5Q_TNMzwCsYBfg2B-BUVm-MnRYHc0QxGNHLTgVLSY,14480
+pathsim/solvers/bdf.py,sha256=McuDCILt-U_Edy-LqICfjF9xRJohy8nho-AGalTSFCA,6620
+pathsim/solvers/dirk2.py,sha256=k_ALjWE0t2cF17ef5CBX6lwDcAR6wM3QUMdiv6dHo9E,3122
+pathsim/solvers/dirk3.py,sha256=xh0G_rpAvK54ySL6ltTg6UU7vJl4PxY9UKx6MEQgF9c,2576
+pathsim/solvers/esdirk32.py,sha256=Pgg-aYc82nS7J730ooPPgiX3tn6wdvTfDvL9LIaEkIw,3983
+pathsim/solvers/esdirk4.py,sha256=slSmpxpKVNo5VN1RzlYS-82JLkQAvydRUO6DaOARcLs,3147
+pathsim/solvers/esdirk43.py,sha256=9kzFABruWzO8aA2CBrIBoiTNPyN-FE_MBVUtuZwgXgo,4938
+pathsim/solvers/esdirk54.py,sha256=ph8GmoQVanv8UVBgnIMKcPBad5LpMDuWcXYU4vifdCg,5475
+pathsim/solvers/esdirk85.py,sha256=aqc3ckoTgc7_La7CVVaPJB0y2Wr2wv7erfI4hqcSbpA,9110
+pathsim/solvers/euler.py,sha256=Yjg8wsrksioKzPqn545-alNUNcbFnyjEb_KxMN1eOCU,2479
+pathsim/solvers/rk4.py,sha256=GLjSPPp78TbpLd9OnfmvwSiFVHspXK6L5eBcxtY7UDE,1887
+pathsim/solvers/rkbs32.py,sha256=J5PNFRBAIpcEf7PqFeENqhvErhKCVD8aAT_MTL0Oo88,3333
+pathsim/solvers/rkck54.py,sha256=TwS9REaREnYFjdU0JLgyh7ONKDH7s7cP_kTL1aQVF6c,3930
+pathsim/solvers/rkdp54.py,sha256=403usE-QTRsF6dD8fyyRvwNUfrcril1CrwsDEIsNdq0,3894
+pathsim/solvers/rkdp87.py,sha256=2tVLmZDiCOKiM-8Z6gk7K7qSCP18mWE8zrthtdNjJXc,5142
+pathsim/solvers/rkf45.py,sha256=M_B1MADPNCZp46oMXzXjlfpAU8RNyqExfXEGpxrJo0Y,3386
+pathsim/solvers/rkf78.py,sha256=oHa56fT6Xb9WzH1DZp-_YAIu-tfDYNSCaEkAjur0Rc8,4345
+pathsim/solvers/rkv65.py,sha256=8md24OudOk-ndaryz3vxZ4OoQhM_DzEQuJDToyllLZE,3909
+pathsim/solvers/ssprk22.py,sha256=fn4zdq4SJTihxWP2UTNFGCGlnDCDrIlijPF4Slp9G9g,2032
+pathsim/solvers/ssprk33.py,sha256=hFs0LG8IFZEj2TTpmrOx5XUos21sQplBIoOQ8GKHFew,2131
+pathsim/solvers/ssprk34.py,sha256=OyzhJ9yN3bzrG8Nc1b8kJs3SJaKhvH6If7wA9aNzM0U,2428
+pathsim/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pathsim/utils/adaptivebuffer.py,sha256=W6NDevnerPgZVBqA3ROwHJ_3ml3dCkwBABU0ZKY-pxE,2478
+pathsim/utils/anderson.py,sha256=7q6GmWE41YeWTSmVY7xlq9LlkvL-97NoEMeGP-UHkRs,5315
+pathsim/utils/funcs.py,sha256=dzJxy3xNRpyrO1ioqUfVYKcpTXvbUtTIVt4zbyykqZ0,6341
+pathsim/utils/gilbert.py,sha256=YlH7T3UiCbObwoAP9N9lTRCzEcJc7WHwApcSh7ohmGU,3596
+pathsim/utils/progresstracker.py,sha256=hRHB0--W9yGubBS99GqrUHDIjIwyV0F9MMU3miM_FEc,2894
+pathsim/utils/realtimeplotter.py,sha256=zGEDzz1OgxIpSe3_1xaZZe8Y7YAoYqYwFkrUNE0w5VI,7595
+pathsim/utils/statespacerealizations.py,sha256=uZpmwsJBCgUBvpdkZK56Lql9u-Ijee7xUdqM2LNpT8Y,3815
+pathsim/utils/waveforms.py,sha256=9EkhL0BEfu69ggsd72S7XnnQryk4kzw5ZKaktKSjXNg,974
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_connection.py,sha256=ThI58KrwjtuGegz1aUkLOX6uOomp8o2enutbBUX8hcU,5026
+tests/test_simulation.py,sha256=UoKyKZ69cooUrLk4j2Rvws7SM-2P_CvSLxOgoz_Fixk,8890
+tests/test_subsystem.py,sha256=mSqirgFVFhqsdNMeeRiU38cFoVygK-wTPn3CrKdIANc,5185
+tests/blocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/blocks/test_adder.py,sha256=uKAKpPcJFRGaKtvfVbWf4xNUJRSKAPALZNk14EPcUww,1993
+tests/blocks/test_amplifier.py,sha256=GAwiiZ2klXNK90BWZOk7x_YktAvRSeAnTWgDbrSbCBU,1609
+tests/blocks/test_block.py,sha256=xl49c_fbdrHGdRilu4ZZBlQnUlg5iWWXtzub_JYJ3q0,3164
+tests/blocks/test_delay.py,sha256=BZuTgTC698Tp9y1YWSay6E62jHqa8IZjSo03fvQa6ZM,2861
+tests/blocks/test_differentiator.py,sha256=Y7vNdgo8bfRCSr0eXAwwBbs32UsYKllmiMwksdOubWU,2611
+tests/blocks/test_function.py,sha256=Fkez0YE7RJZ1Ze5pJhm41zc528E10r467wz6kjLIPGc,3776
+tests/blocks/test_integrator.py,sha256=UcIWZsqTsSRva1KklIVtaM8Mu27kg3NrvH6aQibDFrQ,2388
+tests/blocks/test_lti.py,sha256=jUhBQz5VUdVN3FwTPt8RT7wz9RBcbUQNEJILMw1XRQ8,4995
+tests/blocks/test_multiplier.py,sha256=V_FOVv7xX9MMB9SC_6xu1POz-czM-1E_w5oCcsQPbzw,2047
+tests/blocks/test_ode.py,sha256=kWvx20ZBOJ6EN8yBieM4HQTZM7tvAJ-aR-P8JvhA_b8,3528
+tests/blocks/test_rng.py,sha256=IekE8IQguWxq3Npmhfew9Ai2on1cJZxuypsNTll8XEI,2523
+tests/blocks/test_scope.py,sha256=JP7VHD3d_gB3Bfq8t0ytHOnR4JO87epRcWSOicpxSQc,4710
+tests/blocks/test_sources.py,sha256=4NBDeTASUYRgi1XxMULxdErl4XDIuBgWyekXEVlopyA,2733
+tests/blocks/test_spectrum.py,sha256=Yqo9wk11LxTbjj8IM6Um2UaFQiafpPwwo-P7RYe3MX0,3410
+tests/solvers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/solvers/test_bdf.py,sha256=C7odQHrPyJbQaBoBA7d4V9efUX4zTmEApt-vA77ltB8,10430
+tests/solvers/test_dirk2.py,sha256=g4Rt8XBTRMCvD85lj9xpz5t3z4AeZUJf5uj_CZlVCF8,4170
+tests/solvers/test_dirk3.py,sha256=Wdpky5iPwV3V9Fd3wWTlX3HkRZ1T38R-bzI4LeDp31A,4165
+tests/solvers/test_esdirk32.py,sha256=iwf24nhfMBaJM2B0K9JH6et5vMFLtmqxPvjsZ2-XxYg,4976
+tests/solvers/test_esdirk4.py,sha256=QxQjcSjA7aq6BfuCNqhJZswsAd5GkBO1fj79ukYLzT0,4203
+tests/solvers/test_esdirk43.py,sha256=Ugn2ib1o27J9gUxH1monA-92zFbmCTeUAgbkL_Mnn60,4978
+tests/solvers/test_esdirk54.py,sha256=DkLUVx2_lQJlhN8NVc4ZcpV1aL_qi1q-BEOMklYz8aw,4944
+tests/solvers/test_esdirk85.py,sha256=FwtN1JVVQAQ77sIEVbwGamC6hhBEWNLlYWYtPqZoAvU,4939
+tests/solvers/test_euler.py,sha256=Xo2unPh3zUMobIiPDwwK7aa8YhiLhUoYCvJ0FCjKqZo,6594
+tests/solvers/test_rk4.py,sha256=eXWT26GH-zkVEdrlHT8mY3VeHpZzgXwVf0BptbcQVjQ,4064
+tests/solvers/test_rkbs32.py,sha256=fxwR3B3QxZuXr4QuA4VPrlGQ8Nj2HHr95_aUpXrrMIY,4870
+tests/solvers/test_rkck54.py,sha256=ePNJyz3X7H9L0j1qlFkX8CEDCSsOeu2IVXzoR8WRqZs,4825
+tests/solvers/test_rkdp54.py,sha256=7FeMOEMRZ4UKzkkOZP48HkfScw08ehXNTcBkjz2ggxo,4823
+tests/solvers/test_rkdp87.py,sha256=Mq0Djn234qkWQ1WekbpAeXM-UAzJuA_FhTsnaopEgDA,4818
+tests/solvers/test_rkf45.py,sha256=npa3eLtV2AGIsJhR_zuULQE4PQFs36oXVS7qQ02waC0,4818
+tests/solvers/test_rkf78.py,sha256=Tx2aNewCbq3n8kXG4cct6a2609qByR4eZIXnKA2b_Po,4818
+tests/solvers/test_rkv65.py,sha256=OLlIwxrWL2h3XnXJWnKJP9yh7nse0VXewiBfvwzdgaY,4822
+tests/solvers/test_solver.py,sha256=z_GkWx5svV4Ro-fAzyG2Y-VBLBd-o0lmGTgQo2TNMVM,3668
+tests/solvers/test_ssprk22.py,sha256=OzFKnVw52VnZa0xfTVIpJqOFwhpELsutoFSg5ruNdx8,4098
+tests/solvers/test_ssprk33.py,sha256=o3zIGs1d9DU1FgNtgIs576Mg0TAv8IJEBKNQJafb1y0,4098
+tests/solvers/test_ssprk34.py,sha256=QUs4UlCGUlLRUXf1qFI-yAAtw5SU30lLiGzfMo12wB8,4110
+tests/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/utils/test_adaptivebuffer.py,sha256=EC8sTZne89ta8e2H7zQSAr7tm14KMS19VWHm2VN-GxQ,2461
+tests/utils/test_anderson.py,sha256=JGm_6sC87yt19BWpfUO3S7Wk4Gvo8i7PFzYKpQHEmCw,4726
+tests/utils/test_funcs.py,sha256=Tfru6dz3M0RWay7iTws_B7NF9a4Tjz3Hll23Q4DXviI,4884
+tests/utils/test_gilbert.py,sha256=cS0vJ-g9gdNDrRgP2TsHywJTdHeTxCfVy_5VWjgTrbQ,4428
+tests/utils/test_progresstracker.py,sha256=zfcC2eT9_cs9adP-ep5BYl4yq0dCrJwE-ynh-bN6eM0,4240
+tests/utils/test_realtimeplotter.py,sha256=Nm4RKxWvhjHgQ6NYjoNHwEQ32tZosqhESLQagbdi81w,4222
+tests/utils/test_statespacerealizations.py,sha256=-wRawEUVWAdB7TpElxIZcn887n_W7VqcFZn51HPDh4I,4410
+pathsim-0.2.0.dist-info/LICENSE.txt,sha256=SeKo1Ftp8_Vx3X1M1PvMci7qvSH7uP1E7E03KDoe91g,1088
+pathsim-0.2.0.dist-info/METADATA,sha256=zG4r2JYWoc9Ic9DdQNLD1r3wQ5GvIPsHDI58HfU-i5w,6524
+pathsim-0.2.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+pathsim-0.2.0.dist-info/top_level.txt,sha256=9VWhDKMqa75oeoSg49FLkQozQcozHLWUVX4aERkO40g,14
+pathsim-0.2.0.dist-info/RECORD,,

pathsim-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pathsim-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+pathsim
+tests

tests/blocks/test_adder.py

@@ -0,0 +1,85 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                               'blocks.adder.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.adder import Adder
+
+
+# TESTS ================================================================================
+
+class TestAdder(unittest.TestCase):
+    """
+    Test the implementation of the 'Adder' block class
+    """
+
+    def test_str(self):
+
+        A = Adder()
+
+        #test default str method
+        self.assertEqual(str(A), "Adder")
+
+
+    def test_update_single(self):
+        
+        A = Adder()
+
+        #set block inputs
+        A.set(0, 1)
+
+        #update block
+        err = A.update(None)
+
+        #test if update was correct
+        self.assertEqual(A.get(0), 1)
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = A.update(None)
+
+        #test error, now should be 0
+        self.assertEqual(err, 0)
+
+
+    def test_update_multi(self):
+
+        A = Adder()
+
+        #set block inputs
+        A.set(0, 1)
+        A.set(1, 2.0)
+        A.set(2, 3.1)
+
+        #update block
+        err = A.update(None)
+
+        #test if update was correct
+        self.assertEqual(A.get(0), 6.1)
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = A.update(None)
+
+        #test error, now should be 0
+        self.assertEqual(err, 0)
+
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_amplifier.py

@@ -0,0 +1,66 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                            'blocks.amplifier.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.amplifier import Amplifier
+
+
+# TESTS ================================================================================
+
+class TestAmplifier(unittest.TestCase):
+    """
+    Test the implementation of the 'Amplifier' block class
+    """
+
+    def test_init(self):
+
+        A = Amplifier(gain=5)
+
+        self.assertEqual(A.gain, 5)
+
+
+    def test_str(self):
+
+        A = Amplifier()
+
+        #test default str method
+        self.assertEqual(str(A), "Amplifier")
+
+
+    def test_update(self):
+        
+        A = Amplifier(gain=5)
+
+        #set block inputs
+        A.set(0, 1)
+
+        #update block
+        err = A.update(None)
+
+        #test if update was correct
+        self.assertEqual(A.get(0), 5)
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = A.update(None)
+
+        #test error, now should be 0
+        self.assertEqual(err, 0)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)