Broke out the numerator/denominator cleanup function into a separate function.

Jed · Jed · commit 5e2d95d11645 · 2017-02-18T11:23:47.000-05:00
Added unit tests to test the cleanup function.

Added deep copy to TransferFunction args.
diff --git a/control/tests/xferfcn_input_test.py b/control/tests/xferfcn_input_test.py
@@ -0,0 +1,261 @@
+#!/usr/bin/env python
+#
+# xferfcn_test.py - test TransferFunction class
+# RMM, 30 Mar 2011 (based on TestXferFcn from v0.4a)
+
+import unittest
+import numpy as np
+
+from numpy import int, int8, int16, int32, int64
+from numpy import float, float16, float32, float64, float128
+from numpy import all, ndarray, array
+
+from control.xferfcn import cleanPart
+
+class TestXferFcnInput(unittest.TestCase):
+    """These are tests for functionality of cleaning and validating 
+    XferFucnInput."""
+
+    # Tests for raising exceptions.
+    def testBadInputType(self):
+        """Give the part cleaner invalid input type."""
+
+        self.assertRaises(TypeError, cleanPart, [[0., 1.], [2., 3.]])
+
+    def testBadInputType2(self):
+        """Give the part cleaner another invalid input type."""
+        self.assertRaises(TypeError, cleanPart, [1,"a"])
+
+    def testScalar(self):
+        """Test single scalar value."""
+        num = 1
+        num_ = cleanPart(num)
+        
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+
+    def testListScalar(self):
+        """Test single scalar value in list."""
+        num = [1]
+        num_ = cleanPart(num)
+        
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+      
+    def testTupleScalar(self):
+        """Test single scalar value in tuple."""
+        num = (1)
+        num_ = cleanPart(num)
+        
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+
+    def testList(self):
+        """Test multiple values in a list."""
+        num = [1, 2]
+        num_ = cleanPart(num)
+        
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
+
+    def testTuple(self):
+        """Test multiple values in tuple."""
+        num = (1, 2)
+        num_ = cleanPart(num)
+        
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
+            
+    def testAllScalarTypes(self):
+        """Test single scalar value for all valid data types."""
+        for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
+            num = dtype(1)
+            num_ = cleanPart(num)
+            
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+       
+    def testNpArray(self):
+        """Test multiple values in numpy array."""
+        num = np.array([1, 2])
+        num_ = cleanPart(num)
+        
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
+        
+    def testAllNumpyArrayTypes(self):      
+        """Test scalar value in numpy array of ndim=0 for all data types."""
+        for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
+            num = np.array(1, dtype=dtype)
+            num_ = cleanPart(num)
+            
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+
+    def testAllNumpyArrayTypes2(self):      
+        """Test numpy array for all types."""
+        for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
+            num = np.array([1, 2], dtype=dtype)
+            num_ = cleanPart(num)
+            
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
+           
+    def testListAllTypes(self):
+        """Test list of a single value for all data types."""
+        for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
+            num = [dtype(1)]
+            num_ = cleanPart(num)
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+
+    def testListAllTypes2(self):
+        """List of list of numbers of all data types."""
+        for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
+            num = [dtype(1), dtype(2)]
+            num_ = cleanPart(num)
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0, 2.0], dtype=float))
+            
+    def testTupleAllTypes(self):
+        """Test tuple of a single value for all data types."""
+        for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
+            num = (dtype(1),)
+            num_ = cleanPart(num)
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+            
+    def testTupleAllTypes2(self):
+        """Test tuple of a single value for all data types."""
+        for dtype in [int, int8, int16, int32, int64, float, float16, float32, float64, float128]:
+            num = (dtype(1), dtype(2))
+            num_ = cleanPart(num)
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1, 2], dtype=float))
+    
+    def testListListListInt(self):
+        """ Test an int in a list of a list of a list."""
+        num = [[[1]]]
+        num_ = cleanPart(num)
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+
+    def testListListListFloat(self):
+        """ Test a float in a list of a list of a list."""
+        num = [[[1.0]]]
+        num_ = cleanPart(num)
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0], dtype=float))
+       
+    def testListListListInts(self):
+        """Test 2 lists of ints in a list in a list."""
+        num = [[[1,1],[2,2]]]
+        num_ = cleanPart(num)
+        
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
+        np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
+        
+    def testListListListFloats(self):
+        """Test 2 lists of ints in a list in a list."""
+        num = [[[1.0,1.0],[2.0,2.0]]]
+        num_ = cleanPart(num)
+        
+        assert isinstance(num_, list)
+        assert np.all([isinstance(part, list) for part in num_])
+        np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
+        np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
+ 
+    def testListListArray(self):
+        """List of list of numpy arrays for all valid types."""
+        for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
+            num = [[array([1,1], dtype=dtype),array([2,2], dtype=dtype)]]
+            num_ = cleanPart(num)
+            
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
+            np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
+
+    def testTupleListArray(self):
+        """Tuple of list of numpy arrays for all valid types."""
+        for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
+            num = ([array([1,1], dtype=dtype),array([2,2], dtype=dtype)],)
+            num_ = cleanPart(num)
+            
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
+            np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
+            
+    def testListTupleArray(self):
+        """List of tuple of numpy array for all valid types."""
+        for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
+            num = [(array([1,1], dtype=dtype),array([2,2], dtype=dtype))]
+            num_ = cleanPart(num)
+            
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
+            np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
+    
+    def testTupleTuplesArrays(self):
+        """Tuple of tuples of numpy arrays for all valid types."""
+        for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
+            num = ((array([1,1], dtype=dtype),array([2,2], dtype=dtype)),
+                   (array([3,4], dtype=dtype),array([4,4], dtype=dtype)))
+            num_ = cleanPart(num)
+            
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
+            np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
+    
+    def testListTuplesArrays(self):
+        """List of tuples of numpy arrays for all valid types."""
+        for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
+            num = [(array([1,1], dtype=dtype),array([2,2], dtype=dtype)),
+                   (array([3,4], dtype=dtype),array([4,4], dtype=dtype))]
+            num_ = cleanPart(num)
+            
+            assert isinstance(num_, list)
+            assert np.all([isinstance(part, list) for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
+            np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
+
+    def testListListArrays(self):
+        """List of list of numpy arrays for all valid types."""
+        for dtype in int, int8, int16, int32, int64, float, float16, float32, float64, float128:
+            num = [[array([1,1], dtype=dtype),array([2,2], dtype=dtype)],
+                   [array([3,3], dtype=dtype),array([4,4], dtype=dtype)]]
+            num_ = cleanPart(num)
+            
+            assert len(num_) == 2
+            assert np.all([isinstance(part, list) for part in num_])
+            assert np.all([len(part) == 2 for part in num_])
+            np.testing.assert_array_equal(num_[0][0], array([1.0, 1.0], dtype=float))
+            np.testing.assert_array_equal(num_[0][1], array([2.0, 2.0], dtype=float))
+            np.testing.assert_array_equal(num_[1][0], array([3.0, 3.0], dtype=float))
+            np.testing.assert_array_equal(num_[1][1], array([4.0, 4.0], dtype=float))
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(TestXferFcnInput)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/control/xferfcn.py b/control/xferfcn.py
@@ -128,8 +128,8 @@ def __init__(self, *args):
             raise ValueError("Needs 1, 2 or 3 arguments; received %i."
                              % len(args))
 
-        num = tf_clean_parts(num)
-        den = tf_clean_parts(den)
+        num = cleanPart(num)
+        den = cleanPart(den)
 
         inputs = len(num[0])
         outputs = len(num)
@@ -1318,7 +1318,7 @@ def tfdata(sys):
 
     return (tf.num, tf.den)
 
-def tf_clean_parts(data):
+def cleanPart(data):
     '''
     Return a valid, cleaned up numerator or denominator 
     for the TransferFunction class.
@@ -1328,11 +1328,10 @@ def tf_clean_parts(data):
     
     Returns:
     data: correctly formatted transfer function part.
-    
+    ;
     '''
     valid_types = (int, int8, int16, int32, int64,
-               float, float16, float32, float64, float128,
-               complex, complex64, complex128, complex256)
+                   float, float16, float32, float64, float128)
     valid_collection = (list, tuple, ndarray)
 
     if (isinstance(data, valid_types) or
@@ -1341,11 +1340,13 @@ def tf_clean_parts(data):
     elif (isinstance(data, valid_collection) and
             all([isinstance(d, valid_types) for d in data])):
         return [[array(data, dtype=float)]]
-    elif (isinstance(data, list) and
-          isinstance(data[0], list) and
+    elif (isinstance(data, (list, tuple)) and
+          isinstance(data[0], (list, tuple)) and
               (isinstance(data[0][0], valid_collection) and 
-              isinstance(data[0][0][0], valid_types))):
+               all([isinstance(d, valid_types) for d in data[0][0]]))):
+        data = list(data)
         for j in range(len(data)):
+            data[j] = list(data[j])
             for k in range(len(data[j])):
                 data[j][k] = array(data[j][k], dtype=float)
         return data
