fixed remaining failing unit tests and cleanup of docfiles

sawyerbfuller · sawyerbfuller · commit b05492c08e73 · 2020-08-16T00:51:38.000-07:00
diff --git a/control/frdata.py b/control/frdata.py
@@ -47,7 +47,7 @@
 # External function declarations
 from warnings import warn
 import numpy as np
-from numpy import angle, array, empty, ones, isin, \
+from numpy import angle, array, empty, ones, \
     real, imag, absolute, eye, linalg, where, dot, sort
 from scipy.interpolate import splprep, splev
 from .lti import LTI
@@ -354,23 +354,24 @@ def eval(self, omega, squeeze=True):
         
         squeeze: bool, optional (default=True)
             If True and sys is single input, single output (SISO), return a 
-            1D array or scalar depending on omega's length.
+            1D array or scalar the same length as omega.
 
         """
         omega_array = np.array(omega, ndmin=1) # array-like version of omega 
         if any(omega_array.imag > 0): 
             raise ValueError("FRD.eval can only accept real-valued omega")
 
         if self.ifunc is None:
-            elements = isin(self.omega, omega)
+            elements = np.isin(self.omega, omega) # binary array
             if sum(elements) < len(omega_array):
                 raise ValueError(
-                    "not all frequencies omega are in frequency list of FRD "
-                    "system. Try an interpolating FRD for additional points.")
+                    '''not all frequencies omega are in frequency list of FRD 
+                    system. Try an interpolating FRD for additional points.''')
             else:
                 out = self.fresp[:, :, elements]
         else:
-            out = empty((self.outputs, self.inputs, len(omega_array)))
+            out = empty((self.outputs, self.inputs, len(omega_array)), 
+                         dtype=complex)
             for i in range(self.outputs):
                 for j in range(self.inputs):
                     for k, w in enumerate(omega_array):
diff --git a/control/lti.py b/control/lti.py
@@ -465,9 +465,14 @@ def evalfr(sys, x, squeeze=True):
 
     .. todo:: Add example with MIMO system
     """
+    out = sys.horner(x)
+    if not hasattr(x, '__len__'): 
+            # received a scalar x, squeeze down the array along last dim
+            out = np.squeeze(out, axis=2)
     if squeeze and issiso(sys):
-        return sys.horner(x)[0][0]
-    return sys.horner(x)
+        return out[0][0]
+    else: 
+        return out
 
 
 def freqresp(sys, omega, squeeze=True):
diff --git a/control/margins.py b/control/margins.py
@@ -213,15 +213,15 @@ def stability_margins(sysdata, returnall=False, epsw=0.0):
         # a bit coarse, have the interpolated frd evaluated again
         def _mod(w):
             """Calculate |G(jw)| - 1"""
-            return np.abs(sys(1j * w)[0][0]) - 1
+            return np.abs(sys(1j * w)) - 1
 
         def _arg(w):
             """Calculate the phase angle at -180 deg"""
-            return np.angle(-sys(1j * w)[0][0])
+            return np.angle(-sys(1j * w))
 
         def _dstab(w):
             """Calculate the distance from -1 point"""
-            return np.abs(sys(1j * w)[0][0] + 1.)
+            return np.abs(sys(1j * w) + 1.)
 
         # Find all crossings, note that this depends on omega having
         # a correct range
@@ -232,7 +232,7 @@ def _dstab(w):
 
         # find the phase crossings ang(H(jw) == -180
         widx = np.where(np.diff(np.sign(_arg(sys.omega))))[0]
-        widx = widx[np.real(sys(1j * sys.omega[widx])[0][0]) <= 0]
+        widx = widx[np.real(sys(1j * sys.omega[widx])) <= 0]
         w_180 = np.array(
             [sp.optimize.brentq(_arg, sys.omega[i], sys.omega[i+1])
              for i in widx])
