add (skipped) function for desired binary operator conversions

murrayrm · murrayrm · commit f0593fab671a · 2021-01-07T21:50:57.000-08:00
diff --git a/control/tests/type_conversion_test.py b/control/tests/type_conversion_test.py
@@ -15,6 +15,7 @@ def sys_dict():
     sdict = {}
     sdict['ss'] = ct.ss([[-1]], [[1]], [[1]], [[0]])
     sdict['tf'] = ct.tf([1],[0.5, 1])
+    sdict['tfx'] = ct.tf([1, 1],[1])     # non-proper transfer function
     sdict['frd'] = ct.frd([10+0j, 9 + 1j, 8 + 2j], [1,2,3])
     sdict['lio'] = ct.LinearIOSystem(ct.ss([[-1]], [[5]], [[5]], [[0]]))
     sdict['ios'] = ct.NonlinearIOSystem(
@@ -29,7 +30,7 @@ def sys_dict():
     'ios': ct.InterconnectedSystem, 'arr': np.ndarray, 'flt': float}
 
 #
-# Table of expected conversions
+# Current table of expected conversions
 #
 # This table describes all of the conversions that are supposed to
 # happen for various system combinations. This is written out this way
@@ -50,6 +51,10 @@ def sys_dict():
 # Note 2: eventually the operator entry for this table can be pulled out and
 # tested as a separate parameterized variable (since all operators should
 # return consistent values).
+#
+# Note 3: this table documents the current state, but not actually the desired
+# state.  See bottom of the file for the (eventual) desired behavior.
+#
 
 rtype_list =           ['ss',  'tf', 'frd', 'lio', 'ios', 'arr', 'flt']
 conversion_table = [
@@ -97,7 +102,7 @@ def sys_dict():
         test_matrix.append([opname, ltype, rtype, expected])
     
 @pytest.mark.parametrize("opname, ltype, rtype, expected", test_matrix)
-def test_xferfcn_ndarray_precedence(opname, ltype, rtype, expected, sys_dict):
+def test_operator_type_conversion(opname, ltype, rtype, expected, sys_dict):
     op = getattr(operator, opname)
     leftsys = sys_dict[ltype]
     rightsys = sys_dict[rtype]
@@ -117,3 +122,66 @@ def test_xferfcn_ndarray_precedence(opname, ltype, rtype, expected, sys_dict):
                 
         # Print out what we are testing in case something goes wrong
         assert isinstance(result, type_dict[expected])
+
+#
+# Updated table that describes desired outputs for all operators
+#
+# General rules (subject to change)
+#
+#   * For LTI/LTI, keep the type of the left operand whenever possible. This
+#     prioritizes the first operand, but we need to watch out for non-proper
+#     transfer functions (in which case TransferFunction should be returned)
+#
+#   * For FRD/LTI, convert LTI to FRD by evaluating the LTI transfer function
+#     at the FRD frequencies (can't got the other way since we can't convert
+#     an FRD object to state space/transfer function).
+#
+#   * For IOS/LTI, convert to IOS.  In the case of a linear I/O system (LIO),
+#     this will preserve the linear structure since the LTI system will
+#     be converted to state space.  
+#
+#   * When combining state space or transfer with linear I/O systems, the
+#   * output should be of type Linear IO system, since that maintains the
+#   * underlying state space attributes.
+#
+# Note: tfx = non-proper transfer function, order(num) > order(den)
+#
+
+type_list = ['ss', 'tf', 'tfx', 'frd', 'lio', 'ios', 'arr', 'flt']
+conversion_table = [
+    # L / R ['ss',  'tf',  'tfx', 'frd', 'lio', 'ios', 'arr', 'flt'] 
+    ('ss',  ['ss',  'ss',  'tf'   'frd', 'lio', 'ios', 'ss',  'ss' ]),
+    ('tf',  ['tf',  'tf',  'tf'   'frd', 'lio', 'ios', 'tf',  'tf' ]),
+    ('tfx', ['tf',  'tf',  'tf',  'frd', 'E',   'E',   'tf',  'tf' ]),
+    ('frd', ['frd', 'frd', 'frd', 'frd', 'E',   'E',   'frd', 'frd']),
+    ('lio', ['lio', 'lio', 'E',   'E',   'lio', 'ios', 'lio', 'lio']),
+    ('ios', ['ios', 'ios', 'E',   'E',   'ios', 'ios', 'ios', 'ios']),
+    ('arr', ['ss',  'tf',  'tf'   'frd', 'lio', 'ios', 'arr', 'arr']),
+    ('flt', ['ss',  'tf',  'tf'   'frd', 'lio', 'ios', 'arr', 'flt'])]
+
+@pytest.mark.skip(reason="future test; conversions not yet fully implemented")
+# @pytest.mark.parametrize("opname", ['add', 'sub', 'mul', 'truediv'])
+# @pytest.mark.parametrize("ltype", type_list)
+# @pytest.mark.parametrize("rtype", type_list)
+def test_binary_op_type_conversions(opname, ltype, rtype, sys_dict):
+    op = getattr(operator, opname)
+    leftsys = sys_dict[ltype]
+    rightsys = sys_dict[rtype]
+    expected = \
+        conversion_table[type_list.index(ltype)][1][type_list.index(rtype)]
+
+    # Get rid of warnings for InputOutputSystem objects by making a copy
+    if isinstance(leftsys, ct.InputOutputSystem) and leftsys == rightsys:
+        rightsys = leftsys.copy()
+
+    # Make sure we get the right result
+    if expected == 'E' or expected[0] == 'x':
+        # Exception expected
+        with pytest.raises(TypeError):
+            op(leftsys, rightsys)
+    else:
+        # Operation should work and return the given type
+        result = op(leftsys, rightsys)
+
+        # Print out what we are testing in case something goes wrong
+        assert isinstance(result, type_dict[expected])
