rename mymat to root_array for clarity

sawyerbfuller · sawyerbfuller · commit 15543ffe9d00 · 2022-12-09T15:02:11.000-08:00
diff --git a/control/rlocus.py b/control/rlocus.py
@@ -286,8 +286,8 @@ def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
     kvect = np.hstack((np.linspace(0, kmax, 50), np.real(k_break)))
     kvect.sort()
 
-    mymat = _RLFindRoots(num, den, kvect)
-    mymat = _RLSortRoots(mymat)
+    root_array = _RLFindRoots(num, den, kvect)
+    root_array = _RLSortRoots(root_array)
     open_loop_poles = den.roots
     open_loop_zeros = num.roots
 
@@ -297,13 +297,13 @@ def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
             open_loop_zeros,
             np.ones(open_loop_poles.size - open_loop_zeros.size)
             * open_loop_zeros[-1])
-        mymat_xl = np.append(mymat, open_loop_zeros_xl)
+        root_array_xl = np.append(root_array, open_loop_zeros_xl)
     else:
-        mymat_xl = mymat
+        root_array_xl = root_array
     singular_points = np.concatenate((num.roots, den.roots), axis=0)
     important_points = np.concatenate((singular_points, real_break), axis=0)
     important_points = np.concatenate((important_points, np.zeros(2)), axis=0)
-    mymat_xl = np.append(mymat_xl, important_points)
+    root_array_xl = np.append(root_array_xl, important_points)
 
     false_gain = float(den.coeffs[0]) / float(num.coeffs[0])
     if false_gain < 0 and not den.order > num.order:
@@ -312,27 +312,27 @@ def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
                          "with equal order of numerator and denominator.")
 
     if xlim is None and false_gain > 0:
-        x_tolerance = 0.05 * (np.max(np.real(mymat_xl))
-                              - np.min(np.real(mymat_xl)))
-        xlim = _ax_lim(mymat_xl)
+        x_tolerance = 0.05 * (np.max(np.real(root_array_xl))
+                              - np.min(np.real(root_array_xl)))
+        xlim = _ax_lim(root_array_xl)
     elif xlim is None and false_gain < 0:
         axmin = np.min(np.real(important_points)) \
             - (np.max(np.real(important_points))
                - np.min(np.real(important_points)))
-        axmin = np.min(np.array([axmin, np.min(np.real(mymat_xl))]))
+        axmin = np.min(np.array([axmin, np.min(np.real(root_array_xl))]))
         axmax = np.max(np.real(important_points)) \
             + np.max(np.real(important_points)) \
             - np.min(np.real(important_points))
-        axmax = np.max(np.array([axmax, np.max(np.real(mymat_xl))]))
+        axmax = np.max(np.array([axmax, np.max(np.real(root_array_xl))]))
         xlim = [axmin, axmax]
         x_tolerance = 0.05 * (axmax - axmin)
     else:
         x_tolerance = 0.05 * (xlim[1] - xlim[0])
 
     if ylim is None:
-        y_tolerance = 0.05 * (np.max(np.imag(mymat_xl))
-                              - np.min(np.imag(mymat_xl)))
-        ylim = _ax_lim(mymat_xl * 1j)
+        y_tolerance = 0.05 * (np.max(np.imag(root_array_xl))
+                              - np.min(np.imag(root_array_xl)))
+        ylim = _ax_lim(root_array_xl * 1j)
     else:
         y_tolerance = 0.05 * (ylim[1] - ylim[0])
 
@@ -345,7 +345,7 @@ def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
         tolerance = x_tolerance
     else:
         tolerance = np.min([x_tolerance, y_tolerance])
-    indexes_too_far = _indexes_filt(mymat, tolerance, zoom_xlim, zoom_ylim)
+    indexes_too_far = _indexes_filt(root_array, tolerance, zoom_xlim, zoom_ylim)
 
     # Add more points into the root locus for points that are too far apart
     while len(indexes_too_far) > 0 and kvect.size < 5000:
@@ -354,27 +354,27 @@ def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
             new_gains = np.linspace(kvect[index], kvect[index + 1], 5)
             new_points = _RLFindRoots(num, den, new_gains[1:4])
             kvect = np.insert(kvect, index + 1, new_gains[1:4])
-            mymat = np.insert(mymat, index + 1, new_points, axis=0)
+            root_array = np.insert(root_array, index + 1, new_points, axis=0)
 
-        mymat = _RLSortRoots(mymat)
-        indexes_too_far = _indexes_filt(mymat, tolerance, zoom_xlim, zoom_ylim)
+        root_array = _RLSortRoots(root_array)
+        indexes_too_far = _indexes_filt(root_array, tolerance, zoom_xlim, zoom_ylim)
 
     new_gains = kvect[-1] * np.hstack((np.logspace(0, 3, 4)))
     new_points = _RLFindRoots(num, den, new_gains[1:4])
     kvect = np.append(kvect, new_gains[1:4])
-    mymat = np.concatenate((mymat, new_points), axis=0)
-    mymat = _RLSortRoots(mymat)
-    return kvect, mymat, xlim, ylim
+    root_array = np.concatenate((root_array, new_points), axis=0)
+    root_array = _RLSortRoots(root_array)
+    return kvect, root_array, xlim, ylim
 
 
-def _indexes_filt(mymat, tolerance, zoom_xlim=None, zoom_ylim=None):
+def _indexes_filt(root_array, tolerance, zoom_xlim=None, zoom_ylim=None):
     """Calculate the distance between points and return the indexes.
 
     Filter the indexes so only the resolution of points within the xlim and
     ylim is improved when zoom is used.
 
     """
