Merge branch 'extend-tf2scipylti' into array-matrix-tests

bnavigator · bnavigator · commit ab77e0283363 · 2020-08-03T00:55:30.000+02:00
diff --git a/control/statesp.py b/control/statesp.py
@@ -59,7 +59,8 @@
 from numpy.linalg import solve, eigvals, matrix_rank
 from numpy.linalg.linalg import LinAlgError
 import scipy as sp
-from scipy.signal import lti, cont2discrete
+from scipy.signal import cont2discrete
+from scipy.signal import StateSpace as signalStateSpace
 from warnings import warn
 from .lti import LTI, common_timebase, isdtime
 from . import config
@@ -802,26 +803,51 @@ def minreal(self, tol=0.0):
         else:
             return StateSpace(self)
 
-
-    # TODO: add discrete time check
-    def returnScipySignalLTI(self):
-        """Return a list of a list of scipy.signal.lti objects.
+    def returnScipySignalLTI(self, strict=True):
+        """Return a list of a list of SISO scipy.signal.lti objects.
 
         For instance,
 
         >>> out = ssobject.returnScipySignalLTI()
         >>> out[3][5]
 
-        is a signal.scipy.lti object corresponding to the transfer function from
-        the 6th input to the 4th output."""
+        is a signal.scipy.lti object corresponding to the transfer function
+        from the 6th input to the 4th output.
+
+        Parameters
+        ----------
+        strict : bool, optional
+            True (default):
+              `ssobject` must be continuous or discrete. `tfobject.dt` cannot
+              be None.
+            False:
+              if `ssobject.dt` is None, continuous time signal.StateSpace
+              objects are returned
+
+        Returns
+        -------
+        out : list of list of scipy.signal.StateSpace
+        """
+        if strict and self.dt is None:
+            raise ValueError("with strict=True, dt cannot be None")
+
+        if self.dt:
+            kwdt = {'dt': self.dt}
+        else:
+            # scipy convention for continuous time lti systems: call without
+            # dt keyword argument
+            kwdt = {}
 
         # Preallocate the output.
         out = [[[] for _ in range(self.inputs)] for _ in range(self.outputs)]
 
         for i in range(self.outputs):
             for j in range(self.inputs):
-                out[i][j] = lti(asarray(self.A), asarray(self.B[:, j]),
-                                asarray(self.C[i, :]), self.D[i, j])
+                out[i][j] = signalStateSpace(asarray(self.A),
+                                             asarray(self.B[:, j]),
+                                             asarray(self.C[i, :]),
+                                             self.D[i, j],
+                                             **kwdt)
 
         return out
 
diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py
@@ -9,8 +9,9 @@
 
 
 import numpy as np
-from numpy.linalg import solve
 import pytest
+
+from numpy.linalg import solve
 from scipy.linalg import eigvals, block_diag
 
 from control.statesp import StateSpace, _convertToStateSpace, drss, rss, tf2ss
@@ -698,3 +699,49 @@ def test_pole(self, states, outputs, inputs):
             assert abs(z) < 1
 
 
+class TestLTIConverter:
+    """Test the LTI system return function"""
+
+    @pytest.fixture
+    def mimoss(self, request):
+        """Test system with various dt values"""
+        n = 5
+        m = 3
+        p = 2
+        bx, bu = np.mgrid[1:n + 1, 1:m + 1]
+        cy, cx = np.mgrid[1:p + 1, 1:n + 1]
+        dy, du = np.mgrid[1:p + 1, 1:m + 1]
+        return StateSpace(np.eye(5),
+                          bx * bu,
+                          cy * cx,
+                          dy * du,
+                          request.param)
+
+    @pytest.mark.parametrize("mimoss",
+                             [None,
+                              0,
+                              0.1,
+                              1,
+                              True],
+                             indirect=True)
+    def test_returnScipySignalLTI(self, mimoss):
+        """Test returnScipySignalLTI method with strict=False"""
+        sslti = mimoss.returnScipySignalLTI(strict=False)
+        for i in range(2):
+            for j in range(3):
+                np.testing.assert_allclose(sslti[i][j].A, mimoss.A)
+                np.testing.assert_allclose(sslti[i][j].B, mimoss.B[:, j])
+                np.testing.assert_allclose(sslti[i][j].C, mimoss.C[i, :])
+                np.testing.assert_allclose(sslti[i][j].D, mimoss.D[i, j])
+                if mimoss.dt == 0:
+                    assert sslti[i][j].dt is None
+                else:
+                    assert sslti[i][j].dt == mimoss.dt
+
+    @pytest.mark.parametrize("mimoss", [None], indirect=True)
+    def test_returnScipySignalLTI_error(self, mimoss):
+        """Test returnScipySignalLTI method with dt=None and strict=True"""
+        with pytest.raises(ValueError):
+            mimoss.returnScipySignalLTI()
+        with pytest.raises(ValueError):
+            mimoss.returnScipySignalLTI(strict=True)
diff --git a/control/tests/xferfcn_test.py b/control/tests/xferfcn_test.py
@@ -957,3 +957,39 @@ def test_repr(self, Hargs, ref):
                 np.testing.assert_array_almost_equal(H.num[p][m], H2.num[p][m])
                 np.testing.assert_array_almost_equal(H.den[p][m], H2.den[p][m])
             assert H.dt == H2.dt
