Allow dt=True for a discrete time system with unspecified timebase

murrayrm · murrayrm · commit 69129fbc8d38 · 2012-10-07T06:01:39.000Z
Use timebaseEqual(dt1, dt2) to check if two time bases are the same
diff --git a/ChangeLog b/ChangeLog
@@ -1,3 +1,18 @@
+2012-10-06  Richard Murray  <murray@altura.local>
+
+	* tests/discrete_test.py: added additional tests for dt = True cases
+
+	* src/statesp.py (StateSpace.__str__): show sampling time as
+	'unspecified' if dt is a boolean and equal to True
+
+	* src/xferfcn.py (TransferFunction.__str__): don't print sampling
+	time (dt) if dt = True (discrete time with unspecified time base)
+
+	* src/dtime.py: added code to support dt = True for unspecified
+	sampling time for a discrete time system
+
+	* src/bdalg.py: much -> must in docstrings
+
 2012-10-06  Richard Murray  <murray@altura.local>
 
 	* src/dtime.py: new module with functions for operating on discrete
diff --git a/src/__init__.py b/src/__init__.py
@@ -62,6 +62,7 @@
 from dtime import timebase, isdtime, isctime
 from freqplot import bode_plot, nyquist_plot, gangof4_plot
 from freqplot import bode, nyquist, gangof4
+from lti import timebaseEqual
 from margins import stability_margins, phase_crossover_frequencies
 from mateqn import lyap, dlyap, care, dare
 from modelsimp import hsvd, modred, balred, era, markov
diff --git a/src/bdalg.py b/src/bdalg.py
@@ -85,7 +85,7 @@ def series(sys1, sys2):
     If `sys2` is a scalar, then the output type is the type of `sys1`.
 
     If both systems have a defined timebase (dt = 0 for continuous time,
-    dt > 0 for discrete time), then the timebase for both systems much
+    dt > 0 for discrete time), then the timebase for both systems must
     match.  If only one of the system has a timebase, the return
     timebase will be set to match it.
 
@@ -128,7 +128,7 @@ def parallel(sys1, sys2):
     the type of `sys2`.
 
     If both systems have a defined timebase (dt = 0 for continuous time,
-    dt > 0 for discrete time), then the timebase for both systems much
+    dt > 0 for discrete time), then the timebase for both systems must
     match.  If only one of the system has a timebase, the return
     timebase will be set to match it.
 
@@ -158,7 +158,7 @@ def negate(sys):
     TransferFunction classes.  The output type is the same as the input type.
 
     If both systems have a defined timebase (dt = 0 for continuous time,
-    dt > 0 for discrete time), then the timebase for both systems much
+    dt > 0 for discrete time), then the timebase for both systems must
     match.  If only one of the system has a timebase, the return
     timebase will be set to match it.
 
diff --git a/src/dtime.py b/src/dtime.py
@@ -7,6 +7,7 @@
 isdtime()
 isctime()
 timebase()
+timebaseEqual()
 """
 
 """Copyright (c) 2012 by California Institute of Technology
@@ -60,7 +61,7 @@ def timebase(sys):
 
     # Check for a transfer fucntion or state space object
     if isinstance(sys, (StateSpace, TransferFunction)):
-        if sys.dt > 0:
+        if sys.dt > 0 or sys.dt == True:
             return 'dtime';
         elif sys.dt == 0:
             return 'ctime';
@@ -81,6 +82,7 @@ def isdtime(sys, strict=False):
     # Check for a transfer fucntion or state space object
     if isinstance(sys, (StateSpace, TransferFunction)):
         # Look for dt > 0 or dt == None (if not strict)
+        # Note that dt = True will be checked by dt > 0
         return sys.dt > 0 or (not strict and sys.dt == None)
 
     # Got possed something we don't recognize
@@ -101,6 +103,3 @@ def isctime(sys, strict=False):
 
     # Got possed something we don't recognize
     return False
