python-control · murrayrm · Apr 16, 2022 · Mar 18, 2022 · Mar 23, 2022 · Mar 20, 2022
diff --git a/.github/workflows/python-package-conda.yml b/.github/workflows/python-package-conda.yml
@@ -4,18 +4,20 @@ on: [push, pull_request]
 
 jobs:
   test-linux:
-    name: Python ${{ matrix.python-version }}${{ matrix.slycot && format(' with Slycot from {0}', matrix.slycot) || ' without Slycot' }}${{ matrix.array-and-matrix == 1 && ', array and matrix' || '' }}
+    name: Python ${{ matrix.python-version }}${{ matrix.slycot && format(' with Slycot from {0}', matrix.slycot) || ' without Slycot' }}${{ matrix.pandas && ', with pandas' || '' }}${{ matrix.array-and-matrix == 1 && ', array and matrix' || '' }}
     runs-on: ubuntu-latest
 
     strategy:
       max-parallel: 5
       matrix:
         python-version: [3.7, 3.9]
         slycot: ["", "conda"]
+        pandas: [""]
         array-and-matrix: [0]
         include:
           - python-version: 3.9
             slycot: conda
+            pandas: conda
             array-and-matrix: 1
 
     steps:
@@ -41,6 +43,9 @@ jobs:
         if [[ '${{matrix.slycot}}' == 'conda' ]]; then
           conda install -c conda-forge slycot
         fi
+        if [[ '${{matrix.pandas}}' == 'conda' ]]; then
+          conda install -c conda-forge pandas
+        fi
 
     - name: Test with pytest
       env:

diff --git a/control/__init__.py b/control/__init__.py
@@ -55,6 +55,7 @@
 from .margins import *
 from .mateqn import *
 from .modelsimp import *
+from .namedio import *
 from .nichols import *
 from .phaseplot import *
 from .pzmap import *

diff --git a/control/canonical.py b/control/canonical.py
@@ -2,7 +2,7 @@
 # RMM, 10 Nov 2012
 
 from .exception import ControlNotImplemented, ControlSlycot
-from .lti import issiso
+from .namedio import issiso
 from .statesp import StateSpace, _convert_to_statespace
 from .statefbk import ctrb, obsv
 

diff --git a/control/dtime.py b/control/dtime.py
@@ -47,7 +47,7 @@
 
 """
 
-from .lti import isctime
+from .namedio import isctime
 from .statesp import StateSpace
 
 __all__ = ['sample_system', 'c2d']

diff --git a/control/exception.py b/control/exception.py
@@ -71,3 +71,16 @@ def slycot_check():
         except:
             slycot_installed = False
     return slycot_installed
+
+
+# Utility function to see if pandas is installed
+pandas_installed = None
+def pandas_check():
+    global pandas_installed
+    if pandas_installed is None:
+        try:
+            import pandas
+            pandas_installed = True
+        except:
+            pandas_installed = False
+    return pandas_installed
diff --git a/control/flatsys/flatsys.py b/control/flatsys/flatsys.py
@@ -156,6 +156,11 @@ def __init__(self,
 
         # Save the length of the flat flag
 
+    def __str__(self):
+        return f"{NonlinearIOSystem.__str__(self)}\n\n" \
+            + f"Forward: {self.forward}\n" \
+            + f"Reverse: {self.reverse}"
+
     def forward(self, x, u, params={}):
 
         """Compute the flat flag given the states and input.

diff --git a/control/flatsys/linflat.py b/control/flatsys/linflat.py
@@ -140,3 +140,13 @@ def reverse(self, zflag, params):
         x = self.Tinv @ z
         u = zflag[0][-1] - self.F @ z
         return np.reshape(x, self.nstates), np.reshape(u, self.ninputs)
+
+    # Update function
+    def _rhs(self, t, x, u, params={}):
+        # Use LinearIOSystem._rhs instead of default (MRO) NonlinearIOSystem
+        return LinearIOSystem._rhs(self, t, x, u)
+
+    # output function
+    def _out(self, t, x, u, params={}):
+        # Use LinearIOSystem._out instead of default (MRO) NonlinearIOSystem
+        return LinearIOSystem._out(self, t, x, u)
diff --git a/control/flatsys/systraj.py b/control/flatsys/systraj.py
@@ -37,6 +37,7 @@
 # SUCH DAMAGE.
 
 import numpy as np
+from ..timeresp import TimeResponseData
 
 class SystemTrajectory:
     """Class representing a system trajectory.
@@ -117,3 +118,75 @@ def eval(self, tlist):
                 self.system.reverse(zflag, self.params)
 
         return xd, ud
+
+    # Return the system trajectory as a TimeResponseData object
+    def response(self, tlist, transpose=False, return_x=False, squeeze=None):
+        """Return the trajectory of a system as a TimeResponseData object
+
+        Evaluate the trajectory at a list of time points, returning the state
+        and input vectors for the trajectory:
+
+            response = traj.response(tlist)
+            time, yd, ud = response.time, response.outputs, response.inputs
+
+        Parameters
+        ----------
+        tlist : 1D array
+            List of times to evaluate the trajectory.
+
+        transpose : bool, optional
+            If True, transpose all input and output arrays (for backward
+            compatibility with MATLAB and :func:`scipy.signal.lsim`).
+            Default value is False.
+
+        return_x : bool, optional
+            If True, return the state vector when assigning to a tuple
+            (default = False).  See :func:`forced_response` for more details.
+
+        squeeze : bool, optional
+            By default, if a system is single-input, single-output (SISO) then
+            the output response is returned as a 1D array (indexed by time).
+            If squeeze=True, remove single-dimensional entries from the shape
+            of the output even if the system is not SISO. If squeeze=False,
+            keep the output as a 3D array (indexed by the output, input, and
+            time) even if the system is SISO. The default value can be set
+            using config.defaults['control.squeeze_time_response'].
+
+        Returns
+        -------
+        results : TimeResponseData
+            Time response represented as a :class:`TimeResponseData` object
+            containing the following properties:
+
+            * time (array): Time values of the output.
+
+            * outputs (array): Response of the system.  If the system is SISO
+              and squeeze is not True, the array is 1D (indexed by time).  If
+              the system is not SISO or ``squeeze`` is False, the array is 3D
+              (indexed by the output, trace, and time).
+
+            * states (array): Time evolution of the state vector, represented
+              as either a 2D array indexed by state and time (if SISO) or a 3D
+              array indexed by state, trace, and time.  Not affected by
+              ``squeeze``.
+
+            * inputs (array): Input(s) to the system, indexed in the same
+              manner as ``outputs``.
+
+            The return value of the system can also be accessed by assigning
+            the function to a tuple of length 2 (time, output) or of length 3
+            (time, output, state) if ``return_x`` is ``True``.
+
+        """
+        # Compute the state and input response using the eval function
+        sys = self.system
+        xout, uout = self.eval(tlist)
+        yout = np.array([
+            sys.output(tlist[i], xout[:, i], uout[:, i])
+            for i in range(len(tlist))]).transpose()
+
+        return TimeResponseData(
+            tlist, yout, xout, uout, issiso=sys.issiso(),
+            input_labels=sys.input_labels, output_labels=sys.output_labels,
+            state_labels=sys.state_labels,
+            transpose=transpose, return_x=return_x, squeeze=squeeze)