pathsim 0.2.0__py3-none-any.whl

tests/blocks/test_block.py

@@ -0,0 +1,138 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                              'blocks._block.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks._block import Block
+
+
+# TESTS ================================================================================
+
+class TestBlock(unittest.TestCase):
+    """
+    Test the implementation of the base 'Block' class
+    """
+
+    def test_init(self):
+
+        B = Block()
+
+        #test default inputs and outputs
+        self.assertEqual(B.inputs, {0: 0.0})
+        self.assertEqual(B.outputs, {0: 0.0})
+
+        #test default engine
+        self.assertEqual(B.engine, None)
+
+
+    def test_len(self):
+
+        B = Block()
+
+        #test default len method
+        self.assertEqual(len(B), 1)
+            
+
+    def test_str(self):
+
+        B = Block()
+
+        #test default str method
+        self.assertEqual(str(B), "Block")
+
+
+    def test_getitem(self):
+
+        B = Block()
+
+        #test default getitem method (for connection creation)
+        self.assertEqual(B[0], (B, 0))
+        self.assertEqual(B[1], (B, 1))
+        self.assertEqual(B[2], (B, 2))
+
+        #test input validation
+        with self.assertRaises(ValueError): B[0.2]
+        with self.assertRaises(ValueError): B[1j]
+        with self.assertRaises(ValueError): B["a"]
+
+
+    def test_reset(self):
+
+        B = Block()
+
+        B.inputs = {0:0, 2:2, 1:1}
+        B.outputs = {1:1, 0:0, 2:2}
+
+        B.reset()
+
+        #test if inputs and outputs are reset correctly
+        self.assertEqual(B.inputs, {0:0.0, 1:0.0, 2:0.0})
+        self.assertEqual(B.outputs, {0:0.0, 1:0.0, 2:0.0})
+
+
+    def test_set(self):
+
+        B = Block()
+
+        B.set(0, 1)
+        self.assertEqual(B.inputs[0], 1)
+
+        B.set(0, 2)
+        self.assertEqual(B.inputs[0], 2)
+
+        B.set(2, 3)
+        self.assertEqual(B.inputs[2], 3)
+
+
+    def test_get(self):
+
+        B = Block()
+
+        B.outputs = {0:0, 2:2, 1:1}
+
+        self.assertEqual(B.get(0), 0)
+        self.assertEqual(B.get(1), 1)
+        self.assertEqual(B.get(2), 2)
+
+        #undefined output -> defaults to 0.0
+        self.assertEqual(B.get(100), 0.0)
+
+
+    def test_update(self):
+
+        B = Block()
+
+        #test default implementation 
+        self.assertEqual(B.update(None), 0.0)
+
+
+    def test_solve(self):
+
+        B = Block()
+
+        #test default implementation 
+        self.assertEqual(B.solve(None, None), 0.0)
+
+
+    def test_step(self):
+
+        B = Block()
+
+        #test default implementation 
+        self.assertEqual(B.step(None, None), (True, 0.0, 1.0))
+
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_delay.py