-
-        
-        
diff --git a/src/lti.py b/src/lti.py
@@ -47,3 +47,15 @@ def __init__(self, inputs=1, outputs=1):
         # Data members common to StateSpace and TransferFunction.
         self.inputs = inputs
         self.outputs = outputs
+
+# Check to see if two timebases are equal
+def timebaseEqual(dt1, dt2):
+    # TODO: add docstring
+    if (type(dt1) == bool or type(dt2) == bool):
+        # Make sure both are unspecified discrete timebases
+        return type(dt1) == type(dt2) and dt1 == dt2
+    elif (type(dt1) == None or type(dt2) == None):
+        # One or the other is unspecified => the other can be anything
+        return True
+    else:
+        return dt1 == dt2
diff --git a/src/matlab.py b/src/matlab.py
@@ -478,6 +478,11 @@ def tf(*args):
         of array_like objects. (A 3 dimensional data structure in total.)
         (For details see note below.)
 
+    ``tf(num, den, dt)``
+        Create a discrete time transfer function system; dt can either be a
+        positive number indicating the sampling time or 'True' if no
+        specific timebase is given.
+
     Parameters
     ----------
     sys: Lti (StateSpace or TransferFunction)
@@ -537,8 +542,8 @@ def tf(*args):
 
     """
 
-    if len(args) == 2:
-       return TransferFunction(args[0], args[1])
+    if len(args) == 2 or len(args) == 3:
+       return TransferFunction(*args)
     elif len(args) == 1:
         sys = args[0]
         if isinstance(sys, StateSpace):
diff --git a/src/statesp.py b/src/statesp.py
@@ -81,7 +81,7 @@
 from numpy.linalg.linalg import LinAlgError
 from scipy.signal import lti
 import warnings
-from lti import Lti
+from lti import Lti, timebaseEqual
 import xferfcn
 
 class StateSpace(Lti):
@@ -99,7 +99,9 @@ class StateSpace(Lti):
     variable and setting it to the sampling period.  If 'dt' is not None,
     then it must match whenever two state space systems are combined.
     Setting dt = 0 specifies a continuous system, while leaving dt = None
-    means the system timebase is not specified.
+    means the system timebase is not specified.  If 'dt' is set to True, the
+    system will be treated as a discrete time system with unspecified
+    sampling time.
     """
 
     def __init__(self, *args): 
@@ -214,7 +216,9 @@ def __str__(self):
         str += "B = " + self.B.__str__() + "\n\n"
         str += "C = " + self.C.__str__() + "\n\n"
         str += "D = " + self.D.__str__() + "\n"
-        if (self.dt > 0):
+        if (type(self.dt) == bool and self.dt == True):
+            str += "\ndt unspecified\n"
+        elif (self.dt > 0):
             str += "\ndt = " + self.dt.__str__() + "\n"
         return str
 
@@ -246,7 +250,7 @@ def __add__(self, other):
             if (self.dt == None and other.dt != None):
                 dt = other.dt       # use dt from second argument
             elif (other.dt == None and self.dt != None) or \
-                    (self.dt == other.dt):
+                    (timebaseEqual(self.dt, other.dt)):
                 dt = self.dt        # use dt from first argument
             else:
                 raise ValueError, "Systems have different sampling times"
@@ -304,7 +308,7 @@ def __mul__(self, other):
             if (self.dt == None and other.dt != None):
                 dt = other.dt       # use dt from second argument
             elif (other.dt == None and self.dt != None) or \
-                    (self.dt == other.dt):
+                    (timebaseEqual(self.dt, other.dt)):
                 dt = self.dt        # use dt from first argument
             else:
                 raise ValueError, "Systems have different sampling times"
@@ -435,7 +439,8 @@ def feedback(self, other, sign=-1):
         # Figure out the sampling time to use
         if (self.dt == None and other.dt != None):
             dt = other.dt       # use dt from second argument
