Added in patches from Ryan Krauss <rkrauss@siue.edu>:

murrayrm · murrayrm · commit 0d6ee57c5bd2 · 2013-06-09T15:50:50.000Z
* now possible to call a transfer function with a complex argument and get
  back the value of the transfer function (returns a matrix in MIMO case)

* default argument for second transfer function in feedback() call is now 1.
  Note that this will only work for SISO systems (wasn't sure extending to
  MIMO was that useful).
diff --git a/ChangeLog b/ChangeLog
@@ -1,3 +1,28 @@
+2013-06-09  Richard Murray  <murray@altura-2.local>
+
+	* tests/bdalg_test.py (TestFeedback.testScalarSS)
+	(TestFeedback.testScalarTF): added simple test of default argument
+	to feedback() for state space and transfer function systems
+
+	* tests/frd_test.py (TestFRD.testFeedback): added test of default
+	argument to feedback() for FRD type
+
+	* src/bdalg.py (feedback): 
+	* src/frdata.py (FRD.feedback):
+	* src/statesp.py (StateSpace.feedback):
+	patched in default value of 1 for other system in feedback().
+	Contributed by Ryan Krauss <rkrauss@siue.edu>
+	
+	* tests/xferfcn_test.py (TestXferFcn.testEvalFrMIMO)
+	(TestXferFcn.testEvalFrSISO): added tests of __call__ version of
+	evalfr. 
+
+	* src/xferfcn.py (TransferFunction.__call__): patched in new
+	__call__ functionality from Ryan Krauss <rkrauss@siue.edu>, but
+	modified to use evalfr (works with MIMO).  SISO transfer functions
+	return a single complex number, MIMO transfer functions return a
+	matrix of complex numbers.
+
 2013-05-23  Rene van Paassen <rene.vanpaassen@gmail.com>
 
 	* src/margin.py: re-vamped stability_margins function. Now
diff --git a/src/bdalg.py b/src/bdalg.py
@@ -172,7 +172,8 @@ def negate(sys):
     
     return -sys;
 
-def feedback(sys1, sys2, sign=-1):
+#! TODO: expand to allow sys2 default to work in MIMO case?
+def feedback(sys1, sys2=1, sign=-1):
     """
     Feedback interconnection between two I/O systems.
 
diff --git a/src/frdata.py b/src/frdata.py
@@ -393,7 +393,7 @@ def freqresp(self, omega):
 
         return mag, phase, omega
 
-    def feedback(self, other, sign=-1): 
+    def feedback(self, other=1, sign=-1): 
         """Feedback interconnection between two FRD objects."""
         
         other = _convertToFRD(other, omega=self.omega)
diff --git a/src/statesp.py b/src/statesp.py
@@ -447,7 +447,7 @@ def zero(self):
         return roots(num)
 
     # Feedback around a state space system
-    def feedback(self, other, sign=-1):
+    def feedback(self, other=1, sign=-1):
         """Feedback interconnection between two LTI systems."""
  
         other = _convertToStateSpace(other)
diff --git a/src/xferfcn.py b/src/xferfcn.py
@@ -81,7 +81,7 @@
 # External function declarations
 from numpy import angle, any, array, empty, finfo, insert, ndarray, ones, \
     polyadd, polymul, polyval, roots, sort, sqrt, zeros, squeeze, exp, pi, \
-    where, delete, real, poly
+    where, delete, real, poly, poly1d
 from scipy.signal import lti
 from copy import deepcopy
 from warnings import warn
@@ -231,7 +231,21 @@ def __init__(self, *args):
         self.den = den
         
         self._truncatecoeff()
-        
+
+    def __call__(self, s):
+        """Evaluate the system's transfer function for a complex vairable
+
+        For a SISO transfer function, returns the value of the
+        transfer function.  For a MIMO transfer fuction, returns a
+        matrix of values evaluated at complex variable s."""
+
+        if (self.inputs > 1 or self.outputs > 1):
+            # MIMO transfer function, return a matrix
+            return self.horner(s)
+        else:
+            # SISO transfer function, return a scalar
+            return self.horner(s)[0][0]
+
     def _truncatecoeff(self):
         """Remove extraneous zero coefficients from num and den.
 
