pathsim 0.26.0__tar.gz → 0.27.1__tar.gz

{pathsim-0.26.0 → pathsim-0.27.1}/PKG-INFO

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

{pathsim-0.26.0 → pathsim-0.27.1}/src/pathsim/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.26.0'
-__version_tuple__ = version_tuple = (0, 26, 0)
+__version__ = version = '0.27.1'
+__version_tuple__ = version_tuple = (0, 27, 1)
 
-__commit_id__ = commit_id = 'g7c5a82fa9'
+__commit_id__ = commit_id = 'ga4e824de2'

{pathsim-0.26.0 → pathsim-0.27.1}/src/pathsim/blocks/dae.py

@@ -51,7 +51,10 @@ class SemiExplicitDAE(Block):
         \\dot{x} = f_\\mathrm{dyn}(x, z(x, u, t), u, t)
 
     to the integration engine, so the DAE integrates with any solver, explicit
-    or implicit. The block output is the stacked state :math:`[x, z]`.
+    or implicit. The block output is the stacked state :math:`[x, z]`, or
+    :math:`y = f_\\mathrm{out}(x, z, u, t)` if an output function is supplied.
+    Without algebraic states (empty `z0`) the block reduces to a plain ODE and
+    the constraint solve is skipped.
 
     Note
     ----
@@ -126,6 +129,9 @@ class SemiExplicitDAE(Block):
         convergence tolerance on the residual norm of the algebraic constraint
         solve, loosen it for ill-conditioned constraints whose residual cannot
         reach the default due to roundoff
+    func_out : callable, None
+        optional output function with signature `func_out(x, z, u, t)`, the
+        block output is the stacked state `[x, z]` if `None`
 
     Attributes
     ----------
@@ -148,7 +154,8 @@ class SemiExplicitDAE(Block):
         jac_dyn_x=None,
         jac_dyn_z=None,
         jac_alg_x=None,
-        tolerance=SOL_TOLERANCE_FPI
+        tolerance=SOL_TOLERANCE_FPI,
+        func_out=None
         ):
 
         super().__init__()
@@ -157,6 +164,9 @@ class SemiExplicitDAE(Block):
         self.func_dyn = func_dyn
         self.func_alg = func_alg
 
+        #optional output function, stacked state [x, z] if 'None'
+        self.func_out = func_out
+
         #convergence tolerance of the algebraic constraint solve
         self.tolerance = tolerance
 
@@ -187,9 +197,10 @@ class SemiExplicitDAE(Block):
         self.op_dyn = DynamicOperator(func=self._rhs, jac_x=_jac_x)
 
         #pre-size the output register to the stacked state [x, z]
-        self.outputs.update_from_array(
-            np.concatenate([self.initial_value, self.z0])
-            )
+        if self.func_out is None:
+            self.outputs.update_from_array(
+                np.concatenate([self.initial_value, self.z0])
+                )
 
 
     def __len__(self):
@@ -204,10 +215,11 @@ class SemiExplicitDAE(Block):
         """
         super().reset()
         self._z = self.z0.copy()
-        x = self.engine.state if self.engine else self.initial_value
-        self.outputs.update_from_array(
-            np.concatenate([np.atleast_1d(x), self._z])
-            )
+        if self.func_out is None:
+            x = self.engine.state if self.engine else self.initial_value
+            self.outputs.update_from_array(
+                np.concatenate([np.atleast_1d(x), self._z])
+                )
 
 
     def _solve_z(self, x, u, t):
@@ -229,6 +241,10 @@ class SemiExplicitDAE(Block):
         z : array[float]
             algebraic states satisfying the constraint
         """
+        #nothing to solve without algebraic states
+        if self._z.size == 0:
+            return self._z
+
         _func = lambda z: self.func_alg(x, z, u, t)
         _jac = None if self.jac_z is None else (lambda z: self.jac_z(x, z, u, t))
         z, _, _ = solve_root(self.opt, _func, self._z, _jac, tolerance=self.tolerance)
@@ -277,6 +293,8 @@ class SemiExplicitDAE(Block):
         """
         z = self._solve_z(x, u, t)
         fx = np.atleast_2d(self.jac_dyn_x(x, z, u, t))
+        if z.size == 0:
+            return fx
         fz = np.atleast_2d(self.jac_dyn_z(x, z, u, t))
         gx = np.atleast_2d(self.jac_alg_x(x, z, u, t))
         gz = np.atleast_2d(self.jac_z(x, z, u, t))
@@ -285,7 +303,7 @@ class SemiExplicitDAE(Block):
 
     def update(self, t):
         """Eliminate the algebraic states for the current input and expose the