@@ -0,0 +1,122 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                              'blocks.delay.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.delay import Delay
+from pathsim.utils.adaptivebuffer import AdaptiveBuffer
+
+
+# TESTS ================================================================================
+
+class TestDelay(unittest.TestCase):
+    """
+    Test the implementation of the 'Delay' block class
+    """
+
+    def test_init(self):
+
+        #test specific initialization
+        D = Delay(tau=1)
+
+        self.assertTrue(isinstance(D._buffer, AdaptiveBuffer))
+        self.assertEqual(D.tau, 1)
+
+
+    def test_len(self):
+        
+        D = Delay()
+
+        #no passthrough
+        self.assertEqual(len(D), 0)
+
+
+    def test_str(self):
+
+        D = Delay()
+
+        #test default str method
+        self.assertEqual(str(D), "Delay")
+
+
+    def test_reset(self):
+
+        D = Delay(tau=100)
+
+        for t in range(10):
+            D.sample(t)
+
+        self.assertEqual(len(D._buffer), 10)    
+
+        D.reset()
+
+        #test if reset worked
+        self.assertEqual(len(D._buffer), 0)  
+        
+
+    def test_sample(self):
+
+        D = Delay(tau=100)
+
+        for t in range(10):
+
+            #test internal buffer length
+            self.assertEqual(len(D._buffer), t)
+
+            D.sample(t)
+
+
+    def test_update(self):
+
+        #test delay without interpolation
+        D = Delay(tau=10)
+
+        for t in range(100):
+
+            #test internal buffer length
+            self.assertEqual(len(D._buffer), t)
+
+            D.set(0, t)
+            D.sample(t)
+
+            err = D.update(t)
+
+            #test if error returns correctly
+            self.assertEqual(err, 0)
+
+            #test if delay is correctly applied
+            self.assertEqual(D.get(0), max(0, t-10))
+
+        #test delay with local interpolation
+        D = Delay(tau=10.5)
+
+        for t in range(100):
+
+            #test internal buffer length
+            self.assertEqual(len(D._buffer), t)
+
+            D.set(0, t)
+            D.sample(t)
+
+            err = D.update(t)
+
+            #test if error returns correctly
+            self.assertEqual(err, 0)
+
+            #test if delay is correctly applied
+            self.assertEqual(D.get(0), max(0, t-10.5))
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_differentiator.py

@@ -0,0 +1,102 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                          'blocks.differentiator.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.differentiator import Differentiator
+
+#base solver for testing
+from pathsim.solvers._solver import Solver 
+
+
+# TESTS ================================================================================
+
+class TestDifferentiator(unittest.TestCase):
+    """
+    Test the implementation of the 'Differentiator' block class
+    """
+
+    def test_init(self):
+
+        #test default initialization
+        D = Differentiator()
+        self.assertEqual(D.f_max, 1e2)
+        self.assertEqual(D.engine, None)
+
+        #test special initialization
+        D = Differentiator(f_max=1e3)
+        self.assertEqual(D.f_max, 1e3)
+
+
+    def test_len(self):
+
+        D = Differentiator()
+
+        #has direct passthrough
+        self.assertEqual(len(D), 1)
+
+
+    def test_str(self):
+
+        D = Differentiator()
+
+        #test default str method
+        self.assertEqual(str(D), "Differentiator")
+
+
+    def test_set_solver(self):
+
+        D = Differentiator()
+
+        #test that no solver is initialized
+        self.assertEqual(D.engine, None)
+
+        D.set_solver(Solver, tolerance_lte=1e-6)
+
+        #test that solver is now available
+        self.assertTrue(isinstance(D.engine, Solver))
+        self.assertEqual(D.engine.tolerance_lte, 1e-6)
+
+        D.set_solver(Solver, tolerance_lte=1e-3)
+
+        #test that solver tolerance is changed
+        self.assertEqual(D.engine.tolerance_lte, 1e-3)
+
+
+    def test_update(self):
+
+        D = Differentiator()
+        D.set_solver(Solver)
+
+        #test that input is zero
+        self.assertEqual(D.inputs[0], 0.0)
+
+        err = D.update(0)
+
+        #test if error is correctly 0
+        self.assertEqual(err, 0.0)
+
+        #test if state is retrieved correctly
+        self.assertEqual(D.get(0), 0.0)
+
+        D.set(0, 2)
+
+        err = D.update(0)
+
+        #test if error is correctly calculated
+        self.assertEqual(err, D.f_max*2)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_function.py

