pathsim 0.2.0__py3-none-any.whl

tests/blocks/test_lti.py

@@ -0,0 +1,162 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                               'blocks.lti.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.lti import StateSpace, TransferFunction
+
+#base solver for testing
+from pathsim.solvers._solver import Solver 
+
+
+# TESTS ================================================================================
+
+class TestStateSpace(unittest.TestCase):
+    """
+    Test the implementation of the 'StateSpace' block class
+    """
+
+    def test_init(self):
+
+        #test default initialization
+        S = StateSpace()
+        self.assertEqual(S.initial_value, 0.0)
+        self.assertEqual(S.engine, None)
+        self.assertEqual(S.inputs, {0:0.0})
+        self.assertEqual(S.outputs, {0:0.0})
+
+        #test special initialization (siso)
+        S = StateSpace(A=np.eye(2), 
+                       B=np.ones(2), 
+                       C=np.ones(2), 
+                       D=1, 
+                       initial_value=None)
+        self.assertTrue(np.all(S.initial_value == np.zeros(2)))
+        self.assertEqual(S.inputs, {0:0.0})
+        self.assertEqual(S.outputs, {0:0.0})
+
+        #test special initialization (mimo)
+        S = StateSpace(A=np.eye(2), 
+                       B=np.ones((2, 2)), 
+                       C=np.ones((2, 2)), 
+                       D=np.ones((2, 2)), 
+                       initial_value=np.ones(2))
+        self.assertTrue(np.all(S.initial_value == np.ones(2)))
+        self.assertEqual(S.inputs, {0:0.0, 1:0.0})
+        self.assertEqual(S.outputs, {0:0.0, 1:0.0})
+
+
+    def test_len(self):
+        
+        #no direct passthrough (siso)
+        S = StateSpace(D=0)
+        self.assertEqual(len(S), 0)
+
+        #no direct passthrough (mimo)
+        S = StateSpace(D=np.zeros(2))
+        self.assertEqual(len(S), 0)
+
+        #direct passthrough (siso)
+        S = StateSpace(D=3)
+        self.assertEqual(len(S), 1)
+
+        #direct passthrough (mimo)
+        S = StateSpace(D=np.array([0, 5]))
+        self.assertEqual(len(S), 1)
+
+
+    def test_str(self):
+
+        S = StateSpace()
+
+        #test default str method
+        self.assertEqual(str(S), "StateSpace")
+
+
+    def test_set_solver(self):
+
+        S = StateSpace(initial_value=1.0)
+
+        #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))
+
+        #test that solver parametes have been set
+        self.assertEqual(S.engine.tolerance_lte, 1e-6)
+        self.assertEqual(S.engine.initial_value, 1.0)
+
+        #test that jacobian has been generated correctly
+        self.assertEqual(S.engine.jac(0, 0, 0), S.A)
+
+        S.set_solver(Solver, tolerance_lte=1e-3)
+
+        #test that solver tolerance is changed
+        self.assertEqual(S.engine.tolerance_lte, 1e-3)
+
+
+    def test_update(self):
+
+        S = StateSpace(initial_value=1.1)
+        S.set_solver(Solver)
+
+        #test if output is zero 
+        self.assertEqual(S.get(0), 0.0)
+        
+        S.set(0, 3.3)
+        err = S.update(0)
+
+        #test if error is correctly 0
+        self.assertGreater(err, 0.0)
+
+        #test if engine state is calculated correctly
+        self.assertAlmostEqual(S.get(0), 2.2, 8)
+
+
+class TtestTransferFunction(unittest.TestCase):
+    """
+    Test the implementation of the 'TransferFunction' block class
+
+    inherits most methods from the 'StateSpace' block, so only 
+    testing ot the initialization is required
+    """
+
+    def test_init(self):
+
+        #test default initialization        
+        with self.assertRaises(ValueError):
+            T = TransferFunction()
+
+        #test specific initialization (siso)
+        T = TransferFunction(Poles=2, Residues=0.5, Const=5.5)
+        self.assertEqual(T.A, 2)
+        self.assertEqual(T.B, 1)
+        self.assertEqual(T.C, 0.5)
+        self.assertEqual(T.D, 5.5)
+
+        #test specific initialization (mimo)
+        T = TransferFunction(Poles=np.array([1, 2]), 
+                             Residues=2*np.ones((2, 2)), 
+                             Const=np.ones(2))
+        self.assertTrue(np.all(T.A == np.diag(np.array([1, 2]))))
+        self.assertTrue(np.all(T.B == np.ones(2)))
+        self.assertTrue(np.all(T.C == 2*np.ones(2)))
+        self.assertTrue(np.all(T.D == np.ones(2)))
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_multiplier.py