-        stacked state [x, z] at the output.
+        output function, or the stacked state [x, z], at the output.
 
         Parameters
         ----------
@@ -294,9 +312,11 @@ class SemiExplicitDAE(Block):
         """
         x, u = self.engine.state, self.inputs.to_array()
         self._z = self._solve_z(x, u, t)
-        self.outputs.update_from_array(
-            np.concatenate([np.atleast_1d(x), self._z])
-            )
+        if self.func_out is None:
+            y = np.concatenate([np.atleast_1d(x), self._z])
+        else:
+            y = self.func_out(x, self._z, u, t)
+        self.outputs.update_from_array(y)
 
 
     def solve(self, t, dt):
@@ -474,20 +494,54 @@ class MassMatrixDAE(Block):
                 )
         self._x0 = x0
 
-        #partition into differential (nonzero row) and algebraic (zero row) states
-        _nonzero_row = np.any(M != 0.0, axis=1)
-        self._d = np.flatnonzero(_nonzero_row)
-        self._a = np.flatnonzero(~_nonzero_row)
+        #partition into differential (nonzero column) and algebraic (zero column) states
+        _nonzero_column = np.any(M != 0.0, axis=0)
+        self._d = np.flatnonzero(_nonzero_column)
+        self._a = np.flatnonzero(~_nonzero_column)
+
+        #partition into differential (nonzero row) and algebraic (zero row) equations
+        _non_zero_rows = np.any(M != 0.0, axis=1)
+        self._d_equations = np.flatnonzero(_non_zero_rows)
+        self._a_equations = np.flatnonzero(~_non_zero_rows)
 
         #index-1 form: differential rows must not weight algebraic derivatives
-        if self._a.size and np.any(M[np.ix_(self._d, self._a)] != 0.0):
+        if self._a.size and np.any(M[np.ix_(self._d_equations, self._a)] != 0.0):
             raise ValueError(
                 "mass matrix is not in index-1 form: differential rows couple "
                 "to the derivatives of algebraic states"
                 )
 
-        #LU factorisation of the (constant) differential mass block
-        self._lu = lu_factor(M[np.ix_(self._d, self._d)])
+        #factorise the constant differential mass block when it is square; use
+        #the pseudoinverse for rectangular reduced systems so underdetermined
+        #differential blocks still admit a minimum-norm solution.
+        self._d_mass = M[np.ix_(self._d_equations, self._d)]
+        if self._d_mass.shape[0] == self._d_mass.shape[1]:
+            self._lu = lu_factor(self._d_mass)
+            self._solve_mass_rhs = lambda rhs: lu_solve(self._lu, rhs)
+            self._solve_mass_matrix = lambda mat: lu_solve(self._lu, mat)
+        else:
+            # Use SVD once and apply the pseudoinverse implicitly for stability
+            # and to avoid forming a dense pseudoinverse matrix.
+            U, s, Vt = np.linalg.svd(self._d_mass, full_matrices=False)
+            eps = np.finfo(float).eps
+            tol = max(self._d_mass.shape) * (s.max() if s.size else 0.0) * eps
+            s_inv = np.array([1.0/si if si > tol else 0.0 for si in s])
+
+            # store factors (optional) and set solver callables
+            self._svd_U = U
+            self._svd_s_inv = s_inv
+            self._svd_Vt = Vt
+
+            def _solve_mass_rhs(rhs):
+                # rhs can be vector or matrix; apply V * S_inv * (U.T @ rhs)
+                return (Vt.T * s_inv) @ (U.T @ rhs)
+
+            def _solve_mass_matrix(mat):
+                # mat: matrix of columns to be solved
+                return (Vt.T * s_inv) @ (U.T @ mat)
+
+            self._solve_mass_rhs = _solve_mass_rhs
+            self._solve_mass_matrix = _solve_mass_matrix
 
         #the engine integrates only the differential states
         self.initial_value = x0[self._d]
@@ -503,7 +557,9 @@ class MassMatrixDAE(Block):
         #when 'jac' is given, otherwise the operator falls back to finite differences
         _jac_x = None
         if self._a.size == 0 and jac is not None:
-            _jac_x = lambda x, u, t: lu_solve(self._lu, np.atleast_2d(jac(x, u, t)))
+            def _jac_x(x, u, t):
+                J = np.atleast_2d(jac(x, u, t))[np.ix_(self._d_equations, self._d)]
+                return self._solve_mass_matrix(J)
         self.op_dyn = DynamicOperator(func=self._rhs, jac_x=_jac_x)
 
         #pre-size the output register to the full state
@@ -609,7 +665,7 @@ class MassMatrixDAE(Block):
             xa = self._solve_xa(x_d, u, t)
             x = np.empty(self.mass.shape[0])
             x[self._d], x[self._a] = x_d, xa
-        return lu_solve(self._lu, self.func(x, u, t)[self._d])
+        return self._solve_mass_rhs(self.func(x, u, t)[self._d_equations])
 
 
     def update(self, t):
@@ -646,7 +702,8 @@ class MassMatrixDAE(Block):
 
         #commit the warm-start at the current state, then linearize around it
         self._xa = self._solve_xa(x_d, u, t)
-        f = lu_solve(self._lu, self.func(self._full(x_d), u, t)[self._d])
+        f = self._solve_mass_rhs(self.func(self._full(x_d), u, t)[self._d_equations])
+
         J = self.op_dyn.jac_x(x_d, u, t)
 
         return self.engine.solve(f, J, dt)
@@ -673,7 +730,7 @@ class MassMatrixDAE(Block):
         """
         x_d, u = self.engine.state, self.inputs.to_array()
         self._xa = self._solve_xa(x_d, u, t)
