pathsim 0.2.0__py3-none-any.whl

tests/solvers/test_solver.py

@@ -0,0 +1,119 @@
+########################################################################################
+##
+##                      TESTS FOR 'solvers/_solver.py'
+##
+##                            Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+
+from pathsim.solvers._solver import (
+    Solver, 
+    ExplicitSolver, 
+    ImplicitSolver)
+
+
+# HELPER FUNCTIONS =====================================================================
+
+def simple_func(x, u, t):
+    return u - x
+
+def simple_jac(x, u, t):
+    return -1
+
+
+# TESTS ================================================================================
+
+class TestBaseSolver(unittest.TestCase):
+    """
+    Test the implementation of the base 'Solver' class
+    """
+
+    def setUp(self):
+        self.solver = Solver(initial_value=1.0, func=simple_func, jac=simple_jac)
+
+    def test_init(self):
+        self.assertEqual(self.solver.x, 1.0)
+        self.assertEqual(self.solver.x_0, 1.0)
+        self.assertEqual(self.solver.initial_value, 1.0)
+        self.assertEqual(self.solver.func, simple_func)
+        self.assertEqual(self.solver.jac, simple_jac)
+        self.assertFalse(self.solver.is_adaptive)
+
+    def test_str(self):
+        self.assertEqual(str(self.solver), "Solver")
+
+    def test_stages(self):
+        stages = list(self.solver.stages(0, 1))
+        self.assertEqual(stages, [0])
+
+    def test_get_set(self):
+        self.solver.set(2.0)
+        self.assertEqual(self.solver.get(), 2.0)
+
+    def test_reset(self):
+        self.solver.set(2.0)
+        self.solver.reset()
+        self.assertEqual(self.solver.get(), 1.0)
+
+    def test_buffer(self):
+        self.solver.x = 2.0
+        self.solver.buffer()
+        self.assertEqual(self.solver.x_0, 2.0)
+
+    def test_change(self):
+        new_solver = self.solver.change(ExplicitSolver)
+        self.assertIsInstance(new_solver, ExplicitSolver)
+        self.assertEqual(new_solver.get(), self.solver.get())
+
+
+class ExplicitSolverTest(unittest.TestCase):
+    """
+    Test the implementation of the 'ExplicitSolver' base class
+    """
+    def setUp(self):
+        self.solver = ExplicitSolver(initial_value=1.0, func=simple_func, jac=simple_jac)
+
+    def test_init(self):
+        self.assertTrue(self.solver.is_explicit)
+        self.assertFalse(self.solver.is_implicit)
+
+    def test_integrate_singlestep(self):
+        success, error, scale = self.solver.integrate_singlestep(time=0, dt=0.1)
+        self.assertTrue(success)
+        self.assertEqual(error, 0.0)
+        self.assertEqual(scale, 1.0)
+
+    def test_integrate(self):
+        times, states = self.solver.integrate(time_start=0, time_end=1, dt=0.1)
+        self.assertEqual(len(times), len(states))
+        self.assertGreater(len(times), 1)
+        self.assertEqual(times[0], 0)
+
+
+class ImplicitSolverTest(unittest.TestCase):
+    """
+    Test the implementation of the 'ImplicitSolver' base class
+    """
+
+    def setUp(self):
+        self.solver = ImplicitSolver(initial_value=1.0, func=simple_func, jac=simple_jac)
+
+    def test_init(self):
+        self.assertFalse(self.solver.is_explicit)
+        self.assertTrue(self.solver.is_implicit)
+
+    def test_solve(self):
+        error = self.solver.solve(0, 0, 0.1)
+        self.assertEqual(error, 0.0)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/solvers/test_ssprk22.py

