pathsim 0.23.1__tar.gz → 0.23.2__tar.gz

{pathsim-0.23.1 → pathsim-0.23.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.23.1
+Version: 0.23.2
 Summary: A differentiable block based hybrid system simulation framework.
 Author-email: Milan Rother <milan.rother@gmx.de>
 License: MIT

{pathsim-0.23.1 → pathsim-0.23.2}/src/pathsim/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.23.1'
-__version_tuple__ = version_tuple = (0, 23, 1)
+__version__ = version = '0.23.2'
+__version_tuple__ = version_tuple = (0, 23, 2)
 
-__commit_id__ = commit_id = 'gf987e70cf'
+__commit_id__ = commit_id = 'g6079208a8'

{pathsim-0.23.1 → pathsim-0.23.2}/src/pathsim/blocks/rf.py

@@ -18,6 +18,7 @@ from typing import TYPE_CHECKING, TypeVar
 
 try:
     import skrf as rf
+    from skrf.vectorFitting import VectorFitting as _VectorFitting
 
     HAS_SKRF = True
 except ImportError:
@@ -85,12 +86,12 @@ class RFNetwork(StateSpace):
 
         # Select the vector fitting function from scikit-rf
         vf_fun_name = "auto_fit" if auto_fit else "vector_fit"
-        vf_fun = getattr(rf.VectorFitting, vf_fun_name)
+        vf_fun = getattr(_VectorFitting, vf_fun_name)
         # Filter kwargs for the selected vf function
         vf_fun_keys = signature(vf_fun).parameters
         vf_kwargs = {k: v for k, v in kwargs.items() if k in vf_fun_keys}
         # Apply vector fitting
-        vf = rf.VectorFitting(ntwk)
+        vf = _VectorFitting(ntwk)
         getattr(vf, vf_fun_name)(**vf_kwargs)
         A, B, C, D, _ = vf._get_ABCDE()
         # keep a copy of the network and VF
@@ -113,6 +114,6 @@ class RFNetwork(StateSpace):
         s : :py:class:`~numpy.ndarray`
             Complex-valued S-matrices (fxNxN) calculated at frequencies `freqs`.
         """
-        return rf.VectorFitting._get_s_from_ABCDE(
+        return _VectorFitting._get_s_from_ABCDE(
             freqs, self.A, self.B, self.C, self.D, 0
         )

{pathsim-0.23.1 → pathsim-0.23.2}/src/pathsim/solvers/rkf45.py

@@ -15,16 +15,18 @@ from ._rungekutta import ExplicitRungeKutta
 # SOLVERS ==============================================================================
 
 class RKF45(ExplicitRungeKutta):
-    """Runge-Kutta-Fehlberg 4(5) pair. Six stages, 4th order propagation with
-    5th order error estimate.
+    """Runge-Kutta-Fehlberg 5(4) pair. Six stages, 5th order propagation with
+    an embedded 4th order solution for local error estimation (local
+    extrapolation, matching the ``RKCK54`` / ``RKDP54`` convention).
 
     The historically first widely-used embedded pair for automatic step-size
-    control. The 4th order solution is propagated; the difference to the 5th
-    order solution provides a local error estimate.
+    control. The 5th order solution ``b5`` is propagated; the difference to the
+    4th order solution ``b4`` (``TR = b5 - b4``) provides a local error estimate
+    of the lower-order result.
 
     Characteristics
     ---------------
-    * Order: 4 (propagating) / 5 (error estimate)
+    * Order: 5 (propagating) / 4 (error estimate)
     * Stages: 6
     * Explicit, adaptive timestep
 
@@ -63,15 +65,15 @@ class RKF45(ExplicitRungeKutta):
         #intermediate evaluation times
         self.eval_stages = [0.0, 1/4, 3/8, 12/13, 1, 1/2]
 
-        #extended butcher table 
+        #extended butcher table (propagates the 5th order weights b5)
         self.BT = {
             0: [      1/4],
             1: [     3/32,       9/32],
-            2: [1932/2197, -7200/2197,  7296/2197],
-            3: [  439/216,         -8,   3680/513, -845/4104],
-            4: [    -8/27,          2, -3554/2565, 1859/4104, -11/40],
-            5: [   25/216,          0,  1408/2565, 2197/4104,   -1/5, 0]
+            2: [1932/2197, -7200/2197,   7296/2197],
+            3: [  439/216,         -8,    3680/513,  -845/4104],
+            4: [    -8/27,          2,  -3544/2565,  1859/4104,  -11/40],
+            5: [   16/135,          0, 6656/12825, 28561/56430,   -9/50, 2/55]
             }
 
-        #coefficients for local truncation error estimate
+        #coefficients for local truncation error estimate (TR = b5 - b4)
         self.TR = [1/360, 0, -128/4275, -2197/75240, 1/50, 2/55]

{pathsim-0.23.1 → pathsim-0.23.2}/src/pathsim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.23.1
+Version: 0.23.2
 Summary: A differentiable block based hybrid system simulation framework.
 Author-email: Milan Rother <milan.rother@gmx.de>
 License: MIT

pathsim-0.23.2/src/pathsim.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.23.2",
+  "distance": 0,
+  "node": "g6079208a8cee1d89d8a05a5dadc004bb7f5d2f9a",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-04"
+}

{pathsim-0.23.1 → pathsim-0.23.2}/tests/pathsim/blocks/rf/test_rf.py

@@ -69,7 +69,7 @@ class TestOnePort(unittest.TestCase):
         "Test space-state ABCD parameters."
         # ABCD(E) arrays from scikit-rf
         ntwk = rf.data.ring_slot_meas
-        vf = rf.VectorFitting(ntwk)
+        vf = rf.vectorFitting.VectorFitting(ntwk)
         vf.auto_fit()
         A, B, C, D, E = vf._get_ABCDE()
 

{pathsim-0.23.1 → pathsim-0.23.2}/tests/pathsim/solvers/test_rkf45.py

@@ -118,12 +118,28 @@ class TestRKF45(unittest.TestCase):
                     err = np.mean(abs(numerical_solution - analytical_solution))
                     errors.append(err)
 
-                #test if errors are monotonically decreasing
-                self.assertTrue(np.all(np.diff(errors)<0))
-
-                #test convergence order, expected n-1 (global)
-                p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
-                self.assertGreater(p, solver.n-1)
+                errors = np.array(errors)
+                timesteps = np.array(timesteps)
+
+                #restrict the convergence assessment to the region above the
+                #roundoff floor: now that RKF45 propagates the 5th order weights
+                #it drives some reference problems to machine precision at fine
+                #dt, where the error saturates and is no longer a clean power law
+                above_floor = errors > 1e-11
+                errs_fit = errors[above_floor]
+                dts_fit = timesteps[above_floor]
+
+                #test if errors are monotonically decreasing (above the floor)
+                self.assertTrue(np.all(np.diff(errs_fit) < 0))
+
+                #test convergence order (global). A conservative n-2 bound is
+                #used here because the now-5th-order propagation makes a plain
+                #fixed-step fit sensitive to fixture effects on the stiffer
+                #reference problems (rapidly growing higher derivatives near the
+                #blow-up of 1/(1-t) pollute the asymptotic slope). The clean
+                #order fit lives in test_convergence_order_fixed_step.
+                p, _ = np.polyfit(np.log10(dts_fit), np.log10(errs_fit), deg=1)
+                self.assertGreater(p, solver.n-2)
 
             #log stats
             stats[problem.name] = {"n":p, "err":errors, "dt":timesteps}
@@ -137,6 +153,37 @@ class TestRKF45(unittest.TestCase):
         # plt.show()
 
 
+    def test_convergence_order_fixed_step(self):
+
+        #RKF45 propagates the 5th order weights -> fixed-step global convergence
+        #order must be ~5 on a smooth problem. Driven step-by-step to an exact
+        #endpoint (no overshoot) so the fitted slope reflects the tableau order.
+        #x' = x, x(0) = 1  ->  exact x(1) = e.
+        func = lambda x, t: x
+        exact = np.exp(1.0)
+
+        n_steps = [10, 20, 40, 80, 160]
+        dts = [1.0 / n for n in n_steps]
+        errors = []
+        for n in n_steps:
+            solver = RKF45(1.0)
+            solver.reset()
+            t, dt = 0.0, 1.0 / n
+            for _ in range(n):
+                solver.integrate_singlestep(func, time=t, dt=dt)
+                t += dt
+            errors.append(abs(float(np.ravel(solver.x)[0]) - exact))
+
+        #errors must decrease monotonically
+        self.assertTrue(np.all(np.diff(errors) < 0))
+
+        #least-squares order fit must be close to 5 (the pre-fix 4th order
+        #propagation gives ~4; a broken high-order row would give < 4)
+        p, _ = np.polyfit(np.log10(dts), np.log10(errors), deg=1)
+        self.assertGreater(p, 4.6)
+        self.assertLess(p, 5.4)
+
+
     def test_integrate_adaptive(self):
 
         #integrate test problem and assess convergence order

pathsim-0.23.1/src/pathsim.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.23.1",
-  "distance": 0,
-  "node": "gf987e70cf3b1dd9ad4d30810f5590b0600804593",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-06-25"
-}