@@ -296,11 +296,10 @@ def phase_crossover_frequencies(sys):
     (array([ 1.73205081,  0.        ]), array([-0.5 ,  0.25]))
     """
 
+    if not sys.issiso(): 
+        raise ValueError("MIMO systems not yet implemented.")
     # Convert to a transfer function
     tf = xferfcn._convert_to_transfer_function(sys)
-
-    # if not siso, fall back to (0,0) element
-    #! TODO: should add a check and warning here
     num = tf.num[0][0]
     den = tf.den[0][0]
 
@@ -313,7 +312,9 @@ def phase_crossover_frequencies(sys):
 
     # using real() to avoid rounding errors and results like 1+0j
     # it would be nice to have a vectorized version of self.evalfr here
-    gain = np.real(np.asarray([tf(1j * f)[0][0] for f in realposfreq]))
+    # update Sawyer B. Fuller 2020.08.15: your wish is my command.
+    #gain = np.real(np.asarray([tf(1j * f) for f in realposfreq]))
+    gain = np.real(tf(1j * realposfreq))
 
     return realposfreq, gain
 
diff --git a/control/rlocus.py b/control/rlocus.py
@@ -493,7 +493,7 @@ def _RLFindRoots(nump, denp, kvect):
     """Find the roots for the root locus."""
     # Convert numerator and denominator to polynomials if they aren't
     roots = []
-    for k in kvect:
+    for k in np.array(kvect, ndmin=1):
         curpoly = denp + k * nump
         curroots = curpoly.r
         if len(curroots) < denp.order:
@@ -577,10 +577,10 @@ def _RLFeedbackClicksPoint(event, sys, fig, ax_rlocus, sisotool=False):
     # Catch type error when event click is in the figure but not in an axis
     try:
         s = complex(event.xdata, event.ydata)
-        K = -1. / sys.horner(s)
-        K_xlim = -1. / sys.horner(
+        K = -1. / sys(s)
+        K_xlim = -1. / sys(
             complex(event.xdata + 0.05 * abs(xlim[1] - xlim[0]), event.ydata))
-        K_ylim = -1. / sys.horner(
+        K_ylim = -1. / sys(
             complex(event.xdata, event.ydata + 0.05 * abs(ylim[1] - ylim[0])))
 
     except TypeError:
@@ -621,7 +621,7 @@ def _RLFeedbackClicksPoint(event, sys, fig, ax_rlocus, sisotool=False):
             ax_rlocus.plot(s.real, s.imag, 'k.', marker='s', markersize=8,
                            zorder=20, label='gain_point')
 
-        return K.real[0][0]
+        return K.real
 
 
 def _removeLine(label, ax):
diff --git a/control/statesp.py b/control/statesp.py
@@ -437,60 +437,91 @@ def __rdiv__(self, other):
 
         raise NotImplementedError("StateSpace.__rdiv__ is not implemented yet.")
 
-    def __call__(self, s, squeeze=True):
-        """Evaluate system's transfer function at complex frequencies s/z.
+    def __call__(self, x, squeeze=True):
+        """Evaluate system's transfer function at complex frequencies.
+        
+        Evaluates at complex frequency x, where x is s or z dependong on 
+        whether the system is continuous or discrete-time.
         
         If squeeze is True (default) and sys is single input, single output 
-        (SISO), return a 1D array or scalar depending on s.
+        (SISO), return a 1D array or scalar depending on the size of x. 
+        For a MIMO system, returns an (n_outputs, n_inputs, n_x) array.
 
         """        
-        # Use TB05AD from Slycot if available
+        # Use Slycot if available
         try:
-            from slycot import tb05ad
-
-            # preallocate
-            s_arr = np.array(s, ndmin=1) # array-like version of s
-            out = np.empty((self.outputs, self.inputs, len(s_arr)), 
-                           dtype=complex)
-            n = self.states
-            m = self.inputs
-            p = self.outputs
-            # The first call both evaluates C(sI-A)^-1 B and also returns
-            # Hessenberg transformed matrices at, bt, ct.
-            result = tb05ad(n, m, p, s_arr[0], self.A,
-                            self.B, self.C, job='NG')
-            # When job='NG', result = (at, bt, ct, g_i, hinvb, info)
-            at = result[0]
-            bt = result[1]
-            ct = result[2]
-
-            # TB05AD frequency evaluation does not include direct feedthrough.
-            out[:, :, 0] = result[3] + self.D
-
-            # Now, iterate through the remaining frequencies using the
-            # transformed state matrices, at, bt, ct.
-
-            # Start at the second frequency, already have the first.
-            for kk, s_kk in enumerate(s_arr[1:len(s_arr)]):
-                result = tb05ad(n, m, p, s_kk, at, bt, ct, job='NH')
-                # When job='NH', result = (g_i, hinvb, info)
-
-                # kk+1 because enumerate starts at kk = 0.
-                # but zero-th spot is already filled.
-                out[:, :, kk+1] = result[0] + self.D
-            
-            if not hasattr(s, '__len__'): 
-                # received a scalar s, squeeze down the array
-                out = np.squeeze(out, axis=2)
-        except ImportError:  # Slycot unavailable. Fall back to horner.
-            out = self.horner(s)
+            out = self.slycot_horner(x)
+        except ImportError:  # Slycot unavailable. use built-in horner.
+            out = self.horner(x)
+        if not hasattr(x, '__len__'): 
+            # received a scalar x, squeeze down the array along last dim
+            out = np.squeeze(out, axis=2)
         if squeeze and self.issiso():
             return out[0][0]
         else:
             return out
 
+    def slycot_horner(self, s):
+        """Evaluate system's transfer function at complex frequencies s 
+        using Horner's method from Slycot.
+
+        Expects inputs and outputs to be formatted correctly. Use __call__
+        for a more user-friendly interface. 
+
+        Parameters
+            s : array-like
+
+        Returns
+            output : array of size (outputs, inputs, len(s))
+        
+        """
+        from slycot import tb05ad
+
+        # preallocate
+        s_arr = np.array(s, ndmin=1) # array-like version of s
+        out = np.empty((self.outputs, self.inputs, len(s_arr)), 
+                        dtype=complex)
+        n = self.states
+        m = self.inputs
+        p = self.outputs
+        # The first call both evaluates C(sI-A)^-1 B and also returns
+        # Hessenberg transformed matrices at, bt, ct.
+        result = tb05ad(n, m, p, s_arr[0], self.A,
+                        self.B, self.C, job='NG')
+        # When job='NG', result = (at, bt, ct, g_i, hinvb, info)
+        at = result[0]
+        bt = result[1]
+        ct = result[2]
+
+        # TB05AD frequency evaluation does not include direct feedthrough.
+        out[:, :, 0] = result[3] + self.D
+
+        # Now, iterate through the remaining frequencies using the
+        # transformed state matrices, at, bt, ct.
+
+        # Start at the second frequency, already have the first.
+        for kk, s_kk in enumerate(s_arr[1:len(s_arr)]):
+            result = tb05ad(n, m, p, s_kk, at, bt, ct, job='NH')
+            # When job='NH', result = (g_i, hinvb, info)
+
+            # kk+1 because enumerate starts at kk = 0.
+            # but zero-th spot is already filled.
+            out[:, :, kk+1] = result[0] + self.D
+        return out
+
     def horner(self, s):