@@ -0,0 +1,87 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                            'blocks.multiplier.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.multiplier import Multiplier
+
+
+# TESTS ================================================================================
+
+class TestMultiplier(unittest.TestCase):
+    """
+    Test the implementation of the 'Multiplier' block class
+    """
+
+    def test_str(self):
+
+        M = Multiplier()
+
+        #test default str method
+        self.assertEqual(str(M), "Multiplier")
+
+
+    def test_update_single(self):
+        
+        M = Multiplier()
+
+        #set block inputs
+        M.set(0, 1)
+
+        #update block
+        err = M.update(None)
+
+        #test if update was correct
+        self.assertEqual(M.get(0), 1)
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = M.update(None)
+
+        #test error, now should be 0
+        self.assertEqual(err, 0)
+
+
+    def test_update_multi(self):
+        
+        M = Multiplier()
+
+        #set block inputs
+        M.set(0, 1)
+        M.set(1, 2.0)
+        M.set(2, 3.1)
+
+        #update block
+        err = M.update(None)
+
+        #test if update was correct
+        self.assertEqual(M.get(0), 6.2)
+
+        #test if error was computed correctly
+        self.assertGreater(err, 0)
+
+        #update block again
+        err = M.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_ode.py

@@ -0,0 +1,125 @@
+########################################################################################
+##
+##                                     TESTS FOR 
+##                                  'blocks.ode.py'
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.ode import ODE
+
+#base solver for testing
+from pathsim.solvers._solver import Solver 
+
+
+# TESTS ================================================================================
+
+class TestODE(unittest.TestCase):
+    """
+    Test the implementation of the 'ODE' block class
+    """
+
+    def test_init(self):
+
+        #test default initialization
+        D = ODE()
+
+        self.assertEqual(D.engine, None)
+        self.assertEqual(D.jac, None)
+        self.assertEqual(D.initial_value, 0.0)
+
+        #test special initialization
+        def f(x, u, t): 
+            return -x**2
+        def j(x, u, t):
+            return -2*x
+
+        D = ODE(func=f, initial_value=1.0, jac=j)
+
+        #test that ode function is correctly assigned
+        self.assertEqual(D.func(1, 0, 0), f(1, 0, 0))
+        self.assertEqual(D.func(2, 0, 0), f(2, 0, 0))
+        self.assertEqual(D.func(3, 0, 0), f(3, 0, 0))
+
+        #test that ode jacobian is correctly assigned
+        self.assertEqual(D.jac(1, 0, 0), j(1, 0, 0))
+        self.assertEqual(D.jac(2, 0, 0), j(2, 0, 0))
+        self.assertEqual(D.jac(3, 0, 0), j(3, 0, 0))
+
+        self.assertEqual(D.initial_value, 1.0)
+
+
+    def test_len(self):
+
+        D = ODE()
+
+        #has direct passthrough
+        self.assertEqual(len(D), 0)
+
+
+    def test_str(self):
+
+        D = ODE()
+
+        #test default str method
+        self.assertEqual(str(D), "ODE")
+
+
+    def test_set_solver(self):
+
+        def f(x, u, t): 
+            return -x**2
+        def j(x, u, t):
+            return -2*x
+
+        D = ODE(func=f, initial_value=1.0, jac=j)
+
+        #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)
+
+        #test that solver function is correctly assigned
+        self.assertEqual(D.engine.func(1, 0, 0), f(1, 0, 0))
+        self.assertEqual(D.engine.func(2, 0, 0), f(2, 0, 0))
+        self.assertEqual(D.engine.func(3, 0, 0), f(3, 0, 0))
+
+        #test that solver jacobian is correctly assigned
+        self.assertEqual(D.engine.jac(1, 0, 0), j(1, 0, 0))
+        self.assertEqual(D.engine.jac(2, 0, 0), j(2, 0, 0))
+        self.assertEqual(D.engine.jac(3, 0, 0), j(3, 0, 0))
+
+        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 = ODE()
+        D.set_solver(Solver)
+
+        err = D.update(0)
+
+        #test if error is correctly 0
+        self.assertEqual(err, 0.0)
+
+        #test if engine state is retrieved correctly
+        self.assertEqual(D.get(0), 0.0)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_rng.py

