pathsim 0.2.0__py3-none-any.whl

tests/utils/test_funcs.py

@@ -0,0 +1,143 @@
+########################################################################################
+##
+##                              TESTS FOR 'utils/funcs.py'
+##
+##                                Milan Rother 2023/24
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.utils.funcs import (
+    dict_to_array, 
+    array_to_dict, 
+    abs_error,
+    rel_error,
+    max_error,
+    max_error_dicts,
+    max_rel_error, 
+    max_rel_error_dicts,
+    numerical_jacobian,
+    auto_jacobian
+    )
+
+
+# TESTS ================================================================================
+
+class TestUtilsFuncs(unittest.TestCase):
+    """
+    test all the array-dict conversions and functions for error calculation
+    """
+
+    def test_abs_error(self):
+
+        self.assertEqual(abs_error(1.0, 2.0), 1.0)    
+        self.assertEqual(abs_error(2.0, 1.0), 1.0)
+        self.assertEqual(abs_error(2.0, 0.0), 2.0)
+        self.assertEqual(abs_error(0.0, 1.0), 1.0)
+
+
+    def test_rel_error(self):
+
+        #test fallback to abs error
+        self.assertEqual(rel_error(0.0, 1), 1)
+        self.assertEqual(rel_error(0.0, 0.1), 0.1)
+
+        #test a<b
+        self.assertEqual(rel_error(1.0, 2.0), 1.0)
+        
+        #test a>b
+        self.assertEqual(rel_error(2.0, 1.0), 0.5)
+
+
+    def test_max_error(self):
+        self.assertEqual(max_error([0.00139, 2.4, 87, 1, 97.8, 4.35], 
+                                   [1.00139, 1.4, 86, 2, 98.2, 33.35]), 
+                         29)
+
+
+    def test_max_rel_error(self):
+        self.assertEqual(max_rel_error([0.00139, 2.4, 87, 1, 97.8, 4.35], 
+                                       [1.00139, 1.4, 86, 2, 98.2, 33.35]), 
+                         1/0.00139)
+
+
+    def test_dict_to_array(self):
+
+        #test conversion
+        self.assertEqual(np.sum(np.abs(dict_to_array({0:12, 1:3.2, 2:31.0})-np.array([12, 3.2, 31.0]))), 0.0)
+
+        #test key sorting
+        self.assertEqual(np.sum(np.abs(dict_to_array({0:12, 2:3.2, 1:31.0}) - np.array([12, 31.0, 3.2]))), 0.0)
+        self.assertEqual(np.sum(np.abs(dict_to_array({1:12, 2:3.2, 3:31.0})- np.array([12, 3.2, 31.0]))), 0.0)
+
+        #test non uniform keys
+        self.assertEqual(np.sum(np.abs(dict_to_array({0:12, 2:3.2, 3:31.0}) - np.array([12, 3.2, 31.0]))), 0.0)
+
+
+    def test_array_to_dict(self):
+
+        #test scalar input
+        self.assertEqual(array_to_dict(4), {0:4})
+
+        #test array input
+        self.assertEqual(array_to_dict(np.array([12, 3.2, 31.0])), {0:12, 1:3.2, 2:31.0})
+        self.assertEqual(array_to_dict(np.array([2.0])), {0:2.0})
+
+
+    def test_max_rel_error_dicts(self):
+        self.assertEqual(max_rel_error_dicts({0:0.00139, 1:2.4, 2:87, 3:1, 4:97.8, 5:4.35}, 
+                                             {0:1.00139, 1:1.4, 2:86, 3:2, 4:98.2, 5:33.35}), 
+                         1/0.00139)
+
+    def test_max_error_dicts(self):
+        self.assertEqual(max_error_dicts({0:0.00139, 1:2.4, 2:87, 3:1, 4:97.8, 5:4.35}, 
+                                             {0:1.00139, 1:1.4, 2:86, 3:2, 4:98.2, 5:33.35}), 
+                         29)
+
+
+class TestJacobian(unittest.TestCase):
+    """
+    testing of numerical jacobian calculation
+    """
+
+    def test_numerical_jacobian(self):
+
+        #test scalar case
+        def _f(x): return x**2
+        def _df(x): return 2*x
+        self.assertAlmostEqual(numerical_jacobian(_f, 3), _df(3), 4)
+        self.assertAlmostEqual(numerical_jacobian(_f, -6.0), _df(-6.0), 4)
+        self.assertAlmostEqual(numerical_jacobian(_f, 100), _df(100), 3)
+
+        #test vectorial case
+        def _f(x): return np.array([np.cos(x[0]), np.sin(x[1])])
+        def _df(x): return np.array([[-np.sin(x[0]), 0.0], [0.0, np.cos(x[1])]])
+        self.assertAlmostEqual(np.sum(np.abs(numerical_jacobian(_f, np.ones(2)) - _df(np.ones(2)))), 0.0, 6)
+
+
+    def test_auto_jacobian(self):
+
+        #test scalar case
+        def _f(x): return x**2
+        def _df(x): return 2*x
+        _j = auto_jacobian(_f)
+        self.assertAlmostEqual(_j(3), _df(3), 6)
+        self.assertAlmostEqual(_j(-6.0), _df(-6.0), 6)
+        self.assertAlmostEqual(_j(100), _df(100), 3)
+
+        #test vectorial case
+        def _f(x): return np.array([np.cos(x[0]), np.sin(x[1])])
+        def _df(x): return np.array([[-np.sin(x[0]), 0.0], [0.0, np.cos(x[1])]])
+        _j = auto_jacobian(_f)
+        self.assertAlmostEqual(np.sum(np.abs(_j(np.ones(2)) - _df(np.ones(2)))), 0.0, 6)
+
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/utils/test_gilbert.py