-    distance_points = np.abs(np.diff(mymat, axis=0))
+    distance_points = np.abs(np.diff(root_array, axis=0))
     indexes_too_far = list(np.unique(np.where(distance_points > tolerance)[0]))
 
     if zoom_xlim is not None and zoom_ylim is not None:
@@ -386,23 +386,23 @@ def _indexes_filt(mymat, tolerance, zoom_xlim=None, zoom_ylim=None):
         indexes_too_far_filtered = []
 
         for index in indexes_too_far_zoom:
-            for point in mymat[index]:
+            for point in root_array[index]:
                 if (zoom_xlim[0] <= point.real <= zoom_xlim[1]) and \
                    (zoom_ylim[0] <= point.imag <= zoom_ylim[1]):
                     indexes_too_far_filtered.append(index)
                     break
 
         # Check if zoom box is not overshot & insert points where neccessary
-        if len(indexes_too_far_filtered) == 0 and len(mymat) < 500:
+        if len(indexes_too_far_filtered) == 0 and len(root_array) < 500:
             limits = [zoom_xlim[0], zoom_xlim[1], zoom_ylim[0], zoom_ylim[1]]
             for index, limit in enumerate(limits):
                 if index <= 1:
-                    asign = np.sign(real(mymat)-limit)
+                    asign = np.sign(real(root_array)-limit)
                 else:
-                    asign = np.sign(imag(mymat) - limit)
+                    asign = np.sign(imag(root_array) - limit)
                 signchange = ((np.roll(asign, 1, axis=0)
                                - asign) != 0).astype(int)
-                signchange[0] = np.zeros((len(mymat[0])))
+                signchange[0] = np.zeros((len(root_array[0])))
                 if len(np.where(signchange == 1)[0]) > 0:
                     indexes_too_far_filtered.append(
                         np.where(signchange == 1)[0][0]-1)
@@ -411,7 +411,7 @@ def _indexes_filt(mymat, tolerance, zoom_xlim=None, zoom_ylim=None):
             if indexes_too_far_filtered[0] != 0:
                 indexes_too_far_filtered.insert(
                     0, indexes_too_far_filtered[0]-1)
-            if not indexes_too_far_filtered[-1] + 1 >= len(mymat) - 2:
+            if not indexes_too_far_filtered[-1] + 1 >= len(root_array) - 2:
                 indexes_too_far_filtered.append(
                     indexes_too_far_filtered[-1] + 1)
 
@@ -441,10 +441,10 @@ def _break_points(num, den):
     return k_break, real_break_pts
 
 
-def _ax_lim(mymat):
+def _ax_lim(root_array):
     """Utility to get the axis limits"""
-    axmin = np.min(np.real(mymat))
-    axmax = np.max(np.real(mymat))
+    axmin = np.min(np.real(root_array))
+    axmax = np.max(np.real(root_array))
     if axmax != axmin:
         deltax = (axmax - axmin) * 0.02
     else:
@@ -564,11 +564,11 @@ def _RLZoomDispatcher(event, sys, ax_rlocus, plotstr):
     nump, denp = _systopoly1d(sys_loop)
     xlim, ylim = ax_rlocus.get_xlim(), ax_rlocus.get_ylim()
 
-    kvect, mymat, xlim, ylim = _default_gains(
+    kvect, root_array, xlim, ylim = _default_gains(
         nump, denp, xlim=None, ylim=None, zoom_xlim=xlim, zoom_ylim=ylim)
     _removeLine('rootlocus', ax_rlocus)
 
-    for i, col in enumerate(mymat.T):
+    for i, col in enumerate(root_array.T):
         ax_rlocus.plot(real(col), imag(col), plotstr, label='rootlocus',
                        scalex=False, scaley=False)
 
@@ -640,10 +640,10 @@ def _RLFeedbackClicksPoint(event, sys, fig, ax_rlocus, sisotool=False):
 
         # Visualise clicked point, display all roots for sisotool mode
         if sisotool:
-            mymat = _RLFindRoots(nump, denp, K.real)
+            root_array = _RLFindRoots(nump, denp, K.real)
             ax_rlocus.plot(
-                [root.real for root in mymat],
-                [root.imag for root in mymat],
+                [root.real for root in root_array],
+                [root.imag for root in root_array],
                 marker='s', markersize=6, zorder=20, label='gain_point', color='k')
         else:
             ax_rlocus.plot(s.real, s.imag, 'k.', marker='s', markersize=8,
diff --git a/control/sisotool.py b/control/sisotool.py
@@ -117,7 +117,7 @@ def sisotool(sys, initial_gain=None, xlim_rlocus=None, ylim_rlocus=None,
     if kvect is not None:
         warnings.warn("'kvect' keyword is deprecated in sisotool; "
                       "use 'initial_gain' instead", FutureWarning)
-        initial_gain = np.atleast1d(kvect)[0]
+        initial_gain = np.atleast_1d(kvect)[0]
     initial_gain = config._get_param('sisotool', 'initial_gain',
             initial_gain, _sisotool_defaults)
 