+
+    @pytest.fixture
+    def mimotf(self, request):
+        """Test system with various dt values"""
+        return TransferFunction([[[11], [12], [13]],
+                                 [[21], [22], [23]]],
+                                [[[1, -1]] * 3] * 2,
+                                request.param)
+
+    @pytest.mark.parametrize("mimotf",
+                             [None,
+                              0,
+                              0.1,
+                              1,
+                              True],
+                             indirect=True)
+    def test_returnScipySignalLTI(self, mimotf):
+        """Test returnScipySignalLTI method with strict=False"""
+        sslti = mimotf.returnScipySignalLTI(strict=False)
+        for i in range(2):
+            for j in range(3):
+                np.testing.assert_allclose(sslti[i][j].num, mimotf.num[i][j])
+                np.testing.assert_allclose(sslti[i][j].den, mimotf.den[i][j])
+                if mimotf.dt == 0:
+                    assert sslti[i][j].dt is None
+                else:
+                    assert sslti[i][j].dt == mimotf.dt
+
+    @pytest.mark.parametrize("mimotf", [None], indirect=True)
+    def test_returnScipySignalLTI_error(self, mimotf):
+        """Test returnScipySignalLTI method with dt=None and default strict=True"""
+        with pytest.raises(ValueError):
+            mimotf.returnScipySignalLTI()
+        with pytest.raises(ValueError):
+            mimotf.returnScipySignalLTI(strict=True)
+
diff --git a/control/xferfcn.py b/control/xferfcn.py
@@ -57,7 +57,8 @@
     polyadd, polymul, polyval, roots, sqrt, zeros, squeeze, exp, pi, \
     where, delete, real, poly, nonzero
 import scipy as sp
-from scipy.signal import lti, tf2zpk, zpk2tf, cont2discrete
+from scipy.signal import tf2zpk, zpk2tf, cont2discrete
+from scipy.signal import TransferFunction as signalTransferFunction
 from copy import deepcopy
 from warnings import warn
 from itertools import chain
@@ -788,7 +789,7 @@ def minreal(self, tol=None):
         # end result
         return TransferFunction(num, den, self.dt)
 
-    def returnScipySignalLTI(self):
+    def returnScipySignalLTI(self, strict=True):
         """Return a list of a list of scipy.signal.lti objects.
 
         For instance,
@@ -799,19 +800,38 @@ def returnScipySignalLTI(self):
         is a signal.scipy.lti object corresponding to the
         transfer function from the 6th input to the 4th output.
 
+        Parameters
+        ----------
+        strict : bool, optional
+            True (default):
+              `tfobject` must be continuous or discrete.
+              `tfobject.dt`cannot be None.
+            False:
+              if `tfobject.dt` is None, continuous time signal.TransferFunction
+              objects are is returned
+
+        Returns
+        -------
+        out : list of list of scipy.signal.TransferFunction
         """
+        if strict and self.dt is None:
+            raise ValueError("with strict=True, dt cannot be None")
 
-        # TODO: implement for discrete time systems
-        if self.dt != 0 and self.dt is not None:
-            raise NotImplementedError("Function not \
-                    implemented in discrete time")
+        if self.dt:
+            kwdt = {'dt': self.dt}
+        else:
+            # scipy convention for continuous time lti systems: call without
+            # dt keyword argument
+            kwdt = {}
 
         # Preallocate the output.
         out = [[[] for j in range(self.inputs)] for i in range(self.outputs)]
 
         for i in range(self.outputs):
             for j in range(self.inputs):
-                out[i][j] = lti(self.num[i][j], self.den[i][j])
+                out[i][j] = signalTransferFunction(self.num[i][j],
+                                                   self.den[i][j],
+                                                   **kwdt)
 
         return out
 