@@ -0,0 +1,109 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                               'blocks.rng.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.rng import RNG
+
+
+# TESTS ================================================================================
+
+class TestRNG(unittest.TestCase):
+    """
+    Test the implementation of the 'RNG' block class
+    """
+
+    def test_init(self):
+
+        R = RNG()
+
+        self.assertEqual(R.sampling_rate, None)
+
+        R = RNG(sampling_rate=1)
+
+        self.assertEqual(R.n_samples, 0)
+        self.assertEqual(R.sampling_rate, 1)
+
+
+    def test_len(self):
+        
+        R = RNG()
+
+        #no passthrough
+        self.assertEqual(len(R), 0)
+
+
+    def test_str(self):
+
+        R = RNG()
+
+        #test default str method
+        self.assertEqual(str(R), "RNG")
+
+
+    def test_reset(self):
+
+        R = RNG()
+
+        for t in range(10):
+            R.sample(t)
+
+        R.reset()
+
+        #test if reset worked
+        self.assertEqual(R.n_samples, 0)
+        self.assertEqual(R.get(0), 0.0)
+
+
+    def test_sample(self):
+
+        #first test default 'sampling_rate=None'
+        R = RNG()
+
+        for t in range(10):
+
+            #test sample counter
+            self.assertEqual(R.n_samples, t)
+
+            old = R.get(0)
+
+            R.sample(t)
+
+            #test if new random value is sampled
+            self.assertNotEqual(old, R.get(0))
+
+
+        #next test finite sampling rate (samples every two seconds)
+        R = RNG(sampling_rate=0.5)
+
+        for t in range(10):
+
+            #test sample counter 
+            self.assertEqual(R.n_samples, t//2)
+
+            old = R.get(0)
+
+            R.sample(t)
+
+            if t%2 == 0:
+                #test if value remains the same is sampled
+                self.assertEqual(old, R.get(0))
+
+            else:
+                #test if new random value is sampled
+                self.assertNotEqual(old, R.get(0))
+                
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/blocks/test_scope.py

@@ -0,0 +1,196 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                              'blocks.scope.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.blocks.scope import Scope, RealtimeScope
+
+
+# TESTS ================================================================================
+
+class TestScope(unittest.TestCase):
+    """
+    Test the implementation of the 'Scope' block class
+    """
+
+    def test_init(self):
+
+        #test default initialization
+        S = Scope()
+
+        self.assertEqual(S.sampling_rate, None)
+        self.assertEqual(S.t_wait, 0.0)
+        self.assertEqual(S.labels, [])
+        self.assertEqual(S.recording, {})
+
+        #test specific initialization
+        S = Scope(sampling_rate=1, t_wait=1.0, labels=["1", "2"])
+
+        self.assertEqual(S.sampling_rate, 1)
+        self.assertEqual(S.t_wait, 1.0)
+        self.assertEqual(S.labels, ["1", "2"])
+
+
+    def test_len(self):
+        
+        S = Scope()
+
+        #no passthrough
+        self.assertEqual(len(S), 0)
+
+
+    def test_str(self):
+
+        S = Scope()
+
+        #test default str method
+        self.assertEqual(str(S), "Scope")
+
+
+    def test_reset(self):
+
+        S = Scope()
+
+        for t in range(10):
+
+            S.set(0, t)
+            S.sample(t)
+
+        #test that we have some recording
+        self.assertGreater(len(S.recording), 0)
+
+        S.reset()
+
+        #test if reset was successful
+        self.assertEqual(S.recording, {})
+
+
+    def test_sample(self):
+
+        #single input default initialization
+        S = Scope()
+
+        for t in range(10):
+
+            S.set(0, t)
+            S.sample(t)
+
+            #test most recent recording
+            self.assertEqual(S.recording[t], t)
+
+        #multi input default initialization
+        S = Scope()
+
+        for t in range(10):
+
+            S.set(0, t)
+            S.set(1, 2*t)
+            S.set(2, 3*t)
+            S.sample(t)
+
+            #test most recent recording
+            self.assertTrue(np.all(np.equal(S.recording[t], [t, 2*t, 3*t])))
+
+
+    def test_read(self):
+
+        _time = np.arange(10)
+
+        #single input default initialization
+        S = Scope()
+
+        for t in _time:
+
+            S.set(0, t)
+            S.sample(t)
+
+        time, result = S.read()
+
+        #test if time was recorded correctly
+        self.assertTrue(np.all(np.equal(time, _time)))
+
+        #test if input was recorded correctly
+        self.assertTrue(np.all(np.equal(result, _time)))
+
+        #multi input default initialization
+        S = Scope()
+
+        for t in _time:
+
+            S.set(0, t)
+            S.set(1, 2*t)
+            S.set(2, 3*t)
+            S.sample(t)
+
+        time, result = S.read()
+
+        #test if time was recorded correctly
+        self.assertTrue(np.all(np.equal(time, _time)))
+
+        #test if multi input was recorded correctly
+        self.assertTrue(np.all(np.equal(result, [_time, 2*_time, 3*_time])))
+
+
+    def test_sampling_rate(self):
+
+        _time = np.arange(10)
+
+        #single input special sampling rate
+        S = Scope(sampling_rate=0.5)
+
+        for t in _time:
+
+            S.set(0, t)
+            S.sample(t)
+
+        time, result = S.read()
+
+        #test if time was recorded correctly
+        self.assertTrue(np.all(np.equal(time, _time[1::2])))
+
+        #test if input was recorded correctly
+        self.assertTrue(np.all(np.equal(result, _time[1::2])))
+
+
+    def test_t_wait(self):
+
+        _time = np.arange(10)
+
+        #single input special t_wait
+        S = Scope(t_wait=5)
+
+        for t in _time:
+
+            S.set(0, t)
+            S.sample(t)
+
+        time, result = S.read()
+
+        #test if time was recorded correctly
+        self.assertTrue(np.all(np.equal(time, _time[5:])))
+
+        #test if input was recorded correctly
+        self.assertTrue(np.all(np.equal(result, _time[5:])))
+
+
+class TestRealtimeScope(unittest.TestCase):
+    """
+    Test the implementation of the 'RealtimeScope' block class
+    """
+
+    pass #no tests implemented yet, since it just inherits from 'Scope' and is not critical
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)