python-control
diff --git a/‎.github/workflows/python-package-conda.yml‎
Lines changed: 1 addition & 0 deletions b/‎.github/workflows/python-package-conda.yml‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎control/modelsimp.py‎
Lines changed: 2 additions & 12 deletions b/‎control/modelsimp.py‎
Lines changed: 2 additions & 12 deletions
diff --git a/‎control/rlocus.py‎
Lines changed: 82 additions & 26 deletions b/‎control/rlocus.py‎
Lines changed: 82 additions & 26 deletions
diff --git a/‎control/tests/modelsimp_test.py‎
Lines changed: 7 additions & 11 deletions b/‎control/tests/modelsimp_test.py‎
Lines changed: 7 additions & 11 deletions
@@ -4,6 +4,7 @@ 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' || '' }}
     runs-on: ubuntu-latest
 
     strategy:
 
@@ -395,7 +395,7 @@ def era(YY, m, n, nin, nout, r):
     raise NotImplementedError('This function is not implemented yet.')
 
 
-def markov(Y, U, m=None, transpose=None):
+def markov(Y, U, m=None, transpose=False):
     """Calculate the first `m` Markov parameters [D CB CAB ...]
     from input `U`, output `Y`.
 
@@ -424,8 +424,7 @@ def markov(Y, U, m=None, transpose=None):
         Number of Markov parameters to output.  Defaults to len(U).
     transpose : bool, optional
         Assume that input data is transposed relative to the standard
-        :ref:`time-series-convention`. The default value is true for
-        backward compatibility with legacy code.
+        :ref:`time-series-convention`. Default value is False.
 
     Returns
     -------
@@ -456,15 +455,6 @@ def markov(Y, U, m=None, transpose=None):
     >>> H = markov(Y, U, 3, transpose=False)
 
     """
-    # Check on the specified format of the input
-    if transpose is None:
-        # For backwards compatibility, assume time series in rows but warn user
-        warnings.warn(
-            "Time-series data assumed to be in rows. This will change in a "
-            "future release.  Use `transpose=True` to preserve current "
-            "behavior.")
-        transpose = True
-
     # Convert input parameters to 2D arrays (if they aren't already)
     Umat = np.array(U, ndmin=2)
     Ymat = np.array(Y, ndmin=2)
 
@@ -222,6 +222,14 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None,
         ax.set_xlabel('Real')
         ax.set_ylabel('Imaginary')
 
+        # Set up the limits for the plot
+        # Note: need to do this before computing grid lines
+        if xlim:
+            ax.set_xlim(xlim)
+        if ylim:
+            ax.set_ylim(ylim)
+        # Draw the grid
         if grid and sisotool:
             if isdtime(sys, strict=True):
                 zgrid(ax=ax)
@@ -236,14 +244,9 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None,
             ax.axhline(0., linestyle=':', color='k', zorder=-20)
             ax.axvline(0., linestyle=':', color='k', zorder=-20)
             if isdtime(sys, strict=True):
-                ax.add_patch(plt.Circle((0,0), radius=1.0,
-                     linestyle=':', edgecolor='k', linewidth=1.5,
-                     fill=False, zorder=-20))
-
-        if xlim:
-            ax.set_xlim(xlim)
-        if ylim:
-            ax.set_ylim(ylim)
+                ax.add_patch(plt.Circle(
+                    (0, 0), radius=1.0, linestyle=':', edgecolor='k',
+                    linewidth=1.5, fill=False, zorder=-20))
 
     return mymat, kvect
 
@@ -642,16 +645,21 @@ def _sgrid_func(fig=None, zeta=None, wn=None):
         ax = fig.gca()
     else:
         ax = fig.axes[1]
+
+    # Get locator function for x-axis tick marks
     xlocator = ax.get_xaxis().get_major_locator()
 
+    # Decide on the location for the labels (?)
     ylim = ax.get_ylim()
     ytext_pos_lim = ylim[1] - (ylim[1] - ylim[0]) * 0.03
     xlim = ax.get_xlim()
     xtext_pos_lim = xlim[0] + (xlim[1] - xlim[0]) * 0.0
 
+    # Create a list of damping ratios, if needed
     if zeta is None:
         zeta = _default_zetas(xlim, ylim)
 
+    # Figure out the angles for the different damping ratios
     angles = []
     for z in zeta:
         if (z >= 1e-4) and (z <= 1):
@@ -661,11 +669,8 @@ def _sgrid_func(fig=None, zeta=None, wn=None):
     y_over_x = np.tan(angles)
 
     # zeta-constant lines