-        f = lu_solve(self._lu, self.func(self._full(x_d), u, t)[self._d])
+        f = self._solve_mass_rhs(self.func(self._full(x_d), u, t)[self._d_equations])
         return self.engine.step(f, dt)
 
 

{pathsim-0.26.0 → pathsim-0.27.1}/src/pathsim/simulation.py

@@ -2025,6 +2025,10 @@ class Simulation:
         #main simulation loop
         while self.time < end_time and self._active:
 
+            if not _adaptive and np.isclose(
+                    self.time - start_time, duration, rtol=1e-12, atol=0.0):
+                break
+
             #advance the simulation by one (effective) timestep '_dt'
             try:
                 success, error_norm, scale, *_ = self.timestep(

{pathsim-0.26.0 → pathsim-0.27.1}/src/pathsim/utils/graph.py

@@ -331,19 +331,22 @@ class Graph:
         """Optimized loop processing with minimal overhead.
 
         Finds strongly connected components (SCCs) within the loop blocks, determines
-        entry points for each SCC, and performs BFS to assign local depths. Identifies
+        entry points for each SCC, and performs BFS to assign local depths. Includes
+        acyclic descendants in dependency order alongside cycles. Identifies
         loop-closing connections (back edges) that need special handling.
 
         Parameters
         ----------
         blocks_loop : set
-            set of blocks that are part of algebraic loops
+            set of blocks that are part of or depend on algebraic loops
         """
         if not blocks_loop:
             return
 
-        # Find SCCs (already optimized)
-        sccs = self._find_strongly_connected_components(blocks_loop)
+        # Tarjan emits downstream components before their upstream dependencies.
+        # Reverse that order so each component receives updated upstream outputs
+        # before it is evaluated in the same loop-solver iteration.
+        sccs = reversed(self._find_strongly_connected_components(blocks_loop))
         
         current_depth = 0
 
@@ -433,7 +436,7 @@ class Graph:
     def _find_strongly_connected_components(self, blocks):
         """Iterative Tarjan's algorithm using cleaner state machine.
 
-        Finds strongly connected components (cycles) within the given blocks using
+        Finds all strongly connected components within the given blocks using
         an iterative implementation of Tarjan's algorithm. Avoids recursion limits
         that can occur with deep graphs.
 
@@ -445,7 +448,7 @@ class Graph:
         Returns
         -------
         list
-            list of SCCs, where each SCC is a list of blocks forming a cycle
+            list of SCCs in reverse topological order, including acyclic singletons
         """
         if not blocks:
             return []
@@ -508,11 +511,12 @@ class Graph:
                             if w == node:
                                 break
                         
-                        # Keep only actual cycles
-                        if len(scc) > 1:
-                            result.append(scc)
-                        elif scc[0] in successors_cache[scc[0]]:
-                            result.append(scc)
+                        # A block downstream of a loop can form a singleton SCC
+                        # without being part of a cycle. Its loop dependency keeps
+                        # it out of the ordinary DAG schedule, so discarding it here
+                        # would leave it unevaluated. Keep it in the loop schedule;
+                        # only actual cycle-closing connections receive acceleration.
+                        result.append(scc)
                     
                     # Update parent's lowlink if there is a parent
                     if work_stack:

{pathsim-0.26.0 → pathsim-0.27.1}/src/pathsim.egg-info/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.27.1",
+  "distance": 0,
+  "node": "ga4e824de226c5a76509d6163b3c1e33445861144",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-12"
+}