@@ -0,0 +1,136 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'solvers/ssprk22.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.solvers.ssprk22 import SSPRK22
+
+
+# TEST PROBLEMS ========================================================================
+
+class Problem:
+    def __init__(self, name, func, jac, x0, solution):
+        self.name = name
+        self.func = func
+        self.jac = jac
+        self.x0 = x0
+        self.solution = solution
+
+
+#create some reference problems for testing
+reference_problems = [
+    Problem(name="linear_feedback", 
+            func=lambda x, u, t: -x, 
+            jac=lambda x, u, t: -1, 
+            x0=1.0, 
+            solution=lambda t: np.exp(-t)
+            ),
+    Problem(name="logistic", 
+            func=lambda x, u, t: x*(1-x), 
+            jac=lambda x, u, t: 1-2*x, 
+            x0=0.5, 
+            solution=lambda t: 1/(1 + np.exp(-t))
+            )
+]
+
+
+# TESTS ================================================================================
+
+class TestSSPRK22(unittest.TestCase):
+    """
+    Test the implementation of the 'SSPRK22' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = SSPRK22()
+
+        self.assertTrue(callable(solver.func))
+        self.assertEqual(solver.jac, None)
+        self.assertEqual(solver.initial_value, 0)
+
+        self.assertEqual(solver.stage, 0)
+        self.assertFalse(solver.is_adaptive)
+        self.assertTrue(solver.is_explicit)
+        self.assertFalse(solver.is_implicit)
+        
+        #test specific initialization
+        solver = SSPRK22(initial_value=1, 
+                        func=lambda x, u, t: -x, 
+                        jac=lambda x, u, t: -1, 
+                        tolerance_lte=1e-6)
+
+        self.assertEqual(solver.func(2, 0, 0), -2)
+        self.assertEqual(solver.jac(2, 0, 0), -1)
+        self.assertEqual(solver.initial_value, 1)
+        self.assertEqual(solver.tolerance_lte, 1e-6)
+
+
+    def test_stages(self):
+
+        solver = SSPRK22()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+            
+            #test the stage iterator
+            self.assertEqual(t, solver.eval_stages[i])
+
+
+    def test_step(self):
+
+        solver = SSPRK22()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+
+            #test if stage incrementation works
+            self.assertEqual(solver.stage, i)
+
+            success, err, scale = solver.step(0.0, t, 1)
+
+            #test if expected return at intermediate stages
+            self.assertTrue(success)
+            self.assertEqual(err, 0.0)
+            self.assertEqual(scale, 1.0)
+
+
+    def test_integrate_fixed(self):
+        
+        #integrate test problem and assess convergence order
+
+        timesteps = np.logspace(-0.4, 0, 20)
+
+        for problem in reference_problems:
+
+            solver = SSPRK22(problem.x0, problem.func, problem.jac)
+            
+            errors = []
+
+            for dt in timesteps:
+
+                solver.reset()
+                time, numerical_solution = solver.integrate(time_start=0.0, time_end=3.0, dt=dt, adaptive=False)
+
+                errors.append(np.linalg.norm(numerical_solution - problem.solution(time)))
+
+            #test if errors are monotonically decreasing
+            self.assertTrue(np.all(np.diff(errors)>0))
+
+            #test convergence order, expected 2
+            p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
+            self.assertEqual(round(p), 2)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/solvers/test_ssprk33.py

@@ -0,0 +1,136 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'solvers/ssprk33.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.solvers.ssprk33 import SSPRK33
+
+
+# TEST PROBLEMS ========================================================================
+
+class Problem:
+    def __init__(self, name, func, jac, x0, solution):
+        self.name = name
+        self.func = func
+        self.jac = jac
+        self.x0 = x0
+        self.solution = solution
+
+
+#create some reference problems for testing
+reference_problems = [
+    Problem(name="linear_feedback", 
+            func=lambda x, u, t: -x, 
+            jac=lambda x, u, t: -1, 
+            x0=1.0, 
+            solution=lambda t: np.exp(-t)
+            ),
+    Problem(name="logistic", 
+            func=lambda x, u, t: x*(1-x), 
+            jac=lambda x, u, t: 1-2*x, 
+            x0=0.5, 
+            solution=lambda t: 1/(1 + np.exp(-t))
+            )
+]
+
+
+# TESTS ================================================================================
+
+class TestSSPRK33(unittest.TestCase):
+    """
+    Test the implementation of the 'SSPRK33' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = SSPRK33()
+
+        self.assertTrue(callable(solver.func))
+        self.assertEqual(solver.jac, None)
+        self.assertEqual(solver.initial_value, 0)
+
+        self.assertEqual(solver.stage, 0)
+        self.assertFalse(solver.is_adaptive)
+        self.assertTrue(solver.is_explicit)
+        self.assertFalse(solver.is_implicit)
+        
+        #test specific initialization
+        solver = SSPRK33(initial_value=1, 
+                        func=lambda x, u, t: -x, 
+                        jac=lambda x, u, t: -1, 
+                        tolerance_lte=1e-6)
+
+        self.assertEqual(solver.func(2, 0, 0), -2)
+        self.assertEqual(solver.jac(2, 0, 0), -1)
+        self.assertEqual(solver.initial_value, 1)
+        self.assertEqual(solver.tolerance_lte, 1e-6)
+
+
+    def test_stages(self):
+
+        solver = SSPRK33()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+            
+            #test the stage iterator
+            self.assertEqual(t, solver.eval_stages[i])
+
+
+    def test_step(self):
+
+        solver = SSPRK33()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+
+            #test if stage incrementation works
+            self.assertEqual(solver.stage, i)
+
+            success, err, scale = solver.step(0.0, t, 1)
+
+            #test if expected return at intermediate stages
+            self.assertTrue(success)
+            self.assertEqual(err, 0.0)
+            self.assertEqual(scale, 1.0)
+
+
+    def test_integrate_fixed(self):
+        
+        #integrate test problem and assess convergence order
+
+        timesteps = np.logspace(-0.4, 0, 20)
+
+        for problem in reference_problems:
+
+            solver = SSPRK33(problem.x0, problem.func, problem.jac)
+            
+            errors = []
+
+            for dt in timesteps:
+
+                solver.reset()
+                time, numerical_solution = solver.integrate(time_start=0.0, time_end=3.0, dt=dt, adaptive=False)
+
+                errors.append(np.linalg.norm(numerical_solution - problem.solution(time)))
+
+            #test if errors are monotonically decreasing
+            self.assertTrue(np.all(np.diff(errors)>0))
+
+            #test convergence order, expected 3
+            p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
+            self.assertEqual(round(p), 3)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/solvers/test_ssprk34.py