@@ -0,0 +1,108 @@
+########################################################################################
+##
+##                                    TESTS FOR
+##                               'utils/gilbert.py'
+##
+##                                Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+from pathsim.utils.gilbert import gilbert_realization
+
+
+# HELPER FUNCTIONS =====================================================================
+
+def evaluate_statespace(s, A, B, C, D):
+    n = A.shape[0]
+    return np.dot(C, np.linalg.solve(s*np.eye(n) - A, B)) + D
+
+def evaluate_poleresidue(s, Poles, Residues, Const):
+    return np.sum([r/(s - p) for p, r in zip(Poles, Residues)], axis=0) + Const
+
+
+# TESTS ================================================================================
+
+class TestGilbertRealization(unittest.TestCase):
+    """
+    Test the implementation of the gilbert statespace realization
+    """
+
+    def assertArrayAlmostEqual(self, first, second, places=7, msg=None):
+        np.testing.assert_array_almost_equal(first, second, decimal=places, err_msg=msg)
+
+    def test_helpers(self):
+        A, B, C, D = np.array([[1]]), np.array([[1]]), np.array([[1]]), np.array([[1]])
+        self.assertArrayAlmostEqual(evaluate_statespace(0, A, B, C, D), np.array([[0]]))
+        self.assertArrayAlmostEqual(evaluate_statespace(1j, A, B, C, D), np.array([[1+1/(1j-1)]]))
+
+        Poles, Residues, Const = [1], [np.array([1])], np.array([[1]])
+        self.assertArrayAlmostEqual(evaluate_poleresidue(0, Poles, Residues, Const), np.array([[0]]))
+        self.assertArrayAlmostEqual(evaluate_poleresidue(1j, Poles, Residues, Const), np.array([[1+1/(1j-1)]]))
+
+    def test_siso_real_poles(self):
+        Poles = [-1.0, -2.0, -3.0]
+        Residues = [1.0, 2.0, 3.0]
+        Const = 0.5
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        for s in [0, 1j, 10j, 100j]:
+            ss_eval = evaluate_statespace(s, A, B, C, D)
+            pr_eval = evaluate_poleresidue(s, Poles, Residues, Const)
+            self.assertArrayAlmostEqual(ss_eval, pr_eval, places=12)
+
+    def test_siso_complex_poles(self):
+        Poles = [-1+1j, -1-1j, -2]
+        Residues = [1-0.5j, 1+0.5j, 2]
+        Const = 0.1
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        for s in [0, 1j, 10j, 100j]:
+            ss_eval = evaluate_statespace(s, A, B, C, D)
+            pr_eval = evaluate_poleresidue(s, Poles, Residues, Const)
+            self.assertArrayAlmostEqual(ss_eval, pr_eval, places=12)
+
+    def test_mimo_2x2(self):
+        Poles = [-1, -2, -3]
+        Residues = [np.array([[1, 2], [3, 4]]), 
+                    np.array([[2, 3], [4, 5]]), 
+                    np.array([[3, 4], [5, 6]])]
+        Const = np.array([[0.1, 0.2], [0.3, 0.4]])
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        for s in [0, 1j, 10j, 100j]:
+            ss_eval = evaluate_statespace(s, A, B, C, D)
+            pr_eval = evaluate_poleresidue(s, Poles, Residues, Const)
+            self.assertArrayAlmostEqual(ss_eval, pr_eval, places=12)
+
+    def test_mimo_3x2(self):
+        Poles = [-1+1j, -1-1j, -2]
+        Residues = [np.array([[1, 2], [3, 4], [5, 6]]), 
+                    np.array([[1, 2], [3, 4], [5, 6]]), 
+                    np.array([[2, 3], [4, 5], [6, 7]])]
+        Const = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        for s in [0, 1j, 10j, 100j]:
+            ss_eval = evaluate_statespace(s, A, B, C, D)
+            pr_eval = evaluate_poleresidue(s, Poles, Residues, Const)
+            self.assertArrayAlmostEqual(ss_eval, pr_eval, places=12)
+
+    def test_input_validation(self):
+
+        # Empty poles and residues
+        with self.assertRaises(ValueError):
+            gilbert_realization([], [], 0)  
+        
+        # Mismatched poles and residues
+        with self.assertRaises(ValueError):
+            gilbert_realization([1, 2], [np.array([1])], 0)  
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/utils/test_progresstracker.py