{pathsim-0.26.0 → pathsim-0.27.1}/tests/pathsim/blocks/test_dae.py

@@ -141,10 +141,62 @@ class TestSemiExplicitDAE(unittest.TestCase):
         info = SemiExplicitDAE.info()
         self.assertEqual(info["type"], "SemiExplicitDAE")
         for p in ("func_dyn", "func_alg", "initial_value", "z0", "jac_z",
-                  "jac_dyn_x", "jac_dyn_z", "jac_alg_x", "tolerance"):
+                  "jac_dyn_x", "jac_dyn_z", "jac_alg_x", "tolerance", "func_out"):
             self.assertIn(p, info["parameters"])
 
 
+    def test_func_out(self):
+        #output function replaces the stacked state [x, z] at the output
+        dae = SemiExplicitDAE(
+            lambda x, z, u, t: -x + z, lambda x, z, u, t: z - x**2, 0.5, 0.25,
+            func_out=lambda x, z, u, t: np.array([x[0] + z[0]])
+            )
+        self.assertEqual(len(dae.outputs), 1)
+
+        dae.set_solver(ESDIRK43, None)
+        dae.update(0.0)
+        self.assertAlmostEqual(float(dae.outputs[0]), 0.5 + 0.25, places=8)
+
+        #reset keeps the output size of the output function
+        dae.reset()
+        self.assertEqual(len(dae.outputs), 1)
+
+
+    def test_no_algebraic_states(self):
+        #empty z reduces the block to a plain ODE without a constraint solve
+        calls = []
+        def f_alg(x, z, u, t):
+            calls.append(1)
+            return np.zeros(0)
+
+        dae = SemiExplicitDAE(
+            lambda x, z, u, t: -x, f_alg, initial_value=[1.0, 2.0], z0=np.zeros(0),
+            jac_z=lambda x, z, u, t: np.zeros((0, 0)),
+            jac_dyn_x=lambda x, z, u, t: -np.eye(2),
+            jac_dyn_z=lambda x, z, u, t: np.zeros((2, 0)),
+            jac_alg_x=lambda x, z, u, t: np.zeros((0, 2))
+            )
+
+        x, u = np.array([1.0, 2.0]), np.array([0.0])
+        self.assertEqual(dae._solve_z(x, u, 0.0).size, 0)
+        np.testing.assert_array_equal(dae.op_dyn.jac_x(x, u, 0.0), -np.eye(2))
+        self.assertEqual(len(calls), 0)
+
+
+    def test_simulation_no_algebraic_states(self):
+        #x' = -x with empty z integrates like the ODE block
+        from pathsim import Simulation
+
+        dae = SemiExplicitDAE(
+            lambda x, z, u, t: -x, lambda x, z, u, t: np.zeros(0),
+            initial_value=[1.0, 2.0], z0=np.zeros(0)
+            )
+        sim = Simulation(blocks=[dae], dt=0.01, Solver=ESDIRK43, log=False)
+        sim.run(1.0)
+
+        np.testing.assert_allclose(dae.engine.state, np.exp(-1.0)*np.array([1.0, 2.0]), rtol=1e-4)
+
+
     def test_tolerance_default(self):
         self.assertEqual(self._make_block().tolerance, SOL_TOLERANCE_FPI)
 
@@ -272,9 +324,6 @@ class TestMassMatrixDAE(unittest.TestCase):
             MassMatrixDAE(func, np.ones((2, 3)), initial_value=[0.0, 0.0])
         with self.assertRaises(ValueError):
             MassMatrixDAE(func, np.eye(2), initial_value=[0.0])
-        M_bad = np.array([[1.0, 1.0], [0.0, 0.0]])
-        with self.assertRaises(ValueError):
-            MassMatrixDAE(func, M_bad, initial_value=[0.0, 0.0])
 
     def test_passthrough(self):
         dae_ns = MassMatrixDAE(lambda x, u, t: -x, np.eye(2), [1.0, 1.0])
@@ -293,6 +342,7 @@ class TestMassMatrixDAE(unittest.TestCase):
         dae.reset()
         np.testing.assert_array_equal(dae._xa, dae._x0[dae._a])
 
