pathsim 0.2.0__py3-none-any.whl

tests/blocks/test_sources.py

@@ -0,0 +1,119 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'blocks.sources.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.sources import Source, Constant
+
+
+# TESTS ================================================================================
+
+class TestConstant(unittest.TestCase):
+    """
+    Test the implementation of the 'Constant' block class
+    """
+
+    def test_init(self):
+
+        C = Constant(value=5)
+
+        self.assertEqual(C.value, 5)
+        self.assertEqual(C.get(0), 5)
+
+
+    def test_str(self):
+
+        C = Constant(value=5)
+
+        #test default str method
+        self.assertEqual(str(C), "Constant")
+
+
+    def test_reset(self):
+        
+        C = Constant(value=5)
+
+        C.reset()
+
+        #test if output remains after reset
+        self.assertEqual(C.get(0), 5)
+
+
+class TestSource(unittest.TestCase):
+    """
+    Test the implementation of the 'Source' block class
+    """
+
+    def test_init(self):
+
+        def f(t):
+            return np.sin(t)
+
+        S = Source(func=f)
+
+        #test if function works
+        self.assertEqual(S.func(1), f(1))
+        self.assertEqual(S.func(2), f(2))
+        self.assertEqual(S.func(3), f(3))
+
+        #test input validation
+        with self.assertRaises(ValueError): 
+            S = Source(func=2)
+
+
+    def test_str(self):
+
+        S = Source()
+
+        #test default str method
+        self.assertEqual(str(S), "Source")
+
+
+    def test_update(self):
+        
+        def f(t):
+            return np.sin(t)
+
+        S = Source(func=f)
+
+        #update block
+        err = S.update(1)
+
+        #test if update was correct
+        self.assertEqual(S.get(0), f(1))
+
+        #test if error is allways 0
+        self.assertEqual(err, 0)
+
+        #update block
+        err = S.update(2)
+
+        #test if update was correct
+        self.assertEqual(S.get(0), f(2))
+
+        #test if error is allways 0
+        self.assertEqual(err, 0)
+
+        #update block
+        err = S.update(3)
+
+        #test if update was correct
+        self.assertEqual(S.get(0), f(3))
+
+        #test if error is allways 0
+        self.assertEqual(err, 0)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_spectrum.py

@@ -0,0 +1,119 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                             'blocks.spectrum.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.spectrum import Spectrum
+
+#base solver for testing
+from pathsim.solvers._solver import Solver 
+
+
+# TESTS ================================================================================
+
+class TestSpectrum(unittest.TestCase):
+    """
+    Test the implementation of the 'Spectrum' block class
+    """
+
+    def test_init(self):
+
+        #test default initialization
+        S = Spectrum()
+        self.assertEqual(S.time, 0.0)
+        self.assertEqual(S.t_wait, 0.0)
+        self.assertEqual(S.alpha, 0.0)
+        self.assertEqual(S.labels, [])
+        self.assertEqual(len(S.freq), 0)
+        self.assertEqual(len(S.omega), 0)
+
+        #test specific initialization
+        _freq = np.linspace(0, 10, 100)
+        S = Spectrum(freq=_freq, t_wait=20, alpha=0.01, labels=["1", "2"])
+        self.assertEqual(S.time, 0.0)
+        self.assertEqual(S.t_wait, 20)
+        self.assertEqual(S.alpha, 0.01)
+        self.assertEqual(S.labels, ["1", "2"])
+        self.assertTrue(np.all(S.freq == _freq))
+        self.assertTrue(np.all(S.omega == 2*np.pi*_freq))
+
+
+    def test_len(self):
+
+        S = Spectrum()
+
+        #no direct passthrough
+        self.assertEqual(len(S), 0)
+
+
+    def test_str(self):
+
+        S = Spectrum()
+
+        #test default str method
+        self.assertEqual(str(S), "Spectrum")
+
+
+    def test_set_solver(self):
+
+        S = Spectrum()
+
+        #test that no solver is initialized
+        self.assertEqual(S.engine, None)
+
+        S.set_solver(Solver, tolerance_lte=1e-6)
+
+        #test that solver is now available
+        self.assertTrue(isinstance(S.engine, Solver))
+        self.assertEqual(S.engine.tolerance_lte, 1e-6)
+        self.assertEqual(S.engine.initial_value, 0.0)
+
+        S.set_solver(Solver, tolerance_lte=1e-3)
+
+        #test that solver tolerance is changed
+        self.assertEqual(S.engine.tolerance_lte, 1e-3)
+
+
+    def test_read(self):
+
+        #test read for no engine and default initialization
+        S = Spectrum()
+
+        freq, spec = S.read()
+        
+        self.assertEqual(len(freq), 0)
+        self.assertEqual(len(spec), 0)
+
+        #test read for no engine and specific initialization
+        _freq = np.linspace(0, 10, 100)
+        S = Spectrum(freq=_freq)
+
+        freq, spec = S.read()
+        
+        self.assertTrue(np.all(freq == _freq))
+        self.assertTrue(np.all(spec == np.zeros(100)))
+
+        #test read for engine and specific initialization
+        _freq = np.linspace(0, 10, 100)
+        S = Spectrum(freq=_freq)
+        S.set_solver(Solver)
+
+        freq, spec = S.read()
+        
+        self.assertTrue(np.all(freq == _freq))
+        self.assertTrue(np.all(spec == np.zeros(100)))
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/solvers/test_bdf.py