@@ -0,0 +1,165 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                            'blocks.function.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.function import Function
+
+
+# TESTS ================================================================================
+
+class TestFunction(unittest.TestCase):
+    """
+    Test the implementation of the 'Function' block class
+    """
+
+    def test_init(self):
+
+        def f(a):
+            return a**2
+        
+        F = Function(func=f)
+
+        #test if the function works
+        self.assertEqual(F.func(1), f(1))
+        self.assertEqual(F.func(2), f(2))
+        self.assertEqual(F.func(3), f(3))
+
+        #test input validation
+        with self.assertRaises(ValueError): 
+            F = Function(func=2)
+
+
+    def test_str(self):
+
+        F = Function()
+
+        #test default str method
+        self.assertEqual(str(F), "Function")
+
+
+    def test_update_siso(self):
+
+        def f(a):
+            return a**2
+        
+        F = Function(func=f)
+
+        #set block inputs
+        F.set(0, 3)
+
+        #update block
+        err = F.update(None)
+
+        #test if update was correct
+        self.assertEqual(F.get(0), f(3))
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = F.update(None)
+
+        #test error, now should be 0
+        self.assertEqual(err, 0)
+
+
+    def test_update_miso(self):
+
+        def f(a, b, c):
+            return a**2 + b - c
+        
+        F = Function(func=f)
+
+        #set block inputs
+        F.set(0, 3)
+        F.set(1, 2)
+        F.set(2, 1)
+
+        #update block
+        err = F.update(None)
+
+        #test if update was correct
+        self.assertEqual(F.get(0), f(3, 2, 1))
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = F.update(None)
+
+        #test error, now should be 0
+        self.assertEqual(err, 0)
+
+
+    def test_update_simo(self):
+
+        def f(a):
+            return a**2, 2*a, 1
+        
+        F = Function(func=f)
+
+        #set block inputs
+        F.set(0, 3)
+
+        #update block
+        err = F.update(None)
+
+        #test if update was correct
+        self.assertEqual(F.get(0), 9)
+        self.assertEqual(F.get(1), 6)
+        self.assertEqual(F.get(2), 1)
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = F.update(None)
+
+        #test error, now should be 0
+        self.assertEqual(err, 0)
+
+
+    def test_update_mimo(self):
+
+        def f(a, b, c):
+            return a**2-b, 3*c
+        
+        F = Function(func=f)
+
+        #set block inputs
+        F.set(0, 3)
+        F.set(1, 2)
+        F.set(2, 1)
+
+        #update block
+        err = F.update(None)
+
+        #test if update was correct
+        self.assertEqual(F.get(0), 7)
+        self.assertEqual(F.get(1), 3)
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = F.update(None)
+
+        #test error, now should be 0
+        self.assertEqual(err, 0)
+
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_integrator.py

@@ -0,0 +1,92 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                            'blocks.integrator.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.integrator import Integrator
+
+#base solver for testing
+from pathsim.solvers._solver import Solver 
+
+
+# TESTS ================================================================================
+
+class TestIntegrator(unittest.TestCase):
+    """
+    Test the implementation of the 'Integrator' block class
+    """
+
+    def test_init(self):
+
+        #test default initialization
+        I = Integrator()
+        self.assertEqual(I.initial_value, 0.0)
+        self.assertEqual(I.engine, None)
+
+        #test special initialization
+        I = Integrator(initial_value=1.0)
+        self.assertEqual(I.initial_value, 1.0)
+
+
+    def test_len(self):
+
+        I = Integrator()
+
+        #no direct passthrough
+        self.assertEqual(len(I), 0)
+
+
+    def test_str(self):
+
+        I = Integrator()
+
+        #test default str method
+        self.assertEqual(str(I), "Integrator")
+
+
+    def test_set_solver(self):
+
+        I = Integrator()
+
+        #test that no solver is initialized
+        self.assertEqual(I.engine, None)
+
+        I.set_solver(Solver, tolerance_lte=1e-6)
+
+        #test that solver is now available
+        self.assertTrue(isinstance(I.engine, Solver))
+        self.assertEqual(I.engine.tolerance_lte, 1e-6)
+
+        I.set_solver(Solver, tolerance_lte=1e-3)
+
+        #test that solver tolerance is changed
+        self.assertEqual(I.engine.tolerance_lte, 1e-3)
+
+
+    def test_update(self):
+
+        I = Integrator(initial_value=5.5)
+        I.set_solver(Solver)
+
+        err = I.update(0)
+
+        #test if error is correctly 0
+        self.assertEqual(err, 0.0)
+
+        #test if engine state is retrieved correctly
+        self.assertEqual(I.get(0), 5.5)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)