fixes/cleanups suggested by @murrayrm

sawyerbfuller · sawyerbfuller · commit 23c4b09ae67b · 2021-03-12T13:41:21.000-08:00
diff --git a/control/iosys.py b/control/iosys.py
@@ -370,7 +370,7 @@ def _rhs(self, t, x, u, params={}):
         NotImplemented("Evaluation not implemented for system of type ",
                        type(self))
 
-    def dynamics(self, t, x, u, params={}):
+    def dynamics(self, t, x, u):
         """Compute the dynamics of a differential or difference equation.
 
         Given time `t`, input `u` and state `x`, returns the value of the
@@ -401,7 +401,7 @@ def dynamics(self, t, x, u, params={}):
         -------
         dx/dt or x[t+dt] : ndarray
         """
-        return self._rhs(t, x, u, params)
+        return self._rhs(t, x, u)
 
     def _out(self, t, x, u, params={}):
         """Evaluate the output of a system at a given state, input, and time
@@ -415,7 +415,7 @@ def _out(self, t, x, u, params={}):
         # If no output function was defined in subclass, return state
         return x
 
-    def output(self, t, x, u, params={}):
+    def output(self, t, x, u):
         """Compute the output of the system
 
         Given time `t`, input `u` and state `x`, returns the output of the
@@ -438,7 +438,7 @@ def output(self, t, x, u, params={}):
         -------
         y : ndarray
         """
-        return self._out(t, x, u, params)
+        return self._out(t, x, u)
 
     def set_inputs(self, inputs, prefix='u'):
         """Set the number/names of the system inputs.
@@ -768,6 +768,7 @@ def _out(self, t, x, u):
             + np.dot(self.D, np.reshape(u, (-1, 1)))
         return np.array(y).reshape((-1,))
 
+
 class NonlinearIOSystem(InputOutputSystem):
     """Nonlinear I/O system.
 
diff --git a/control/statesp.py b/control/statesp.py
@@ -1227,7 +1227,7 @@ def dcgain(self, warn_infinite=False):
         return self(0, warn_infinite=warn_infinite) if self.isctime() \
             else self(1, warn_infinite=warn_infinite)
 
-    def dynamics(self, *args):
+    def dynamics(self, t, x, u=0):
         """Compute the dynamics of the system
 
         Given input `u` and state `x`, returns the dynamics of the state-space
@@ -1242,11 +1242,10 @@ def dynamics(self, *args):
 
         The inputs `x` and `u` must be of the correct length for the system.
 
-        The calling signature is ``out = sys.dynamics(t, x[, u])``
         The first argument `t` is ignored because :class:`StateSpace` systems
         are time-invariant. It is included so that the dynamics can be passed
-        to most numerical integrators, such as scipy's `integrate.solve_ivp` and
-        for consistency with :class:`IOSystem` systems.
+        to most numerical integrators, such as :func:`scipy.integrate.solve_ivp`
+        and for consistency with :class:`IOSystem` systems.
 
         Parameters
         ----------
@@ -1261,23 +1260,19 @@ def dynamics(self, *args):
         -------
         dx/dt or x[t+dt] : ndarray
         """
-        if len(args) not in (2, 3):
-            raise ValueError("received" + len(args) + "args, expected 2 or 3")
-
-        x = np.reshape(args[1], (-1, 1)) # force to a column in case matrix
+        x = np.reshape(x, (-1, 1)) # force to a column in case matrix
         if np.size(x) != self.nstates:
             raise ValueError("len(x) must be equal to number of states")
-
-        if len(args) == 2: # received t and x, ignore t
+        if u is 0:
             return self.A.dot(x).reshape((-1,)) # return as row vector
         else: # received t, x, and u, ignore t
-            u = np.reshape(args[2], (-1, 1)) # force to a column in case matrix
+            u = np.reshape(u, (-1, 1)) # force to a column in case matrix
             if np.size(u) != self.ninputs:
                 raise ValueError("len(u) must be equal to number of inputs")
             return self.A.dot(x).reshape((-1,)) \
                  + self.B.dot(u).reshape((-1,)) # return as row vector
 
-    def output(self, *args):
+    def output(self, t, x, u=0):
         """Compute the output of the system
 
         Given input `u` and state `x`, returns the output `y` of the
@@ -1287,7 +1282,6 @@ def output(self, *args):
 
         where A and B are the state-space matrices of the system.
 
-        The calling signature is ``y = sys.output(t, x[, u])``
         The first argument `t` is ignored because :class:`StateSpace` systems
         are time-invariant. It is included so that the dynamics can be passed
         to most numerical integrators, such as scipy's `integrate.solve_ivp` and
@@ -1308,17 +1302,14 @@ def output(self, *args):
         -------
         y : ndarray
         """
-        if len(args) not in (2, 3):
-            raise ValueError("received"+len(args)+"args, expected 2 or 3")
-
-        x = np.reshape(args[1], (-1, 1)) # force to a column in case matrix
+        x = np.reshape(x, (-1, 1)) # force to a column in case matrix
         if np.size(x) != self.nstates:
             raise ValueError("len(x) must be equal to number of states")
 
-        if len(args) == 2: # received t and x, ignore t
+        if u is 0:
             return self.C.dot(x).reshape((-1,)) # return as row vector
         else: # received t, x, and u, ignore t
-            u = np.reshape(args[2], (-1, 1)) # force to a column in case matrix
+            u = np.reshape(u, (-1, 1)) # force to a column in case matrix
             if np.size(u) != self.ninputs:
                 raise ValueError("len(u) must be equal to number of inputs")
             return self.C.dot(x).reshape((-1,)) \
diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py
@@ -773,6 +773,12 @@ def test_dynamics_and_output_siso(self, x, u, sys121):
         assert_array_almost_equal(
             sys121.output(0, x, u),
             sys121.C.dot(x).reshape((-1,)) + sys121.D.dot(u).reshape((-1,)))
+        assert_array_almost_equal(
+            sys121.dynamics(0, x),
+            sys121.A.dot(x).reshape((-1,)))
+        assert_array_almost_equal(
+            sys121.output(0, x),
+            sys121.C.dot(x).reshape((-1,)))
 
     # too few and too many states and inputs
     @pytest.mark.parametrize('x', [0, 1, [], [1, 2, 3], np.atleast_1d(2)])
@@ -799,6 +805,12 @@ def test_dynamics_and_output_mimo(self, x, u, sys222):
         assert_array_almost_equal(
             sys222.output(0, x, u),
             sys222.C.dot(x).reshape((-1,)) + sys222.D.dot(u).reshape((-1,)))
+        assert_array_almost_equal(
+            sys222.dynamics(0, x),
+            sys222.A.dot(x).reshape((-1,)))
+        assert_array_almost_equal(
+            sys222.output(0, x),
+            sys222.C.dot(x).reshape((-1,)))
 
     # too few and too many states and inputs
     @pytest.mark.parametrize('x', [0, 1, [1, 1, 1]])
@@ -807,7 +819,7 @@ def test_error_x_dynamics_mimo(self, x, sys222):
             sys222.dynamics(0, x)
         with pytest.raises(ValueError):
             sys222.output(0, x)
-    @pytest.mark.parametrize('u', [0, 1, [1, 1, 1]])
+    @pytest.mark.parametrize('u', [1, [1, 1, 1]])
     def test_error_u_dynamics_mimo(self, u, sys222):
         with pytest.raises(ValueError):
             sys222.dynamics(0, (1, 1), u)