@@ -0,0 +1,136 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'solvers/ssprk34.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.solvers.ssprk34 import SSPRK34
+
+
+# TEST PROBLEMS ========================================================================
+
+class Problem:
+    def __init__(self, name, func, jac, x0, solution):
+        self.name = name
+        self.func = func
+        self.jac = jac
+        self.x0 = x0
+        self.solution = solution
+
+
+#create some reference problems for testing
+reference_problems = [
+    Problem(name="linear_feedback", 
+            func=lambda x, u, t: -x, 
+            jac=lambda x, u, t: -1, 
+            x0=1.0, 
+            solution=lambda t: np.exp(-t)
+            ),
+    Problem(name="logistic", 
+            func=lambda x, u, t: x*(1-x), 
+            jac=lambda x, u, t: 1-2*x, 
+            x0=0.5, 
+            solution=lambda t: 1/(1 + np.exp(-t))
+            )
+]
+
+
+# TESTS ================================================================================
+
+class TestSSPRK34(unittest.TestCase):
+    """
+    Test the implementation of the 'SSPRK34' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = SSPRK34()
+
+        self.assertTrue(callable(solver.func))
+        self.assertEqual(solver.jac, None)
+        self.assertEqual(solver.initial_value, 0)
+
+        self.assertEqual(solver.stage, 0)
+        self.assertFalse(solver.is_adaptive)
+        self.assertTrue(solver.is_explicit)
+        self.assertFalse(solver.is_implicit)
+        
+        #test specific initialization
+        solver = SSPRK34(initial_value=1, 
+                        func=lambda x, u, t: -x, 
+                        jac=lambda x, u, t: -1, 
+                        tolerance_lte=1e-6)
+
+        self.assertEqual(solver.func(2, 0, 0), -2)
+        self.assertEqual(solver.jac(2, 0, 0), -1)
+        self.assertEqual(solver.initial_value, 1)
+        self.assertEqual(solver.tolerance_lte, 1e-6)
+
+
+    def test_stages(self):
+
+        solver = SSPRK34()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+            
+            #test the stage iterator
+            self.assertEqual(t, solver.eval_stages[i])
+
+
+    def test_step(self):
+
+        solver = SSPRK34()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+
+            #test if stage incrementation works
+            self.assertEqual(solver.stage, i)
+
+            success, err, scale = solver.step(0.0, t, 1)
+
+            #test if expected return at intermediate stages
+            self.assertTrue(success)
+            self.assertEqual(err, 0.0)
+            self.assertEqual(scale, 1.0)
+
+
+    def test_integrate_fixed(self):
+        
+        #integrate test problem and assess convergence order
+
+        timesteps = np.logspace(-0.4, 0, 20)
+
+        for problem in reference_problems:
+
+            solver = SSPRK34(problem.x0, problem.func, problem.jac)
+            
+            errors = []
+
+            for dt in timesteps:
+
+                solver.reset()
+                time, numerical_solution = solver.integrate(time_start=0.0, time_end=3.0, dt=dt, adaptive=False)
+
+                errors.append(np.linalg.norm(numerical_solution - problem.solution(time)))
+
+            #test if errors are monotonically decreasing
+            self.assertTrue(np.all(np.diff(errors)>0))
+
+            #test convergence order, expected 3
+            p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
+            self.assertEqual(round(p), 3)
+            
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/test_connection.py

@@ -0,0 +1,176 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                               'connection.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.connection import Connection
+from pathsim.blocks._block import Block
+
+
+# TESTS ================================================================================
+
+class TestConnection(unittest.TestCase):
+    """
+    Test the implementation of the 'Connection' class
+    """
+
+    def test_init_single(self):
+
+        B1, B2 = Block(), Block()
+
+        #default
+        C = Connection(B1, B2)
+
+        #test if ports assigned correctly
+        self.assertEqual(C.source, (B1, 0))
+        self.assertEqual(C.targets, [(B2, 0)])
+
+        #mixed
+        C1 = Connection(B1, (B2, 2))    
+        C2 = Connection((B1, 3), B2)
+        
+        #test if ports assigned correctly
+        self.assertEqual(C1.source, (B1, 0))
+        self.assertEqual(C1.targets, [(B2, 2)])
+
+        #test if ports assigned correctly
+        self.assertEqual(C2.source, (B1, 3))
+        self.assertEqual(C2.targets, [(B2, 0)])
+
+        #all
+        C = Connection((B1, 4), (B2, 1))
+
+        #test if ports assigned correctly
+        self.assertEqual(C.source, (B1, 4))
+        self.assertEqual(C.targets, [(B2, 1)])
+
+
+    def test_init_multi(self):
+
+        B1, B2, B3 = Block(), Block(), Block()
+
+        #default
+        C = Connection(B1, B2, B3)
+
+        #test if ports assigned correctly
+        self.assertEqual(C.source, (B1, 0))
+        self.assertEqual(C.targets, [(B2, 0), (B3, 0)])
+
+        #mixed
+        C1 = Connection(B1, (B2, 2), B3)    
+        C2 = Connection((B1, 3), B2, (B3, 1))
+        
+        #test if ports assigned correctly
+        self.assertEqual(C1.source, (B1, 0))
+        self.assertEqual(C1.targets, [(B2, 2), (B3, 0)])
+
+        #test if ports assigned correctly
+        self.assertEqual(C2.source, (B1, 3))
+        self.assertEqual(C2.targets, [(B2, 0), (B3, 1)])
+
+        #all
+        C = Connection((B1, 4), (B2, 1), (B3, 2))
+
+        #test if ports assigned correctly
+        self.assertEqual(C.source, (B1, 4))
+        self.assertEqual(C.targets, [(B2, 1), (B3, 2)])
+
+
+    def test_overwrites(self):
+
+        B1, B2, B3 = Block(), Block(), Block()
+
+        C1 = Connection(B1, B2) 
+        C2 = Connection(B1, B3)  
+        C3 = Connection(B2, B3) 
+
+        self.assertFalse(C1.overwrites(C2))
+        self.assertFalse(C2.overwrites(C1))
+        self.assertTrue(C3.overwrites(C2))
+        self.assertTrue(C2.overwrites(C3))
+
+        C1 = Connection(B1, B2, B3) 
+        C2 = Connection(B1, B3)  
+
+        self.assertTrue(C1.overwrites(C2))
+        self.assertTrue(C2.overwrites(C1))
+
+        C1 = Connection(B1, (B2, 1)) 
+        C2 = Connection(B1, (B2, 2))  
+
+        self.assertFalse(C1.overwrites(C2))
+        self.assertFalse(C2.overwrites(C1))
+
+        C1 = Connection((B1, 1), B3) 
+        C2 = Connection((B1, 2), B3)  
+
+        self.assertTrue(C1.overwrites(C2))
+        self.assertTrue(C2.overwrites(C1))
+
+        C1 = Connection((B1, 1), B3) 
+        C2 = Connection((B1, 2), (B3, 0))  
+
+        self.assertTrue(C1.overwrites(C2))
+        self.assertTrue(C2.overwrites(C1))
+
+
+    def test_update_single(self):
+
+        B1, B2 = Block(), Block()
+
+        #test data transfer with default ports
+        C = Connection(B1, B2) 
+        B1.outputs[0] = 3
+        C.update()
+        self.assertEqual(B2.inputs[0], 3)
+
+        #test data transfer with specific ports
+        C = Connection((B1, 2), (B2, 2)) 
+        B1.outputs[2] = 3
+        C.update()
+        self.assertEqual(B2.inputs[2], 3)
+
+        #test data transfer with mixed ports
+        C = Connection(B1, (B2, 2)) 
+        B1.outputs[0] = 3
+        C.update()
+        self.assertEqual(B2.inputs[2], 3)
+
+        C = Connection((B1, 2), B2) 
+        B1.outputs[2] = 3
+        C.update()
+        self.assertEqual(B2.inputs[0], 3)
+
+
+    def test_update_multi(self):
+
+        B1, B2, B3 = Block(), Block(), Block()
+
+        #test data transfer with default ports
+        C = Connection(B1, B2, B3) 
+        B1.outputs[0] = 3
+        C.update()
+        self.assertEqual(B2.inputs[0], 3)
+        self.assertEqual(B3.inputs[0], 3)
+
+        #test data transfer with specific ports
+        C = Connection((B1, 2), (B2, 2), (B3, 1)) 
+        B1.outputs[2] = 3
+        C.update()
+        self.assertEqual(B2.inputs[2], 3)
+        self.assertEqual(B3.inputs[1], 3)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)