-
-    index = 0
-
-    for yp in y_over_x:
-        ax.plot([0, xlocator()[0]], [0, yp*xlocator()[0]], color='gray',
+    for index, yp in enumerate(y_over_x):
+        ax.plot([0, xlocator()[0]], [0, yp * xlocator()[0]], color='gray',
                 linestyle='dashed', linewidth=0.5)
         ax.plot([0, xlocator()[0]], [0, -yp * xlocator()[0]], color='gray',
                 linestyle='dashed', linewidth=0.5)
@@ -679,45 +684,96 @@ def _sgrid_func(fig=None, zeta=None, wn=None):
                 ytext_pos = ytext_pos_lim
             ax.annotate(an, textcoords='data', xy=[xtext_pos, ytext_pos],
                         fontsize=8)
-        index += 1
     ax.plot([0, 0], [ylim[0], ylim[1]],
             color='gray', linestyle='
9E81
;dashed', linewidth=0.5)
 
-    angles = np.linspace(-90, 90, 20)*np.pi/180
+    # omega-constant lines
+    angles = np.linspace(-90, 90, 20) * np.pi/180
     if wn is None:
         wn = _default_wn(xlocator(), ylim)
 
     for om in wn:
         if om < 0:
-            yp = np.sin(angles)*np.abs(om)
-            xp = -np.cos(angles)*np.abs(om)
-            ax.plot(xp, yp, color='gray',
-                    linestyle='dashed', linewidth=0.5)
-            an = "%.2f" % -om
-            ax.annotate(an, textcoords='data', xy=[om, 0], fontsize=8)
+            # Generate the lines for natural frequency curves
+            yp = np.sin(angles) * np.abs(om)
+            xp = -np.cos(angles) * np.abs(om)
+
+            # Plot the natural frequency contours
+            ax.plot(xp, yp, color='gray', linestyle='dashed', linewidth=0.5)
+
+            # Annotate the natural frequencies by listing on x-axis
+            # Note: need to filter values for proper plotting in Jupyter
+            if (om > xlim[0]):
+                an = "%.2f" % -om
+                ax.annotate(an, textcoords='data', xy=[om, 0], fontsize=8)
 
 
 def _default_zetas(xlim, ylim):
-    """Return default list of damping coefficients"""
-    sep1 = -xlim[0]/4
+    """Return default list of damping coefficients
+
+    This function computes a list of damping coefficients based on the limits
+    of the graph.  A set of 4 damping coefficients are computed for the x-axis
+    and a set of three damping coefficients are computed for the y-axis
+    (corresponding to the normal 4:3 plot aspect ratio in `matplotlib`?).
+
+    Parameters
+    ----------
+    xlim : array_like
+        List of x-axis limits [min, max]
+    ylim : array_like
+        List of y-axis limits [min, max]
+
+    Returns
+    -------
+    zeta : list
+        List of default damping coefficients for the plot
+
+    """
+    # Damping coefficient lines that intersect the x-axis
+    sep1 = -xlim[0] / 4
     ang1 = [np.arctan((sep1*i)/ylim[1]) for i in np.arange(1, 4, 1)]
+
+    # Damping coefficient lines that intersection the y-axis
     sep2 = ylim[1] / 3
     ang2 = [np.arctan(-xlim[0]/(ylim[1]-sep2*i)) for i in np.arange(1, 3, 1)]
 
+    # Put the lines together and add one at -pi/2 (negative real axis)
     angles = np.concatenate((ang1, ang2))
     angles = np.insert(angles, len(angles), np.pi/2)
+
+    # Return the damping coefficients corresponding to these angles
     zeta = np.sin(angles)
     return zeta.tolist()
 
 
 def _default_wn(xloc, ylim):
-    """Return default wn for root locus plot"""
+    """Return default wn for root locus plot
+
+    This function computes a list of natural frequencies based on the grid
+    parameters of the graph.
+
+    Parameters
+    ----------
+    xloc : array_like
+        List of x-axis tick values
+    ylim : array_like
+        List of y-axis limits [min, max]
+
+    Returns
+    -------
+    wn : list
+        List of default natural frequencies for the plot
+
+    """
+
+    wn = xloc                   # one frequency per x-axis tick mark
+    sep = xloc[1]-xloc[0]       # separation between ticks
 
-    wn = xloc
-    sep = xloc[1]-xloc[0]
+    # Insert additional frequencies to span the y-axis
     while np.abs(wn[0]) < ylim[1]:
         wn = np.insert(wn, 0, wn[0]-sep)
 
+    # If there are too many values, cut them in half
     while len(wn) > 7:
         wn = wn[0:-1:2]
 
 
@@ -44,13 +44,9 @@ def testMarkovSignature(self, matarrayout, matarrayin):
         H = markov(np.transpose(Y), np.transpose(U), m, transpose=True)
         np.testing.assert_array_almost_equal(H, np.transpose(Htrue))
 
-        # Default (in v0.8.4 and below) should be transpose=True (w/ warning)
-        with pytest.warns(UserWarning, match="assumed to be in rows.*"
-                                             "change in a future release"):
-            # Generate Markov parameters without any arguments
-            H = markov(np.transpose(Y), np.transpose(U), m)
-            np.testing.assert_array_almost_equal(H, np.transpose(Htrue))
-
+
D30D
        # Generate Markov parameters without any arguments
+        H = markov(Y, U, m)
+        np.testing.assert_array_almost_equal(H, Htrue)
 
         # Test example from docstring
         T = np.linspace(0, 10, 100)
@@ -65,9 +61,8 @@ def testMarkovSignature(self, matarrayout, matarrayin):
 
         # Make sure MIMO generates an error
         U = np.ones((2, 100))   # 2 inputs (Y unchanged, with 1 output)
-        with pytest.warns(UserWarning):
-            with pytest.raises(ControlMIMONotImplemented):
-                markov(Y, U, m)
+        with pytest.raises(ControlMIMONotImplemented):
+            markov(Y, U, m)
 
     # Make sure markov() returns the right answer
     @pytest.mark.parametrize("k, m, n",
@@ -107,8 +102,9 @@ def testMarkovResults(self, k, m, n):
         # Generate input/output data
         T = np.array(range(n)) * Ts
         U = np.cos(T) + np.sin(T/np.pi)
+
         _, Y = forced_response(Hd, T, U, squeeze=True)
-        Mcomp = markov(Y, U, m, transpose=False)
+        Mcomp = markov(Y, U, m)
 
         # Compare to results from markov()
         np.testing.assert_array_almost_equal(Mtrue, Mcomp)