pathsim 0.2.0__py3-none-any.whl

tests/solvers/test_esdirk43.py

@@ -0,0 +1,158 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'solvers/esdirk43.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.solvers.esdirk43 import ESDIRK43
+
+
+
+# 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 TestESDIRK43(unittest.TestCase):
+    """
+    Test the implementation of the 'ESDIRK43' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = ESDIRK43()
+
+        self.assertTrue(callable(solver.func))
+        self.assertEqual(solver.jac, None)
+        self.assertEqual(solver.initial_value, 0)
+
+        self.assertEqual(solver.stage, 0)
+        self.assertTrue(solver.is_adaptive)
+        self.assertTrue(solver.is_implicit)
+        self.assertFalse(solver.is_explicit)
+        
+        #test specific initialization
+        solver = ESDIRK43(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 = ESDIRK43()
+
+        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 = ESDIRK43()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+
+            #test if stage incrementation works
+            self.assertEqual(solver.stage, i)
+
+            _ = solver.solve(0.0, t, 1) #needed for implicit solvers to get slope
+            success, err, scale = solver.step(0.0, t, 1)
+
+            #test if expected return at intermediate stages
+            if i < len(solver.eval_stages)-1:
+                self.assertTrue(success)
+                self.assertEqual(err, 0.0)
+                self.assertEqual(scale, 1.0)
+
+        #test if expected return at final stage
+        self.assertNotEqual(err, 0.0)
+        self.assertNotEqual(scale, 1.0)
+
+
+    def test_integrate_fixed(self):
+        
+        #integrate test problem and assess convergence order
+
+        timesteps = np.logspace(-0.4, 0, 10)
+
+        for problem in reference_problems:
+
+            solver = ESDIRK43(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 or 4
+            p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
+            self.assertEqual(round(p), 4)
+            
+
+    def test_integrate_adaptive(self):
+
+        #test the error control for each reference problem
+
+        for problem in reference_problems:
+
+            solver = ESDIRK43(problem.x0, problem.func, problem.jac, tolerance_lte=1e-6)
+
+            time, numerical_solution = solver.integrate(time_start=0.0, time_end=2.0, dt=1, adaptive=True)
+            error = np.linalg.norm(numerical_solution - problem.solution(time))
+
+            #test if error control was successful (same OOM, since global error)
+            self.assertLess(error, solver.tolerance_lte*3)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/solvers/test_esdirk54.py

@@ -0,0 +1,160 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'solvers/esdirk54.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.solvers.esdirk54 import ESDIRK54
+
+
+
+# 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 TestESDIRK54(unittest.TestCase):
+    """
+    Test the implementation of the 'ESDIRK54' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = ESDIRK54()
+
+        self.assertTrue(callable(solver.func))
+        self.assertEqual(solver.jac, None)
+        self.assertEqual(solver.initial_value, 0)
+
+        self.assertEqual(solver.stage, 0)
+        self.assertTrue(solver.is_adaptive)
+        self.assertTrue(solver.is_implicit)
+        self.assertFalse(solver.is_explicit)
+        
+        #test specific initialization
+        solver = ESDIRK54(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 = ESDIRK54()
+
+        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 = ESDIRK54()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+
+            #test if stage incrementation works
+            self.assertEqual(solver.stage, i)
+
+            _ = solver.solve(0.0, t, 1) #needed for implicit solvers to get slope
+            success, err, scale = solver.step(0.0, t, 1)
+
+            #test if expected return at intermediate stages
+            if i < len(solver.eval_stages)-1:
+                self.assertTrue(success)
+                self.assertEqual(err, 0.0)
+                self.assertEqual(scale, 1.0)
+
+        #test if expected return at final stage
+        self.assertNotEqual(err, 0.0)
+        self.assertNotEqual(scale, 1.0)
+
+
+    def test_integrate_fixed(self):
+        
+        #integrate test problem and assess convergence order
+
+        timesteps = np.logspace(-0.4, 0, 10)
+
+        for problem in reference_problems:
+
+            solver = ESDIRK54(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 4 or 5
+            p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
+            self.assertGreater(p, 4)
+            
+
+    def test_integrate_adaptive(self):
+
+        #test the error control for each reference problem
+
+        for problem in reference_problems:
+
+            solver = ESDIRK54(problem.x0, problem.func, problem.jac, tolerance_lte=1e-6)
+
+            time, numerical_solution = solver.integrate(time_start=0.0, time_end=1.0, dt=1, adaptive=True)
+            error = np.linalg.norm(numerical_solution - problem.solution(time))
+
+            #test if error control was successful
+            self.assertLess(error, solver.tolerance_lte)
+
+
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/solvers/test_esdirk85.py

@@ -0,0 +1,157 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'solvers/esdirk85.py'
+##
+##                               Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.solvers.esdirk85 import ESDIRK85
+
+
+# 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 TestESDIRK85(unittest.TestCase):
+    """
+    Test the implementation of the 'ESDIRK85' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = ESDIRK85()
+
+        self.assertTrue(callable(solver.func))
+        self.assertEqual(solver.jac, None)
+        self.assertEqual(solver.initial_value, 0)
+
+        self.assertEqual(solver.stage, 0)
+        self.assertTrue(solver.is_adaptive)
+        self.assertTrue(solver.is_implicit)
+        self.assertFalse(solver.is_explicit)
+        
+        #test specific initialization
+        solver = ESDIRK85(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 = ESDIRK85()
+
+        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 = ESDIRK85()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+
+            #test if stage incrementation works
+            self.assertEqual(solver.stage, i)
+
+            _ = solver.solve(0.0, t, 1) #needed for implicit solvers to get slope
+            success, err, scale = solver.step(0.0, t, 1)
+
+            #test if expected return at intermediate stages
+            if i < len(solver.eval_stages)-1:
+                self.assertTrue(success)
+                self.assertEqual(err, 0.0)
+                self.assertEqual(scale, 1.0)
+
+        #test if expected return at final stage
+        self.assertNotEqual(err, 0.0)
+        self.assertNotEqual(scale, 1.0)
+
+
+    def test_integrate_fixed(self):
+        
+        #integrate test problem and assess convergence order
+
+        timesteps = np.logspace(-0.4, 0, 10)
+
+        for problem in reference_problems:
+
+            solver = ESDIRK85(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 7 or 8
+            p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
+            self.assertGreaterEqual(round(p), 7)
+
+
+    def test_integrate_adaptive(self):
+
+        #test the error control for each reference problem
+
+        for problem in reference_problems:
+
+            solver = ESDIRK85(problem.x0, problem.func, problem.jac, tolerance_lte=1e-6)
+
+            time, numerical_solution = solver.integrate(time_start=0.0, time_end=1.0, dt=1, adaptive=True)
+            error = np.linalg.norm(numerical_solution - problem.solution(time))
+
+            #test if error control was successful
+            self.assertLess(error, solver.tolerance_lte)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/solvers/test_euler.py

@@ -0,0 +1,223 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'solvers/euler.py'
+##
+##                            Milan Rother 2023/24
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.solvers.euler import EUF, EUB
+
+
+
+# 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 TestEUF(unittest.TestCase):
+    """
+    Test the implementation of the 'EUF' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = EUF()
+
+        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 = EUF(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 = EUF()
+
+        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 = EUF()
+
+        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 = EUF(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 1
+            p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
+            self.assertEqual(round(p), 1)
+
+
+
+class TestEUB(unittest.TestCase):
+    """
+    Test the implementation of the 'EUB' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = EUB()
+
+        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_implicit)
+        self.assertFalse(solver.is_explicit)
+        
+        #test specific initialization
+        solver = EUB(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 = EUB()
+
+        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 = EUB()
+
+        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(-2, -1, 10)
+
+        for problem in reference_problems:
+
+            solver = EUB(problem.x0, problem.func, problem.jac)
+            
+            errors = []
+
+            for dt in timesteps:
+
+                solver.reset()
+                time, numerical_solution = solver.integrate(time_start=0.0, time_end=1.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 1
+            p, _ = np.polyfit(np.log10(timesteps), np.log10(errors), deg=1)
+            self.assertGreater(p, 0.5)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)