@@ -0,0 +1,364 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                               'solvers/bdf.py'
+##
+##                            Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.solvers.bdf import BDF2, BDF3, BDF4
+
+
+# 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 TestBDF2(unittest.TestCase):
+    """
+    Test the implementation of the 'BDF2' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = BDF2()
+
+        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 = BDF2(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 = BDF2()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+            
+            #test the stage iterator
+            self.assertEqual(t, solver.eval_stages[i])
+
+
+    def test_buffer(self):
+
+        solver = BDF2()
+
+        #perform some steps
+        for k in range(10):
+
+            #test bdf buffer length
+            buffer_length = len(solver.B)
+            self.assertEqual(buffer_length, k+1 if k < 2 else 2)
+            
+            #make one step
+            for i, t in enumerate(solver.stages(0, 1)):
+                success, err, scale = solver.step(0.0, t, 1)
+
+
+    def test_step(self):
+
+        solver = BDF2()
+
+        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 = BDF2(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, 1)
+
+
+
+class TestBDF3(unittest.TestCase):
+    """
+    Test the implementation of the 'BDF3' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = BDF3()
+
+        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 = BDF3(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 = BDF3()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+            
+            #test the stage iterator
+            self.assertEqual(t, solver.eval_stages[i])
+
+
+    def test_buffer(self):
+
+        solver = BDF3()
+
+        #perform some steps
+        for k in range(10):
+
+            #test bdf buffer length
+            buffer_length = len(solver.B)
+            self.assertEqual(buffer_length, k+1 if k < 3 else 3)
+            
+            #make one step
+            for i, t in enumerate(solver.stages(0, 1)):
+                success, err, scale = solver.step(0.0, t, 1)
+
+
+    def test_step(self):
+
+        solver = BDF3()
+
+        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 = BDF3(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, 1)
+
+
+
+class TestBDF4(unittest.TestCase):
+    """
+    Test the implementation of the 'BDF4' solver class
+    """
+
+    def test_init(self):
+
+        #test default initializtion
+        solver = BDF4()
+
+        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 = BDF4(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 = BDF4()
+
+        for i, t in enumerate(solver.stages(0, 1)):
+            
+            #test the stage iterator
+            self.assertEqual(t, solver.eval_stages[i])
+
+
+    def test_buffer(self):
+
+        solver = BDF4()
+
+        #perform some steps
+        for k in range(10):
+
+            #test bdf buffer length
+            buffer_length = len(solver.B)
+            self.assertEqual(buffer_length, k+1 if k < 4 else 4)
+            
+            #make one step
+            for i, t in enumerate(solver.stages(0, 1)):
+                success, err, scale = solver.step(0.0, t, 1)
+
+
+    def test_step(self):
+
+        solver = BDF4()
+
+        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 = BDF4(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, 1)
+
+
+
+
+
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)