Refactor method names to lower case

don4get · don4get · commit 3ea2d697cfab · 2018-12-30T21:16:28.000+01:00
diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py
@@ -33,7 +33,7 @@ def setUp(self):
         self.sys1 = StateSpace(A, B, C, D)
         self.sys2 = StateSpace(a, b, c, d)
 
-    def testPole(self):
+    def test_pole(self):
         """Evaluate the poles of a MIMO system."""
 
         p = np.sort(self.sys1.pole())
@@ -43,13 +43,13 @@ def testPole(self):
 
         np.testing.assert_array_almost_equal(p, true_p)
 
-    def testEmptyZero(self):
-        """Test to make sure zero() works with no zeros in system"""
+    def test_zero_empty(self):
+        """Test to make sure zero() works with no zeros in system."""
         sys = _convertToStateSpace(TransferFunction([1], [1, 2, 1]))
         np.testing.assert_array_equal(sys.zero(), np.array([]))
 
     @unittest.skipIf(not slycot_check(), "slycot not installed")
-    def testMIMOZero_nonsquare(self):
+    def test_zero_mimo_non_square(self):
         """Evaluate the zeros of a MIMO system."""
 
         z = np.sort(self.sys1.zero())
@@ -80,7 +80,7 @@ def testMIMOZero_nonsquare(self):
 
         np.testing.assert_array_almost_equal(z, true_z)
 