-        elif (other.dt == None and self.dt != None) or (self.dt == other.dt):
+        elif (other.dt == None and self.dt != None) or \
+                timebaseEqual(self.dt, other.dt):
             dt = self.dt        # use dt from first argument
         else:
             raise ValueError, "Systems have different sampling times"
diff --git a/src/xferfcn.py b/src/xferfcn.py
@@ -79,7 +79,7 @@
     polyadd, polymul, polyval, roots, sort, sqrt, zeros, squeeze
 from scipy.signal import lti
 from copy import deepcopy
-from lti import Lti
+from lti import Lti, timebaseEqual
 import statesp
 
 class TransferFunction(Lti):
@@ -98,10 +98,11 @@ class TransferFunction(Lti):
     means that the numerator of the transfer function from the 6th input to the
     3rd output is set to s^2 + 4s + 8.
 
-    Discrete time transfer functions are implemented by using the 'dt'
-    class variable and setting it to something other than 'None'.  If
-    'dt' has a non-zero value, then it must match whenever two transfer
-    functions are combined.
+    Discrete time transfer functions are implemented by using the 'dt' class
+    variable and setting it to something other than 'None'.  If 'dt' has a
+    non-zero value, then it must match whenever two transfer functions are
+    combined.  If 'dt' is set to True, the system will be treated as a
+    discrete time system with unspecified sampling time.
     """
     
     def __init__(self, *args):
@@ -288,7 +289,7 @@ def __str__(self, var=None):
                 outstr += "\n" + numstr + "\n" + dashes + "\n" + denstr + "\n"
 
         # See if this is a discrete time system with specific sampling time
-        if (self.dt > 0):
+        if (type(self.dt) != bool and self.dt > 0):
             outstr += "\ndt = " + self.dt.__str__() + "\n"
 
         return outstr
@@ -324,7 +325,8 @@ def __add__(self, other):
         # Figure out the sampling time to use
         if (self.dt == None and other.dt != None):
             dt = other.dt       # use dt from second argument
-        elif (other.dt == None and self.dt != None) or (self.dt == other.dt):
+        elif (other.dt == None and self.dt != None) or \
+                (timebaseEqual(self.dt, other.dt)):
             dt = self.dt        # use dt from first argument
         else:
             raise ValueError, "Systems have different sampling times"
diff --git a/tests/discrete_test.py b/tests/discrete_test.py
@@ -19,6 +19,7 @@ def setUp(self):
         self.siso_ss1c = StateSpace(sys.A, sys.B, sys.C, sys.D, 0.0) 
         self.siso_ss1d = StateSpace(sys.A, sys.B, sys.C, sys.D, 0.1) 
         self.siso_ss2d = StateSpace(sys.A, sys.B, sys.C, sys.D, 0.2) 
+        self.siso_ss3d = StateSpace(sys.A, sys.B, sys.C, sys.D, True) 
 
         # Two input, two output continuous time system
         A = [[-3., 4., 2.], [-1., -3., 0.], [2., 5., 3.]]
@@ -39,19 +40,35 @@ def setUp(self):
         self.siso_tf1c = TransferFunction([1, 1], [1, 2, 1], 0)
         self.siso_tf1d = TransferFunction([1, 1], [1, 2, 1], 0.1)
         self.siso_tf2d = TransferFunction([1, 1], [1, 2, 1], 0.2)
+        self.siso_tf3d = TransferFunction([1, 1], [1, 2, 1], True)
+
+    def testTimebaseEqual(self):
+        self.assertEqual(timebaseEqual(None, None), True)
+        self.assertEqual(timebaseEqual(1, 1), True)
+        self.assertEqual(timebaseEqual(1, 1.0), True)
+        self.assertEqual(timebaseEqual(True, True), True)
+
+        self.assertEqual(timebaseEqual(1, 0.1), False)
+        self.assertEqual(timebaseEqual(None, 0.1), False)
+        self.assertEqual(timebaseEqual(None, True), False)
+        self.assertEqual(timebaseEqual(None, 0), False)
+        self.assertEqual(timebaseEqual(1, True), False)
 
     def testSystemInitialization(self):
         # Check to make sure systems are discrete time with proper variables
         self.assertEqual(self.siso_ss1.dt, None)
         self.assertEqual(self.siso_ss1c.dt, 0)
         self.assertEqual(self.siso_ss1d.dt, 0.1)
         self.assertEqual(self.siso_ss2d.dt, 0.2)
+        self.assertEqual(self.siso_ss3d.dt, True)
         self.assertEqual(self.mimo_ss1c.dt, 0)
         self.assertEqual(self.mimo_ss1d.dt, 0.1)
         self.assertEqual(self.mimo_ss2d.dt, 0.2)
         self.assertEqual(self.siso_tf1.dt, None)
         self.assertEqual(self.siso_tf1c.dt, 0)
         self.assertEqual(self.siso_tf1d.dt, 0.1)
+        self.assertEqual(self.siso_tf2d.dt, 0.2)
+        self.assertEqual(self.siso_tf3d.dt, True)
 
     def testCopyConstructor(self):
         for sys in (self.siso_ss1, self.siso_ss1c, self.siso_ss1d):
@@ -66,9 +83,11 @@ def testTimebase(self):
         self.assertEqual(timebase(self.siso_ss1), None);
         self.assertEqual(timebase(self.siso_ss1c), 'ctime');
         self.assertEqual(timebase(self.siso_ss1d), 'dtime');
+        self.assertEqual(timebase(self.siso_ss3d), 'dtime');
         self.assertEqual(timebase(self.siso_tf1), None);
         self.assertEqual(timebase(self.siso_tf1c), 'ctime');
         self.assertEqual(timebase(self.siso_tf1d), 'dtime');
+        self.assertEqual(timebase(self.siso_tf3d), 'dtime');
 
     def testisdtime(self):
         # Constant
@@ -82,6 +101,7 @@ def testisdtime(self):
         self.assertEqual(isdtime(self.siso_ss1c, strict=True), False);
         self.assertEqual(isdtime(self.siso_ss1d), True);
         self.assertEqual(isdtime(self.siso_ss1d, strict=True), True);
+        self.assertEqual(isdtime(self.siso_ss3d, strict=True), True);
 
         # Transfer function
         self.assertEqual(isdtime(self.siso_tf1), True);
@@ -90,6 +110,7 @@ def testisdtime(self):
         self.assertEqual(isdtime(self.siso_tf1c, strict=True), False);
         self.assertEqual(isdtime(self.siso_tf1d), True);
         self.assertEqual(isdtime(self.siso_tf1d, strict=True), True);
+        self.assertEqual(isdtime(self.siso_tf3d, strict=True), True);
 
     def testisctime(self):
         # Constant
@@ -103,14 +124,16 @@ def testisctime(self):
         self.assertEqual(isctime(self.siso_ss1c, strict=True), True);
         self.assertEqual(isctime(self.siso_ss1d), False);
         self.assertEqual(isctime(self.siso_ss1d, strict=True), False);
+        self.assertEqual(isctime(self.siso_ss3d, strict=True), False);
 
         # Transfer Function
-        self.assertEqual(isctime(self.siso_ss1), True);
-        self.assertEqual(isctime(self.siso_ss1, strict=True), False);
-        self.assertEqual(isctime(self.siso_ss1c), True);
-        self.assertEqual(isctime(self.siso_ss1c, strict=True), True);
-        self.assertEqual(isctime(self.siso_ss1d), False);
-        self.assertEqual(isctime(self.siso_ss1d, strict=True), False);
+        self.assertEqual(isctime(self.siso_tf1), True);
+        self.assertEqual(isctime(self.siso_tf1, strict=True), False);
+        self.assertEqual(isctime(self.siso_tf1c), True);
+        self.assertEqual(isctime(self.siso_tf1c, strict=True), True);
+        self.assertEqual(isctime(self.siso_tf1d), False);
+        self.assertEqual(isctime(self.siso_tf1d, strict=True), False);
+        self.assertEqual(isctime(self.siso_tf3d, strict=True), False);
 
     def testAddition(self):
         # State space addition
@@ -120,10 +143,13 @@ def testAddition(self):
         sys = self.siso_ss1d + self.siso_ss1
         sys = self.siso_ss1c + self.siso_ss1c
         sys = self.siso_ss1d + self.siso_ss1d
+        sys = self.siso_ss3d + self.siso_ss3d
         self.assertRaises(ValueError, StateSpace.__add__, self.mimo_ss1c, 
                           self.mimo_ss1d)
         self.assertRaises(ValueError, StateSpace.__add__, self.mimo_ss1d, 
                           self.mimo_ss2d)
+        self.assertRaises(ValueError, StateSpace.__add__, self.siso_ss1d, 
+                          self.siso_ss3d)
 
         # Transfer function addition
         sys = self.siso_tf1 + self.siso_tf1d
@@ -132,10 +158,13 @@ def testAddition(self):
         sys = self.siso_tf1d + self.siso_tf1
         sys = self.siso_tf1c + self.siso_tf1c
         sys = self.siso_tf1d + self.siso_tf1d
+        sys = self.siso_tf2d + self.siso_tf2d
         self.assertRaises(ValueError, TransferFunction.__add__, self.siso_tf1c, 
                           self.siso_tf1d)
         self.assertRaises(ValueError, TransferFunction.__add__, self.siso_tf1d, 
                           self.siso_tf2d)
+        self.assertRaises(ValueError, TransferFunction.__add__, self.siso_tf1d, 
+                          self.siso_tf3d)
 
         # State space + transfer function
         sys = self.siso_ss1c + self.siso_tf1c
@@ -157,6 +186,8 @@ def testMultiplication(self):
                           self.mimo_ss1d)
         self.assertRaises(ValueError, StateSpace.__mul__, self.mimo_ss1d, 
                           self.mimo_ss2d)
+        self.assertRaises(ValueError, StateSpace.__mul__, self.siso_ss1d, 
+                          self.siso_ss3d)
 
         # Transfer function addition
         sys = self.siso_tf1 * self.siso_tf1d
@@ -169,6 +200,8 @@ def testMultiplication(self):
                           self.siso_tf1d)
         self.assertRaises(ValueError, TransferFunction.__mul__, self.siso_tf1d, 
                           self.siso_tf2d)
+        self.assertRaises(ValueError, TransferFunction.__mul__, self.siso_tf1d, 
+                          self.siso_tf3d)
 
         # State space * transfer function
         sys = self.siso_ss1c * self.siso_tf1c
@@ -189,6 +222,7 @@ def testFeedback(self):
         sys = feedback(self.siso_ss1d, self.siso_ss1d)
         self.assertRaises(ValueError, feedback, self.mimo_ss1c, self.mimo_ss1d)
         self.assertRaises(ValueError, feedback, self.mimo_ss1d, self.mimo_ss2d)
+        self.assertRaises(ValueError, feedback, self.siso_ss1d, self.siso_ss3d)
 
         # Transfer function addition
         sys = feedback(self.siso_tf1, self.siso_tf1d)
@@ -199,6 +233,7 @@ def testFeedback(self):
         sys = feedback(self.siso_tf1d, self.siso_tf1d)
         self.assertRaises(ValueError, feedback, self.siso_tf1c, self.siso_tf1d)
         self.assertRaises(ValueError, feedback, self.siso_tf1d, self.siso_tf2d)
+        self.assertRaises(ValueError, feedback, self.siso_tf1d, self.siso_tf3d)
 
         # State space, transfer function
         sys = feedback(self.siso_ss1c, self.siso_tf1c)