-        """Evaluate systems's transfer function at complex frequencies s.
+        """Evaluate system's transfer function at complex frequencies s 
+        using Horner's method.
+
+        Expects inputs and outputs to be formatted correctly. Use __call__
+        for a more user-friendly interface. 
+
+        Parameters
+            s : array-like
+
+        Returns
+            output : array of size (outputs, inputs, len(s))
+        
         """
         s_arr = np.array(s, ndmin=1) # force to be an array
         # Preallocate 
@@ -501,9 +532,6 @@ def horner(self, s):
                 np.dot(self.C, 
                        solve(s_idx * eye(self.states) - self.A, self.B)) \
                 + self.D
-        if not hasattr(s, '__len__'): 
-            # received a scalar s, squeeze down the array along last dim
-            out = np.squeeze(out, axis=2)
         return out
 
     def freqresp(self, omega):
@@ -879,7 +907,7 @@ def dcgain(self):
             if self.isctime():
                 gain = np.asarray(self.D-self.C.dot(np.linalg.solve(self.A, self.B)))
             else:
-                gain = self.horner(1)
+                gain = np.squeeze(self.horner(1))
         except LinAlgError:
             # eigenvalue at DC
             gain = np.tile(np.nan, (self.outputs, self.inputs))
diff --git a/control/tests/frd_test.py b/control/tests/frd_test.py
@@ -387,9 +387,9 @@ def test_eval(self):
         np.testing.assert_almost_equal(sys_tf(1j), frd_tf(1j))
 
         # Should get an error if we evaluate at an unknown frequency
-        self.assertRaises(Exception, frd_tf.eval(2))
+        self.assertRaises(ValueError, frd_tf.eval, 2)
         # Should get an error if we use __call__ at real-valued frequency
-        self.assertRaises(ValueError, frd_tf(2))
+        self.assertRaises(ValueError, frd_tf, 2)
 
     def test_repr_str(self):
         # repr printing
diff --git a/control/tests/margin_test.py b/control/tests/margin_test.py
@@ -76,7 +76,7 @@ def test_stability_margins_omega(sys, refout, refoutall):
 def test_stability_margins_3input(sys, refout, refoutall):
     """Test stability_margins() function with mag, phase, omega input"""
     omega = np.logspace(-2, 2, 2000)
-    mag, phase, omega_ = sys.freqresp(omega)
+    mag, phase, omega_ = sys.frequency_response(omega)
     out = stability_margins((mag, phase*180/np.pi, omega_))
     assert_allclose(out, refout, atol=1.5e-3)
 
@@ -92,7 +92,7 @@ def test_margin_sys(sys, refout, refoutall):
 def test_margin_3input(sys, refout, refoutall):
     """Test margin() function with mag, phase, omega input"""
     omega = np.logspace(-2, 2, 2000)
-    mag, phase, omega_ = sys.freqresp(omega)
+    mag, phase, omega_ = sys.frequency_response(omega)
     out = margin((mag, phase*180/np.pi, omega_))
     assert_allclose(out, np.array(refout)[[0, 1, 3, 4]], atol=1.5e-3)
 
@@ -113,7 +113,7 @@ def test_phase_crossover_frequencies():
                            [[3], [4]]],
                           [[[1, 2, 3, 4], [1, 1]],
                            [[1, 1], [1, 1]]])
-    omega, gain = phase_crossover_frequencies(tf)
+    omega, gain = phase_crossover_frequencies(tf[0,0])
     assert_allclose(omega, [1.73205,  0.], atol=1.5e-3)
     assert_allclose(gain, [-0.5,  0.25], atol=1.5e-3)
 
@@ -123,7 +123,7 @@ def test_mag_phase_omega():
     sys = TransferFunction(15, [1, 6, 11, 6])
     out = stability_margins(sys)
     omega = np.logspace(-2, 2, 1000)
-    mag, phase, omega = sys.freqresp(omega)
+    mag, phase, omega = sys.frequency_response(omega)
     out2 = stability_margins((mag, phase*180/np.pi, omega))
     ind = [0, 1, 3, 4]   # indices of gm, pm, wg, wp -- ignore sm
     marg1 = np.array(out)[ind]
diff --git a/control/tests/statesp_array_test.py b/control/tests/statesp_array_test.py
@@ -505,7 +505,7 @@ def test_horner(self):
         # Make sure result agrees with frequency response
         mag, phase, omega = self.sys322.frequency_response([1])
         np.testing.assert_array_almost_equal(
-            self.sys322.horner(1.j),
+            np.squeeze(self.sys322.horner(1.j)),
             mag[:,:,0] * np.exp(1.j * phase[:,:,0]))
 
     def tearDown(self):
diff --git a/control/xferfcn.py b/control/xferfcn.py