@@ -604,7 +618,7 @@ def zero(self):
             #for now, just give zeros of a SISO tf 
             return roots(self.num[0][0])
 
-    def feedback(self, other, sign=-1): 
+    def feedback(self, other=1, sign=-1): 
         """Feedback interconnection between two LTI objects."""
         
         other = _convertToTransferFunction(other)
diff --git a/tests/bdalg_test.py b/tests/bdalg_test.py
@@ -50,6 +50,14 @@ def testScalarSS(self):
         np.testing.assert_array_almost_equal(ans2.C, [[2.5, 0.]])
         np.testing.assert_array_almost_equal(ans2.D, [[2.5]])
 
+        # Make sure default arugments work as well
+        ans3 = feedback(self.sys2, 1)
+        ans4 = feedback(self.sys2)
+        np.testing.assert_array_almost_equal(ans3.A, ans4.A)
+        np.testing.assert_array_almost_equal(ans3.B, ans4.B)
+        np.testing.assert_array_almost_equal(ans3.C, ans4.C)
+        np.testing.assert_array_almost_equal(ans3.D, ans4.D)
+
     def testScalarTF(self):
         """Scalar system with transfer function feedback block."""
 
@@ -61,6 +69,12 @@ def testScalarTF(self):
         np.testing.assert_array_almost_equal(ans2.num, [[[2.5, 5., 7.5]]])
         np.testing.assert_array_almost_equal(ans2.den, [[[1., -0.5, -2.]]])
 
+        # Make sure default arugments work as well
+        ans3 = feedback(self.sys1, 1)
+        ans4 = feedback(self.sys1)
+        np.testing.assert_array_almost_equal(ans3.num, ans4.num)
+        np.testing.assert_array_almost_equal(ans3.den, ans4.den)
+
     def testSSScalar(self):
         """State space system with scalar feedback block."""
         
diff --git a/tests/frd_test.py b/tests/frd_test.py
@@ -84,6 +84,11 @@ def testFeedback(self):
         np.testing.assert_array_almost_equal(
             f1.feedback(1).freqresp([0.1, 1.0, 10])[0],
             h1.feedback(1).freqresp([0.1, 1.0, 10])[0])
+
+        # Make sure default argument also works
+        np.testing.assert_array_almost_equal(
+            f1.feedback().freqresp([0.1, 1.0, 10])[0],
+            h1.feedback().freqresp([0.1, 1.0, 10])[0])
         
     def testFeedback2(self):
         h2 = StateSpace([[-1.0, 0], [0, -2.0]], [[0.4], [0.1]],
diff --git a/tests/xferfcn_test.py b/tests/xferfcn_test.py
@@ -324,6 +324,11 @@ def testEvalFrSISO(self):
         np.testing.assert_array_almost_equal(sys.evalfr(32.),
             np.array([[0.00281959302585077 - 0.030628473607392j]]))
 
+        # Test call version as well
+        np.testing.assert_almost_equal(sys(1.j), -0.5 - 0.5j)
+        np.testing.assert_almost_equal(sys(32.j), 
+            0.00281959302585077 - 0.030628473607392j)
+
     def testEvalFrMIMO(self):
         """Evaluate the frequency response of a MIMO system at one frequency."""
 
@@ -338,6 +343,9 @@ def testEvalFrMIMO(self):
         
         np.testing.assert_array_almost_equal(sys.evalfr(2.), resp)
 
+        # Test call version as well
+        np.testing.assert_array_almost_equal(sys(2.j), resp)
+
     # Tests for TransferFunction.freqresp.
 
     def testFreqRespSISO(self):
