rewrite some tests with complex state matrices

lytex · lytex · commit 235a92b888b5 · 2020-02-09T21:53:12.000+01:00
diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py
@@ -21,15 +21,15 @@ def setUp(self):
         """Set up a MIMO system to test operations on."""
 
         # sys1: 3-states square system (2 inputs x 2 outputs)
-        A322 = [[-3., 4., 2.],
+        A322 = [[-3j, 4j, 2.],
                 [-1., -3., 0.],
-                [2., 5., 3.]]
+                [2j, 5j, 3.]]
         B322 = [[1., 4.],
-                [-3., -3.],
+                [-3j, -3.],
                 [-2., 1.]]
-        C322 = [[4., 2., -3.],
+        C322 = [[4., 2j, -3.],
                 [1., 4., 3.]]
-        D322 = [[-2., 4.],
+        D322 = [[-2j, 4.],
                 [0., 1.]]
         self.sys322 = StateSpace(A322, B322, C322, D322)
 
@@ -90,9 +90,9 @@ def test_pole(self):
         """Evaluate the poles of a MIMO system."""
 
         p = np.sort(self.sys322.pole())
-        true_p = np.sort([3.34747678408874,
-                          -3.17373839204437 + 1.47492908003839j,
-                          -3.17373839204437 - 1.47492908003839j])
+        true_p = np.sort([-0.000000000000002 - 3.631067038076226j,
+                          -3.345427524119811 + 0.315533519038114j,
+                           3.345427524119812 + 0.315533519038115j])
 
         np.testing.assert_array_almost_equal(p, true_p)
 
@@ -117,20 +117,23 @@ def test_zero_siso(self):
 
         np.testing.assert_almost_equal(true_z, z)
 
-    @unittest.skipIf(not slycot_check(), "slycot not installed")
+    # @unittest.skipIf(not slycot_check(), "slycot not installed")
     def test_zero_mimo_sys322_square(self):
         """Evaluate the zeros of a square MIMO system."""
 
         z = np.sort(self.sys322.zero())
-        true_z = np.sort([44.41465, -0.490252, -5.924398])
+        true_z = np.sort([26.269442405839197 -17.632596605469434j,
+                          6.573387902319676 + 1.272834429979537j,
+                          -3.842830308158862 - 4.640237824510066j])
         np.testing.assert_array_almost_equal(z, true_z)
 
-    @unittest.skipIf(not slycot_check(), "slycot not installed")
+    # @unittest.skipIf(not slycot_check(), "slycot not installed")
     def test_zero_mimo_sys222_square(self):
         """Evaluate the zeros of a square MIMO system."""
 
         z = np.sort(self.sys222.zero())
-        true_z = np.sort([-10.568501,   3.368501])
+        true_z = np.sort([ -6.904778467102364 + 1.237894313717807j,
+                            4.304778467102365 + 2.162105686282194j])
         np.testing.assert_array_almost_equal(z, true_z)
 
     @unittest.skipIf(not slycot_check(), "slycot not installed")
@@ -144,11 +147,11 @@ def test_zero_mimo_sys623_non_square(self):
     def test_add_ss(self):
         """Add two MIMO systems."""
 
-        A = [[-3., 4., 2., 0., 0.], [-1., -3., 0., 0., 0.],
-             [2., 5., 3., 0., 0.], [0., 0., 0., 4., 1.], [0., 0., 0., 2., -3.]]
-        B = [[1., 4.], [-3., -3.], [-2., 1.], [5., 2.], [-3., -3.]]
-        C = [[4., 2., -3., 2., -4.], [1., 4., 3., 0., 1.]]
-        D = [[1., 6.], [1., 0.]]
+        A = [[-3j, 4j, 2., 0., 0.], [-1., -3., 0., 0., 0.],
+            [2j, 5j, 3., 0., 0.], [0., 0., 0., 4., 1j], [0., 0., 0., 2j, -3.]]
+        B = [[1., 4.], [-3j, -3.], [-2., 1.], [5., 2.], [-3j, -3]]
+        C = [[4., 2j, -3., 2., -4.], [1., 4., 3., 0., 1j]]
+        D = [[1j, 4+2j], [1., 0.]]
 
         sys = self.sys322 + self.sys222
 
@@ -160,11 +163,11 @@ def test_add_ss(self):
     def test_subtract_ss(self):
         """Subtract two MIMO systems."""
 
-        A = [[-3., 4., 2., 0., 0.], [-1., -3., 0., 0., 0.],
-             [2., 5., 3., 0., 0.], [0., 0., 0., 4., 1.], [0., 0., 0., 2., -3.]]
-        B = [[1., 4.], [-3., -3.], [-2., 1.], [5., 2.], [-3., -3.]]
-        C = [[4., 2., -3., -2., 4.], [1., 4., 3., 0., -1.]]
-        D = [[-5., 2.], [-1., 2.]]
+        A = [[-3j, 4j, 2., 0. ,0.], [-1., -3., 0., 0., 0.],
+            [2j, 5j, 3., 0., 0., ], [0., 0., 0., 4., 1j], [0., 0., 0., 2j, -3.]]
+        B = [[1., 4.], [-3j, -3.], [-2., 1.], [5., 2.], [-3j, -3.]]
+        C = [[4., 2j, -3., -2., 4.], [1., 4., 3., 0., -1j]]
+        D = [[5j, 4-2j], [-1., 2.]]
 
         sys = self.sys322 - self.sys222
 
@@ -176,12 +179,11 @@ def test_subtract_ss(self):
     def test_multiply_ss(self):
         """Multiply two MIMO systems."""
 
-        A = [[4., 1., 0., 0., 0.], [2., -3., 0., 0., 0.], [2., 0., -3., 4., 2.],
-             [-6., 9., -1., -3., 0.], [-4., 9., 2., 5., 3.]]
-        B = [[5., 2.], [-3., -3.], [7., -2.], [-12., -3.], [-5., -5.]]
-        C = [[-4., 12., 4., 2., -3.], [0., 1., 1., 4., 3.]]
-        D = [[-2., -8.], [1., -1.]]
-
+        A = [[-3j, 4j, 2., 2., -4+4j], [-1., -3., 0., -6j, 9j], [2j, 5j, 3., -4., 8+1j],
+             [0., 0., 0., 4., 1j], [0., 0., 0., 2j, -3.]]
+        B = [[4+3j, -4+2j], [6., 9.], [1-6j, -1-4j], [5., 2.], [-3j, -3.]]
+        C = [[4., 2j, -3., -4j, 12j], [1., 4., 3., 0., 1j]]
+        D = [[10., 0.], [1., -1.]]
         sys = self.sys322 * self.sys222
 
         np.testing.assert_array_almost_equal(sys.A, A)
@@ -219,7 +221,7 @@ def test_evalfr(self):
             assert len(w) == 1
             assert issubclass(w[-1].category, PendingDeprecationWarning)
 
-    @unittest.skipIf(not slycot_check(), "slycot not installed")
+    # @unittest.skipIf(not slycot_check(), "slycot not installed")
     def test_freq_resp(self):
         """Evaluate the frequency response at multiple frequencies."""
 
