TransferFunction _common_den rewrite - issue #194 (#206)

repagh · murrayrm · commit 7bed77f2526d · 2018-07-01T17:45:17.000-07:00
* replaced the _common_den function internals. Passes tests * make xferfcn.py python2 compatible again * working tf -> ss transformation now, also solved #111 * disabled MIMO test when no slycot * do not cancel pole/zero pairs before calculating pole() in xferfcn.py - for the above reason, do conversion on minreal'd xferfcn in statesp.py - add a test for not canceling pole/zero pairs when calculating pole() - add import of matlab in discrete_test.py * change testModred; that one did state removal on a system of which the selection of states was automatic
diff --git a/control/statesp.py b/control/statesp.py
@@ -757,7 +757,6 @@ def _convertToStateSpace(sys, **kw):
                                                   [1., 1., 1.]].
 
     """
-
     from .xferfcn import TransferFunction
     import itertools
     if isinstance(sys, StateSpace):
@@ -771,20 +770,17 @@ def _convertToStateSpace(sys, **kw):
         try:
             from slycot import td04ad
             if len(kw):
-                raise TypeError("If sys is a TransferFunction, _convertToStateSpace \
-    cannot take keywords.")
+                raise TypeError("If sys is a TransferFunction, "
+                                "_convertToStateSpace cannot take keywords.")
 
             # Change the numerator and denominator arrays so that the transfer
             # function matrix has a common denominator.
-            num, den = sys._common_den()
-            # Make a list of the orders of the denominator polynomials.
-            index = [len(den) - 1 for i in range(sys.outputs)]
-            # Repeat the common denominator along the rows.
-            den = array([den for i in range(sys.outputs)])
-            #! TODO: transfer function to state space conversion is still buggy!
-            #print num
-            #print shape(num)
-            ssout = td04ad('R',sys.inputs, sys.outputs, index, den, num,tol=0.0)
+            # matrices are also sized/padded to fit td04ad
+            num, den, denorder = sys.minreal()._common_den()
+
+            # transfer function to state space conversion now should work!
+            ssout = td04ad('C', sys.inputs, sys.outputs, 
+                           denorder, den, num, tol=0)
 
             states = ssout[0]
             return StateSpace(ssout[1][:states, :states],
diff --git a/control/tests/convert_test.py b/control/tests/convert_test.py
@@ -40,7 +40,7 @@ def setUp(self):
         # Set to True to print systems to the output.
         self.debug = False
         # get consistent results
-        np.random.seed(9)
+        np.random.seed(7)
 
     def printSys(self, sys, ind):
         """Print system to the standard output."""
@@ -141,10 +141,9 @@ def testConvert(self):
                             ssxfrm_real = ssxfrm_mag * np.cos(ssxfrm_phase)
                             ssxfrm_imag = ssxfrm_mag * np.sin(ssxfrm_phase)
                             np.testing.assert_array_almost_equal( \
-                                ssorig_real, ssxfrm_real)
+                            ssorig_real, ssxfrm_real)
                             np.testing.assert_array_almost_equal( \
-                                ssorig_imag, ssxfrm_imag)
-
+                            ssorig_imag, ssxfrm_imag)
                             #
                             # Make sure xform'd TF has same frequency response
                             #
@@ -198,8 +197,9 @@ def testTf2ssStaticMimo(self):
         """Regression: tf2ss for MIMO static gain"""
         import control
         # 2x3 TFM
-        gmimo = control.tf2ss(control.tf([[ [23],   [3],  [5] ], [ [-1],  [0.125],  [101.3] ]],
-                                         [[ [46], [0.1], [80] ], [  [2],   [-0.1],      [1] ]]))
+        gmimo = control.tf2ss(control.tf(
+                [[ [23],   [3],  [5] ], [ [-1],  [0.125],  [101.3] ]],
+                [[ [46], [0.1], [80] ], [  [2],   [-0.1],      [1] ]]))
         self.assertEqual(0, gmimo.states)
         self.assertEqual(3, gmimo.inputs)
         self.assertEqual(2, gmimo.outputs)
@@ -229,6 +229,21 @@ def testSs2tfStaticMimo(self):
         numref = np.asarray(d)[...,np.newaxis]
         np.testing.assert_array_equal(numref, np.array(gtf.num) / np.array(gtf.den))
 
+    def testTf2SsDuplicatePoles(self):
+        """Tests for "too few poles for MIMO tf #111" """
+        import control
+        try:
+            import slycot
+            num = [ [ [1], [0] ],
+                   [ [0], [1] ] ]
+
+            den = [ [ [1,0], [1] ],
+                [ [1],   [1,0] ] ]
+            g = control.tf(num, den)
+            s = control.ss(g)
+            np.testing.assert_array_equal(g.pole(), s.pole())
+        except ImportError:
+            print("Slycot not present, skipping")
 
 def suite():
    return unittest.TestLoader().loadTestsFromTestCase(TestConvert)
diff --git a/control/tests/discrete_test.py b/control/tests/discrete_test.py
@@ -6,6 +6,7 @@
 import unittest
 import numpy as np
 from control import *
+from control import matlab
 
 class TestDiscrete(unittest.TestCase):
     """Tests for the DiscreteStateSpace class."""
diff --git a/control/tests/matlab_test.py b/control/tests/matlab_test.py
@@ -396,9 +396,9 @@ def testBalred(self):
     @unittest.skipIf(not slycot_check(), "slycot not installed")
     def testModred(self):
         modred(self.siso_ss1, [1])
-        modred(self.siso_ss2 * self.siso_ss3, [0, 1])
-        modred(self.siso_ss3, [1], 'matchdc')
-        modred(self.siso_ss3, [1], 'truncate')
+        modred(self.siso_ss2 * self.siso_ss1, [0, 1])
+        modred(self.siso_ss1, [1], 'matchdc')
+        modred(self.siso_ss1, [1], 'truncate')
 
     @unittest.skipIf(not slycot_check(), "slycot not installed")
     def testPlace_varga(self):
diff --git a/control/tests/xferfcn_test.py b/control/tests/xferfcn_test.py
@@ -425,10 +425,16 @@ def testPoleMIMO(self):
             [[[1., 2.], [1., 3.]], [[1., 4., 4.], [1., 9., 14.]]])
         p = sys.pole()
 
-        np.testing.assert_array_almost_equal(p, [-7., -3., -2., -2.])
-
-    # Tests for TransferFunction.feedback.
+        np.testing.assert_array_almost_equal(p, [-2., -2., -7., -3., -2.])
 
+    @unittest.skipIf(not slycot_check(), "slycot not installed")
+    def testDoubleCancelingPoleSiso(self):
+        
+        H = TransferFunction([1,1],[1,2,1])
+        p = H.pole()
+        np.testing.assert_array_almost_equal(p, [-1, -1])
+    
+    # Tests for TransferFunction.feedback
     def testFeedbackSISO(self):
         """Test for correct SISO transfer function feedback."""
 
diff --git a/control/xferfcn.py b/control/xferfcn.py