@@ -0,0 +1,144 @@
+########################################################################################
+##
+##                                     TESTS FOR 
+##                             'utils/progresstracker.py'
+##
+##                                Milan Rother 2023/24
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.utils.progresstracker import (
+    ProgressTracker
+    )
+
+
+# TESTS ================================================================================
+
+class TestProgressTracker(unittest.TestCase):
+    """
+    test the implementation of the 'ProgressTracker' class 
+    """
+
+
+    def test_iter_successful_5(self):
+
+        #tracker with log interval 5/100 %
+        tracker = ProgressTracker(log_interval=5)
+
+        #test if display percentages are correctly computed
+        self.assertEqual(tracker.display_percentages, 
+            [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100])
+
+        i, n = 0, 100
+
+        #iterate the tracker
+        for _ in tracker:
+            i += 1
+
+            #test tracker iteration condition
+            self.assertTrue(tracker.condition)
+
+            #check progress
+            tracker.check(progress=i/n, success=True)
+
+            #test tracker steps
+            self.assertEqual(tracker.steps, i)
+
+            #check successful steps tracker
+            self.assertEqual(tracker.successful_steps, i)
+
+
+    def test_iter_successful_10(self):
+
+        #tracker with log interval 10/100 %
+        tracker = ProgressTracker(log_interval=10)
+
+        #test if display percentages are correctly computed
+        self.assertEqual(tracker.display_percentages, 
+            [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
+
+        i, n = 0, 100
+
+        #iterate the tracker
+        for _ in tracker:
+            i += 1
+
+            #test tracker iteration condition
+            self.assertTrue(tracker.condition)
+
+            #check progress
+            tracker.check(progress=i/n, success=True)
+
+            #test tracker steps
+            self.assertEqual(tracker.steps, i)
+
+            #check successful steps tracker
+            self.assertEqual(tracker.successful_steps, i)
+
+
+    def test_iter_mixed_success_5(self):
+
+        #tracker with log interval 5/100 %
+        tracker = ProgressTracker(log_interval=5)
+
+        #test if display percentages are correctly computed
+        self.assertEqual(tracker.display_percentages, 
+            [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100])
+
+        i, j, n = 0, 50, 100
+
+        #iterate the tracker
+        for _ in tracker:
+            i += 1
+
+            #test tracker iteration condition
+            self.assertTrue(tracker.condition)
+
+            #check progress
+            tracker.check(progress=i/n, success=i>j)
+
+            #test tracker steps
+            self.assertEqual(tracker.steps, i)
+
+            #check successful steps tracker
+            self.assertEqual(tracker.successful_steps, max(0, i-j))
+
+
+    def test_iter_mixed_success_10(self):
+
+        #tracker with log interval 10/100 %
+        tracker = ProgressTracker(log_interval=10)
+
+        #test if display percentages are correctly computed
+        self.assertEqual(tracker.display_percentages, 
+            [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
+
+        i, j, n = 0, 50, 100
+
+        #iterate the tracker
+        for _ in tracker:
+            i += 1
+
+            #test tracker iteration condition
+            self.assertTrue(tracker.condition)
+
+            #check progress
+            tracker.check(progress=i/n, success=i>j)
+
+            #test tracker steps
+            self.assertEqual(tracker.steps, i)
+
+            #check successful steps tracker
+            self.assertEqual(tracker.successful_steps, max(0, i-j))
+
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/utils/test_realtimeplotter.py

@@ -0,0 +1,122 @@
+########################################################################################
+##
+##                                     TESTS FOR 
+##                             'utils/realtimeplotter.py'
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+from unittest.mock import patch, MagicMock
+import numpy as np
+
+from pathsim.utils.realtimeplotter import RealtimePlotter
+
+
+# TESTS ================================================================================
+
+class TestRealtimePlotter(unittest.TestCase):
+    """
+    test the implementation of the 'RealtimePlotter' class 
+    """
+
+    def setUp(self):
+        self.max_samples = 100
+        self.update_interval = 0.5
+        self.labels = ['Test 1', 'Test 2']
+        self.x_label = 'X Axis'
+        self.y_label = 'Y Axis'
+
+    @patch('pathsim.utils.realtimeplotter.plt')
+    def test_init(self, mock_plt):
+        mock_fig = MagicMock()
+        mock_ax = MagicMock()
+        mock_plt.subplots.return_value = (mock_fig, mock_ax)
+
+        plotter = RealtimePlotter(
+            max_samples=self.max_samples,
+            update_interval=self.update_interval,
+            labels=self.labels,
+            x_label=self.x_label,
+            y_label=self.y_label
+        )
+
+        self.assertEqual(plotter.max_samples, self.max_samples)
+        self.assertEqual(plotter.update_interval, self.update_interval)
+        self.assertEqual(plotter.labels, self.labels)
+        self.assertEqual(plotter.x_label, self.x_label)
+        self.assertEqual(plotter.y_label, self.y_label)
+
+        mock_plt.subplots.assert_called_once()
+        mock_ax.set_xlabel.assert_called_once_with(self.x_label)
+        mock_ax.set_ylabel.assert_called_once_with(self.y_label)
+        mock_ax.grid.assert_called_once_with(True)
+
+    @patch('pathsim.utils.realtimeplotter.plt')
+    @patch('pathsim.utils.realtimeplotter.time')
+    def test_update_all(self, mock_time, mock_plt):
+        mock_fig = MagicMock()
+        mock_ax = MagicMock()
+        mock_line = MagicMock()
+        mock_ax.plot.return_value = [mock_line]
+        mock_plt.subplots.return_value = (mock_fig, mock_ax)
+        mock_time.time.return_value = 0
+
+        plotter = RealtimePlotter(labels=self.labels)
+
+        x = np.array([1, 2, 3])
+        y = np.array([[1, 2, 3], [4, 5, 6]])
+
+        result = plotter.update_all(x, y)
+
+        self.assertTrue(result)
+        self.assertTrue(hasattr(plotter, 'data'))
+        self.assertTrue(hasattr(plotter, 'lines'))
+
+    @patch('pathsim.utils.realtimeplotter.plt')
+    @patch('pathsim.utils.realtimeplotter.time')
+    def test_update(self, mock_time, mock_plt):
+        mock_fig = MagicMock()
+        mock_ax = MagicMock()
+        mock_line = MagicMock()
+        mock_ax.plot.return_value = [mock_line]
+        mock_plt.subplots.return_value = (mock_fig, mock_ax)
+        mock_time.time.return_value = 0
+
+        plotter = RealtimePlotter(max_samples=5)
+
+        for i in range(10):
+            result = plotter.update(i, i)
+            self.assertTrue(result)
+
+        self.assertTrue(hasattr(plotter, 'data'))
+        self.assertTrue(hasattr(plotter, 'lines'))
+
+    @patch('pathsim.utils.realtimeplotter.plt')
+    def test_on_close(self, mock_plt):
+        mock_fig = MagicMock()
+        mock_ax = MagicMock()
+        mock_plt.subplots.return_value = (mock_fig, mock_ax)
+
+        plotter = RealtimePlotter()
+        plotter.on_close(None)
+        self.assertFalse(plotter.is_running)
+
+    @patch('pathsim.utils.realtimeplotter.plt')
+    def test_show(self, mock_plt):
+        mock_fig = MagicMock()
+        mock_ax = MagicMock()
+        mock_plt.subplots.return_value = (mock_fig, mock_ax)
+
+        plotter = RealtimePlotter()
+        plotter.show()
+        mock_plt.show.assert_called_with(block=False)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/utils/test_statespacerealizations.py

@@ -0,0 +1,107 @@
+########################################################################################
+##
+##                      TESTS FOR 'utils/statespacerealizations.py'
+##
+##                                Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+from pathsim.utils.statespacerealizations import gilbert_realization
+
+
+# HELPER FUNCTIONS =====================================================================
+
+def evaluate_statespace(s, A, B, C, D):
+    n = A.shape[0]
+    return np.dot(C, np.linalg.solve(s*np.eye(n) - A, B)) + D
+
+def evaluate_poleresidue(s, Poles, Residues, Const):
+    return np.sum([r/(s - p) for p, r in zip(Poles, Residues)], axis=0) + Const
+
+
+# TESTS ================================================================================
+
+class GilbertRealizationTest(unittest.TestCase):
+    """
+    Test the implementation of the gilbert statespace realization
+    """
+
+    def assertArrayAlmostEqual(self, first, second, places=7, msg=None):
+        np.testing.assert_array_almost_equal(first, second, decimal=places, err_msg=msg)
+
+    def test_helpers(self):
+        A, B, C, D = np.array([[1]]), np.array([[1]]), np.array([[1]]), np.array([[1]])
+        self.assertArrayAlmostEqual(evaluate_statespace(0, A, B, C, D), np.array([[0]]))
+        self.assertArrayAlmostEqual(evaluate_statespace(1j, A, B, C, D), np.array([[1+1/(1j-1)]]))
+
+        Poles, Residues, Const = [1], [np.array([1])], np.array([[1]])
+        self.assertArrayAlmostEqual(evaluate_poleresidue(0, Poles, Residues, Const), np.array([[0]]))
+        self.assertArrayAlmostEqual(evaluate_poleresidue(1j, Poles, Residues, Const), np.array([[1+1/(1j-1)]]))
+
+    def test_siso_real_poles(self):
+        Poles = [-1.0, -2.0, -3.0]
+        Residues = [1.0, 2.0, 3.0]
+        Const = 0.5
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        for s in [0, 1j, 10j, 100j]:
+            ss_eval = evaluate_statespace(s, A, B, C, D)
+            pr_eval = evaluate_poleresidue(s, Poles, Residues, Const)
+            self.assertArrayAlmostEqual(ss_eval, pr_eval, places=12)
+
+    def test_siso_complex_poles(self):
+        Poles = [-1+1j, -1-1j, -2]
+        Residues = [1-0.5j, 1+0.5j, 2]
+        Const = 0.1
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        for s in [0, 1j, 10j, 100j]:
+            ss_eval = evaluate_statespace(s, A, B, C, D)
+            pr_eval = evaluate_poleresidue(s, Poles, Residues, Const)
+            self.assertArrayAlmostEqual(ss_eval, pr_eval, places=12)
+
+    def test_mimo_2x2(self):
+        Poles = [-1, -2, -3]
+        Residues = [np.array([[1, 2], [3, 4]]), 
+                    np.array([[2, 3], [4, 5]]), 
+                    np.array([[3, 4], [5, 6]])]
+        Const = np.array([[0.1, 0.2], [0.3, 0.4]])
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        for s in [0, 1j, 10j, 100j]:
+            ss_eval = evaluate_statespace(s, A, B, C, D)
+            pr_eval = evaluate_poleresidue(s, Poles, Residues, Const)
+            self.assertArrayAlmostEqual(ss_eval, pr_eval, places=12)
+
+    def test_mimo_3x2(self):
+        Poles = [-1+1j, -1-1j, -2]
+        Residues = [np.array([[1, 2], [3, 4], [5, 6]]), 
+                    np.array([[1, 2], [3, 4], [5, 6]]), 
+                    np.array([[2, 3], [4, 5], [6, 7]])]
+        Const = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        for s in [0, 1j, 10j, 100j]:
+            ss_eval = evaluate_statespace(s, A, B, C, D)
+            pr_eval = evaluate_poleresidue(s, Poles, Residues, Const)
+            self.assertArrayAlmostEqual(ss_eval, pr_eval, places=12)
+
+    def test_input_validation(self):
+
+        # Empty poles and residues
+        with self.assertRaises(ValueError):
+            gilbert_realization([], [], 0)  
+        
+        # Mismatched poles and residues
+        with self.assertRaises(ValueError):
+            gilbert_realization([1, 2], [np.array([1])], 0)  
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)