+
     def test_info(self):
         info = MassMatrixDAE.info()
         self.assertEqual(info["type"], "MassMatrixDAE")
@@ -348,6 +398,21 @@ class TestMassMatrixDAE(unittest.TestCase):
         sim.run(1.0)
         self.assertAlmostEqual(float(dae.engine.state[0]), np.exp(-0.5), places=4)
 
+    def test_nonsymmetric_singular(self):
+        from pathsim import Simulation, Connection
+        from pathsim.blocks import Constant, Scope
+        M = np.array([[1.0, 1.0], [0.0, 0.0]])
+        func = lambda x, u, t: np.array([1., x[0] - x[1]])
+        dae = MassMatrixDAE(func, M, initial_value=[0.0, 0.0])
+        sco = Scope()
+        sim = Simulation(
+            blocks=[dae, sco],
+            connections=[Connection(dae[0], sco[0])],
+            dt=0.01, Solver=ESDIRK43, log=False
+            )
+        sim.run(1.0)
+        np.testing.assert_allclose(dae.outputs.to_array(), [0.5, 0.5], atol=1e-3)
+
     def test_simulation_singular_with_input(self):
         #x0' = -x0 + x1,  0 = x0 + x1 - u   =>   steady state x -> u/2
         from pathsim import Simulation, Connection

{pathsim-0.26.0 → pathsim-0.27.1}/tests/pathsim/test_simulation.py

