pathsim 0.26.0__tar.gz → 0.27.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.26.0
+Version: 0.27.0
 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.0}/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.0'
+__version_tuple__ = version_tuple = (0, 27, 0)
 
-__commit_id__ = commit_id = 'g7c5a82fa9'
+__commit_id__ = commit_id = 'g2cbb2f919'

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

@@ -474,20 +474,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 +537,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 +645,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 +682,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 +710,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.0}/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.0}/src/pathsim.egg-info/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.27.0",
+  "distance": 0,
+  "node": "g2cbb2f9191f0a2aeaa2154b3a54601c2ca92ea6b",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-04"
+}

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

@@ -272,9 +272,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 +290,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 +346,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.0}/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

{pathsim-0.26.0 → pathsim-0.27.0}/tests/pathsim/utils/test_graph.py

@@ -478,6 +478,73 @@ class TestGraph(unittest.TestCase):
         self.assertEqual(len(g), 4)
 
 
+    def test_loop_downstream_chain(self):
+        """Schedule every loop-dependent block after its upstream component."""
+        a, b, c, d = [Amplifier(0.5) for _ in range(4)]
+        connections = [
+            Connection(a, b), Connection(b, a),
+            Connection(a, c), Connection(c, d),
+        ]
+        graph = Graph([d, c, b, a], connections)
+        levels = {block: depth for depth, blocks, _ in graph.loop() for block in blocks}
+
+        self.assertEqual(set(levels), {a, b, c, d})
+        self.assertGreater(levels[c], max(levels[a], levels[b]))
+        self.assertGreater(levels[d], levels[c])
+        self.assertEqual(len(graph.loop_closing_connections()), 1)
+
+
+    def test_loop_downstream_merge(self):
+        """Merged branches wait for both of their loop-dependent inputs."""
+        a, b, c, d, e = [Amplifier(0.5) for _ in range(5)]
+        merge = Adder()
+        connections = [
+            Connection(a, b), Connection(b, a),
+            Connection(a, c), Connection(a, d), Connection(d, e),
+            Connection(c, merge[0]), Connection(e, merge[1]),
+        ]
+        blocks = [merge, e, d, c, b, a]
+        graph = Graph(blocks, connections)
+        levels = {block: depth for depth, nodes, _ in graph.loop() for block in nodes}
+
+        self.assertEqual(set(levels), set(blocks))
+        self.assertGreater(levels[merge], max(levels[c], levels[e]))
+        self.assertGreater(levels[e], levels[d])
+        self.assertEqual(len(graph.loop_closing_connections()), 1)
+
+
+    def test_connected_loops_with_downstream_blocks(self):
+        """Order connected cycles and the acyclic blocks between them."""
+        a, b, bridge, c, d, tail = [Adder() for _ in range(6)]
+        connections = [
+            Connection(a, b), Connection(b, a), Connection(a, bridge),
+            Connection(bridge, c[0]), Connection(c, d), Connection(d, c[1]),
+            Connection(c, tail),
+        ]
+        blocks = [tail, d, c, bridge, b, a]
+        graph = Graph(blocks, connections)
+        levels = {block: depth for depth, nodes, _ in graph.loop() for block in nodes}
+
+        self.assertEqual(set(levels), set(blocks))
+        self.assertGreater(levels[bridge], max(levels[a], levels[b]))
+        self.assertGreater(min(levels[c], levels[d]), levels[bridge])
+        self.assertGreater(levels[tail], max(levels[c], levels[d]))
+        self.assertEqual(len(graph.loop_closing_connections()), 2)
+
+
+    def test_self_loop_with_downstream_block(self):
+        """Keep a self-loop's accelerator without treating its tail as a cycle."""
+        a, tail = Amplifier(0.5), Amplifier(2)
+        feedback = Connection(a, a)
+        downstream = Connection(a, tail)
+        graph = Graph([tail, a], [feedback, downstream])
+        levels = {block: depth for depth, nodes, _ in graph.loop() for block in nodes}
+
+        self.assertEqual(set(levels), {a, tail})
+        self.assertGreater(levels[tail], levels[a])
+        self.assertEqual(graph.loop_closing_connections(), [feedback])
+
+
     def test_dag_empty_when_only_loops(self):
         """Test that DAG is empty when graph only contains loops."""
 

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

@@ -1,8 +0,0 @@
-{
-  "tag": "0.26.0",
-  "distance": 0,
-  "node": "g7c5a82fa9c55230285135deccbf851ad602818fe",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-30"
-}