-    def testAdd(self):
+    def test_add_ss(self):
         """Add two MIMO systems."""
 
         A = [[-3., 4., 2., 0., 0.], [-1., -3., 0., 0., 0.],
@@ -96,7 +96,7 @@ def testAdd(self):
         np.testing.assert_array_almost_equal(sys.C, C)
         np.testing.assert_array_almost_equal(sys.D, D)
 
-    def testSub(self):
+    def test_subtract_ss(self):
         """Subtract two MIMO systems."""
 
         A = [[-3., 4., 2., 0., 0.], [-1., -3., 0., 0., 0.],
@@ -112,7 +112,7 @@ def testSub(self):
         np.testing.assert_array_almost_equal(sys.C, C)
         np.testing.assert_array_almost_equal(sys.D, D)
 
-    def testMul(self):
+    def test_multiply_ss(self):
         """Multiply two MIMO systems."""
 
         A = [[4., 1., 0., 0., 0.], [2., -3., 0., 0., 0.], [2., 0., -3., 4., 2.],
@@ -128,7 +128,7 @@ def testMul(self):
         np.testing.assert_array_almost_equal(sys.C, C)
         np.testing.assert_array_almost_equal(sys.D, D)
 
-    def testEvalFr(self):
+    def test_evalfr(self):
         """Evaluate the frequency response at one frequency."""
 
         A = [[-2, 0.5], [0.5, -0.3]]
@@ -159,7 +159,7 @@ def testEvalFr(self):
             assert issubclass(w[-1].category, PendingDeprecationWarning)
 
     @unittest.skipIf(not slycot_check(), "slycot not installed")
-    def testFreqResp(self):
+    def test_freq_resp(self):
         """Evaluate the frequency response at multiple frequencies."""
 
         A = [[-2, 0.5], [0.5, -0.3]]
@@ -168,25 +168,25 @@ def testFreqResp(self):
         D = [[0., -0.8], [-0.3, 0.]]
         sys = StateSpace(A, B, C, D)
 
-        truemag = [[[0.0852992637230322, 0.00103596611395218],
+        true_mag = [[[0.0852992637230322, 0.00103596611395218],
                     [0.935374692849736, 0.799380720864549]],
                    [[0.55656854563842, 0.301542699860857],
                     [0.609178071542849, 0.0382108097985257]]]
-        truephase = [[[-0.566195599644593, -1.68063565332582],
+        true_phase = [[[-0.566195599644593, -1.68063565332582],
                       [3.0465958317514, 3.14141384339534]],
                      [[2.90457947657161, 3.10601268291914],
                       [-0.438157380501337, -1.40720969147217]]]
-        trueomega = [0.1, 10.]
+        true_omega = [0.1, 10.]
 
-        mag, phase, omega = sys.freqresp(trueomega)
+        mag, phase, omega = sys.freqresp(true_omega)
 
-        np.testing.assert_almost_equal(mag, truemag)
-        np.testing.assert_almost_equal(phase, truephase)
-        np.testing.assert_equal(omega, trueomega)
+        np.testing.assert_almost_equal(mag, true_mag)
+        np.testing.assert_almost_equal(phase, true_phase)
+        np.testing.assert_equal(omega, true_omega)
 
     @unittest.skipIf(not slycot_check(), "slycot not installed")
-    def testMinreal(self):
-        """Test a minreal model reduction"""
+    def test_minreal(self):
+        """Test a minreal model reduction."""
         # A = [-2, 0.5, 0; 0.5, -0.3, 0; 0, 0, -0.1]
         A = [[-2, 0.5, 0], [0.5, -0.3, 0], [0, 0, -0.1]]
         # B = [0.3, -1.3; 0.1, 0; 1, 0]
@@ -205,8 +205,8 @@ def testMinreal(self):
         np.testing.assert_array_almost_equal(
             eigvals(sysr.A), [-2.136154, -0.1638459])
 
-    def testAppendSS(self):
-        """Test appending two state-space systems"""
+    def test_append_ss(self):
+        """Test appending two state-space systems."""
         A1 = [[-2, 0.5, 0], [0.5, -0.3, 0], [0, 0, -0.1]]
         B1 = [[0.3, -1.3], [0.1, 0.], [1.0, 0.0]]
         C1 = [[0., 0.1, 0.0], [-0.3, -0.2, 0.0]]
@@ -229,7 +229,7 @@ def testAppendSS(self):
         np.testing.assert_array_almost_equal(sys3.C, sys3c.C)
         np.testing.assert_array_almost_equal(sys3.D, sys3c.D)
 
-    def testAppendTF(self):
+    def test_append_tf(self):
         """Test appending a state-space system with a tf"""
         A1 = [[-2, 0.5, 0], [0.5, -0.3, 0], [0, 0, -0.1]]
         B1 = [[0.3, -1.3], [0.1, 0.], [1.0, 0.0]]
@@ -251,7 +251,7 @@ def testAppendTF(self):
         np.testing.assert_array_almost_equal(sys3c.A[:3, 3:], np.zeros((3, 2)))
         np.testing.assert_array_almost_equal(sys3c.A[3:, :3], np.zeros((2, 3)))
 
-    def testArrayAccessSS(self):
+    def test_array_access_ss(self):
 
         sys1 = StateSpace([[1., 2.], [3., 4.]],
                           [[5., 6.], [6., 8.]],
@@ -270,8 +270,8 @@ def testArrayAccessSS(self):
 
         assert sys1.dt == sys1_11.dt
 
-    def test_dcgain_cont(self):
-        """Test DC gain for continuous-time state-space systems"""
+    def test_dc_gain_cont(self):
+        """Test DC gain for continuous-time state-space systems."""
         sys = StateSpace(-2., 6., 5., 0)
         np.testing.assert_equal(sys.dcgain(), 15.)
 
@@ -282,8 +282,8 @@ def test_dcgain_cont(self):
         sys3 = StateSpace(0., 1., 1., 0.)
         np.testing.assert_equal(sys3.dcgain(), np.nan)
 
-    def test_dcgain_discr(self):
-        """Test DC gain for discrete-time state-space systems"""
+    def test_dc_gain_discr(self):
+        """Test DC gain for discrete-time state-space systems."""
         # static gain
         sys = StateSpace([], [], [], 2, True)
         np.testing.assert_equal(sys.dcgain(), 2)
@@ -300,15 +300,16 @@ def test_dcgain_discr(self):
         sys = StateSpace(1, 1, 1, 0, True)
         np.testing.assert_equal(sys.dcgain(), np.nan)
 
-    def test_dcgain_integrator(self):
-        """DC gain when eigenvalue at DC returns appropriately sized array of nan"""
+    def test_dc_gain_integrator(self):
+        """DC gain when eigenvalue at DC returns appropriately sized array of nan."""
         # the SISO case is also tested in test_dc_gain_{cont,discr}
         import itertools
         # iterate over input and output sizes, and continuous (dt=None) and discrete (dt=True) time
         for inputs, outputs, dt in itertools.product(range(1, 6), range(1, 6), [None, True]):
             states = max(inputs, outputs)
 
-            # a matrix that is singular at DC, and has no "useless" states as in _remove_useless_states
+            # a matrix that is singular at DC, and has no "useless" states as in
+            # _remove_useless_states
             a = np.triu(np.tile(2, (states, states)))
             # eigenvalues all +2, except for ...
             a[0, 0] = 0 if dt is None else 1
@@ -319,7 +320,7 @@ def test_dcgain_integrator(self):
             dc = np.squeeze(np.tile(np.nan, (outputs, inputs)))
             np.testing.assert_array_equal(dc, sys.dcgain())
 
-    def test_scalarStaticGain(self):
+    def test_scalar_static_gain(self):
         """Regression: can we create a scalar static gain?"""
         g1 = StateSpace([], [], [], [2])
         g2 = StateSpace([], [], [], [3])
@@ -335,7 +336,7 @@ def test_scalarStaticGain(self):
         g6 = g1.append(g2)
         np.testing.assert_array_equal(np.diag([2, 3]), g6.D)
 
-    def test_matrixStaticGain(self):
+    def test_matrix_static_gain(self):
         """Regression: can we create matrix static gains?"""
         d1 = np.matrix([[1, 2, 3], [4, 5, 6]])
         d2 = np.matrix([[7, 8], [9, 10], [11, 12]])
@@ -358,7 +359,7 @@ def test_matrixStaticGain(self):
         np.testing.assert_array_equal(block_diag(d1, d2), h4.D)
 
     def test_remove_useless_states(self):
-        """Regression: _remove_useless_states gives correct ABC sizes"""
+        """Regression: _remove_useless_states gives correct ABC sizes."""
         g1 = StateSpace(np.zeros((3, 3)),
                         np.zeros((3, 4)),
                         np.zeros((5, 3)),
@@ -369,8 +370,8 @@ def test_remove_useless_states(self):
         self.assertEqual((5, 4), g1.D.shape)
         self.assertEqual(0, g1.states)
 
-    def test_BadEmptyMatrices(self):
-        """Mismatched ABCD matrices when some are empty"""
+    def test_bad_empty_matrices(self):
+        """Mismatched ABCD matrices when some are empty."""
         self.assertRaises(ValueError, StateSpace, [1], [], [], [1])
         self.assertRaises(ValueError, StateSpace, [1], [1], [], [1])
         self.assertRaises(ValueError, StateSpace, [1], [], [1], [1])
@@ -379,23 +380,23 @@ def test_BadEmptyMatrices(self):
         self.assertRaises(ValueError, StateSpace, [], [], [1], [1])
         self.assertRaises(ValueError, StateSpace, [1], [1], [1], [])
 
-    def test_minrealStaticGain(self):
-        """Regression: minreal on static gain was failing"""
+    def test_minreal_static_gain(self):
+        """Regression: minreal on static gain was failing."""
         g1 = StateSpace([], [], [], [1])
         g2 = g1.minreal()
         np.testing.assert_array_equal(g1.A, g2.A)
         np.testing.assert_array_equal(g1.B, g2.B)
         np.testing.assert_array_equal(g1.C, g2.C)
         np.testing.assert_array_equal(g1.D, g2.D)
 
-    def test_Empty(self):
+    def test_empty(self):
         """Regression: can we create an empty StateSpace object?"""
         g1 = StateSpace([], [], [], [])
         self.assertEqual(0, g1.states)
         self.assertEqual(0, g1.inputs)
         self.assertEqual(0, g1.outputs)
 
-    def test_MatrixToStateSpace(self):
+    def test_matrix_to_state_space(self):
         """_convertToStateSpace(matrix) gives ss([],[],[],D)"""
         D = np.matrix([[1, 2, 3], [4, 5, 6]])
         g = _convertToStateSpace(D)
@@ -421,9 +422,8 @@ def setUp(self):
         # Maximum number of inputs and outputs to test + 1
         self.maxIO = 5
 
-    def testShape(self):
-        """Test that rss outputs have the right state, input, and output
-        size."""
+    def test_shape(self):
+        """Test that rss outputs have the right state, input, and output size."""
 
         for states in range(1, self.maxStates):
             for inputs in range(1, self.maxIO):
@@ -433,7 +433,7 @@ def testShape(self):
                     self.assertEqual(sys.inputs, inputs)
                     self.assertEqual(sys.outputs, outputs)
 
-    def testPole(self):
+    def test_pole(self):
         """Test that the poles of rss outputs have a negative real part."""
 
         for states in range(1, self.maxStates):
@@ -451,14 +451,13 @@ class TestDrss(unittest.TestCase):
     def setUp(self):
         # Number of times to run each of the randomized tests.
         self.numTests = 100
-        # Maxmimum number of states to test + 1
+        # Maximum number of states to test + 1
         self.maxStates = 10
         # Maximum number of inputs and outputs to test + 1
         self.maxIO = 5
 
-    def testShape(self):
-        """Test that drss outputs have the right state, input, and output
-        size."""
+    def test_shape(self):
+        """Test that drss outputs have the right state, input, and output size."""
 
         for states in range(1, self.maxStates):
             for inputs in range(1, self.maxIO):
@@ -468,7 +467,7 @@ def testShape(self):
                     self.assertEqual(sys.inputs, inputs)
                     self.assertEqual(sys.outputs, outputs)
 
-    def testPole(self):
+    def test_pole(self):
         """Test that the poles of drss outputs have less than unit magnitude."""
 
         for states in range(1, self.maxStates):
@@ -479,8 +478,8 @@ def testPole(self):
                     for z in p:
                         self.assertTrue(abs(z) < 1)
 
-    def testPoleStatic(self):
-        """Regression: pole() of static gain is empty array"""
+    def test_pole_static(self):
+        """Regression: pole() of static gain is empty array."""
         np.testing.assert_array_equal(np.array([]),
                                       StateSpace([], [], [], [[1]]).pole())
 