@@ -51,6 +51,78 @@ class TestSimulation(unittest.TestCase):
     only very minimal functonality
     """
 
+    def test_algebraic_loop_downstream_chain(self):
+        """Evaluate acyclic descendants of a converged algebraic loop."""
+        a = Function(lambda b: 0.5 * b + 1)
+        b = Function(lambda a: 0.5 * a)
+        c = Function(lambda a: a + 10)
+        d = Function(lambda c: 2 * c)
+        simulation = Simulation(
+            blocks=[d, c, b, a],
+            connections=[
+                Connection(a, b), Connection(b, a),
+                Connection(a, c), Connection(c, d),
+            ],
+            log=False,
+        )
+        simulation.run(0.01)
+
+        self.assertAlmostEqual(a.outputs[0], 4 / 3)
+        self.assertAlmostEqual(b.outputs[0], 2 / 3)
+        self.assertAlmostEqual(c.outputs[0], 4 / 3 + 10)
+        self.assertAlmostEqual(d.outputs[0], 2 * (4 / 3 + 10))
+
+
+    def test_algebraic_loop_downstream_merge(self):
+        """Propagate both branches before evaluating their merged output."""
+        a = Function(lambda a: 0.5 * a + 1)
+        short = Function(lambda a: a + 10)
+        long = Function(lambda a: 3 * a)
+        end = Function(lambda value: value + 20)
+        merge = Adder()
+        simulation = Simulation(
+            blocks=[merge, end, long, short, a],
+            connections=[
+                Connection(a, a), Connection(a, short), Connection(a, long),
+                Connection(long, end),
+                Connection(short, merge[0]), Connection(end, merge[1]),
+            ],
+            log=False,
+        )
+        simulation.run(0.01)
+
+        self.assertAlmostEqual(a.outputs[0], 2)
+        self.assertAlmostEqual(short.outputs[0], 12)
+        self.assertAlmostEqual(end.outputs[0], 26)
+        self.assertAlmostEqual(merge.outputs[0], 38)
+
+
+    def test_connected_algebraic_loops_with_downstream_blocks(self):
+        """Evaluate a second feedback loop after its upstream loop and bridge."""
+        a = Function(lambda b: 0.5 * b + 1)
+        b = Function(lambda a: 0.5 * a)
+        bridge = Function(lambda a: a)
+        c = Function(lambda upstream, d: upstream + 0.5 * d)
+        d = Function(lambda c: 0.5 * c)
+        tail = Function(lambda c: c + 10)
+        simulation = Simulation(
+            blocks=[tail, d, c, bridge, b, a],
+            connections=[
+                Connection(a, b), Connection(b, a), Connection(a, bridge),
+                Connection(bridge, c[0]), Connection(c, d), Connection(d, c[1]),
+                Connection(c, tail),
+            ],
+            log=False,
+        )
+        simulation.run(0.01)
+
+        self.assertAlmostEqual(a.outputs[0], 4 / 3)
+        self.assertAlmostEqual(bridge.outputs[0], 4 / 3)
+        self.assertAlmostEqual(c.outputs[0], 16 / 9)
+        self.assertAlmostEqual(d.outputs[0], 8 / 9)
+        self.assertAlmostEqual(tail.outputs[0], 16 / 9 + 10)
+
+
     def test_init_default(self):
 
         #test default initialization
@@ -324,10 +396,10 @@ class TestSimulation(unittest.TestCase):
         stats = Sim.run(10)
 
         #check stats
-        self.assertEqual(stats["total_steps"], 1001)
+        self.assertEqual(stats["total_steps"], 1000)
             
-        #check internal time progression (fixed step solvers naturally overshoot)
-        self.assertAlmostEqual(Sim.time, 10, 1)
+        #check internal time progression stops at the requested endpoint
+        self.assertAlmostEqual(Sim.time, 10.0)
 
 
 
@@ -480,6 +552,88 @@ class TestSimulationIVP(unittest.TestCase):
 
 
 
+class TestSimulationRunBoundaries(unittest.TestCase):
+
+    def test_fixed_run_stops_at_aligned_endpoint(self):
+        for dt, duration, steps in [(0.1, 1.0, 10), (0.01, 10.0, 1000),
+                                    (0.2, 2.0, 10)]:
+            with self.subTest(dt=dt, duration=duration):
+                source = Constant(1.0)
+                integrator = Integrator()
+                scope = Scope()
+                simulation = Simulation(
+                    [source, integrator, scope],
+                    [Connection(source, integrator), Connection(integrator, scope)],
+                    dt=dt, log=False
+                    )
+
+                simulation.run(duration, adaptive=False)
+
+                self.assertAlmostEqual(simulation.time / duration, 1.0)
+                self.assertAlmostEqual(integrator.outputs[0] / duration, 1.0)
+                times, _ = scope.read()
+                self.assertEqual(len(times), steps + 1)
+                self.assertEqual(simulation.dt, dt)
+
+
+    def test_fixed_run_keeps_full_steps_for_non_aligned_endpoint(self):
+        for dt, duration, endpoint, steps in [(0.3, 1.0, 1.2, 4),
+                                             (2.0, 1.0, 2.0, 1),
+                                             (0.1, 0.05, 0.1, 1)]:
+            with self.subTest(dt=dt, duration=duration):
+                source = Constant(1.0)
+                integrator = Integrator()
+                scope = Scope()
+                simulation = Simulation(
+                    [source, integrator, scope],
+                    [Connection(source, integrator), Connection(integrator, scope)],
+                    dt=dt, log=False
+                    )
+
+                simulation.run(duration, adaptive=False)
+
+                self.assertAlmostEqual(simulation.time, endpoint)
+                self.assertAlmostEqual(integrator.outputs[0], endpoint)
+                times, _ = scope.read()
+                self.assertEqual(len(times), steps + 1)
+                self.assertEqual(simulation.dt, dt)
+
+
+    def test_streaming_run_stops_at_requested_endpoint(self):
+        simulation = Simulation(dt=0.1, log=False)
+        list(simulation.run_streaming(1.0, adaptive=False))
+        self.assertAlmostEqual(simulation.time, 1.0)
+
+
+    def test_fixed_split_runs_match_single_run(self):
+        source = Constant(1.0)
+        integrator = Integrator()
+        ticks = []
+
+        def sample(time):
+            ticks.append(time)
+            source.value = 2.0 * integrator.outputs[0] + 1.0
+
+        simulation = Simulation(
+            [source, integrator], [Connection(source, integrator)],
+            events=[Schedule(t_start=0.0, t_period=1.0, func_act=sample)],
+            dt=0.1, log=False
+            )
+
+        simulation.run(1.0, adaptive=False)
+        self.assertAlmostEqual(simulation.time, 1.0)
+        simulation.run(1.0, adaptive=False)
+        self.assertAlmostEqual(simulation.time, 2.0)
+        self.assertEqual(ticks, [0.0, 1.0, 2.0])
+        split_output = integrator.outputs[0]
+
+        ticks.clear()
+        simulation.run(2.0, reset=True, adaptive=False)
+        self.assertAlmostEqual(simulation.time, 2.0)
+        self.assertEqual(ticks, [0.0, 1.0, 2.0])
+        self.assertAlmostEqual(integrator.outputs[0], split_output)
+
+
 class TestSimulationEvents(unittest.TestCase):
     """Test event management and event handling during simulation"""