Improve readability of matrix equation tests

cwrowley · cwrowley · commit 8c1fdeb2b401 · 2014-08-16T15:29:41.000-04:00
diff --git a/control/tests/mateqn_test.py b/control/tests/mateqn_test.py
@@ -43,7 +43,7 @@
 """
 
 import unittest
-from numpy import array
+from numpy import matrix
 from numpy.testing import assert_array_almost_equal
 from numpy.linalg import inv
 from scipy import zeros,dot
@@ -55,175 +55,172 @@ class TestMatrixEquations(unittest.TestCase):
     """These are tests for the matrix equation solvers in mateqn.py"""
 
     def test_lyap(self):
-        A = array([[-1, 1],[-1, 0]])
-        Q = array([[1,0],[0,1]])
+        A = matrix([[-1, 1],[-1, 0]])
+        Q = matrix([[1,0],[0,1]])
         X = lyap(A,Q)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,X)+dot(X,A.T)+Q,zeros((2,2)))
+        assert_array_almost_equal(A * X + X * A.T + Q, zeros((2,2)))
 
-        A = array([[1, 2],[-3, -4]])
-        Q = array([[3, 1],[1, 1]])
+        A = matrix([[1, 2],[-3, -4]])
+        Q = matrix([[3, 1],[1, 1]])
         X = lyap(A,Q)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,X)+dot(X,A.T)+Q,zeros((2,2)))
+        assert_array_almost_equal(A * X + X * A.T + Q, zeros((2,2)))
 
     def test_lyap_sylvester(self):
         A = 5
-        B = array([[4, 3], [4, 3]])
-        C = array([2, 1])
+        B = matrix([[4, 3], [4, 3]])
+        C = matrix([2, 1])
         X = lyap(A,B,C)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,X)+dot(X,B)+C,zeros((1,2)))
+        assert_array_almost_equal(A * X + X * B + C, zeros((1,2)))
 
-        A = array([[2,1],[1,2]])
-        B = array([[1,2],[0.5,0.1]])
-        C = array([[1,0],[0,1]])
+        A = matrix([[2,1],[1,2]])
+        B = matrix([[1,2],[0.5,0.1]])
+        C = matrix([[1,0],[0,1]])
         X = lyap(A,B,C)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,X)+dot(X,B)+C,zeros((2,2)))
+        assert_array_almost_equal(A * X + X * B + C, zeros((2,2)))
 
     def test_lyap_g(self):
-        A = array([[-1, 2],[-3, -4]])
-        Q = array([[3, 1],[1, 1]])
-        E = array([[1,2],[2,1]])
+        A = matrix([[-1, 2],[-3, -4]])
+        Q = matrix([[3, 1],[1, 1]])
+        E = matrix([[1,2],[2,1]])
         X = lyap(A,Q,None,E)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,dot(X,E.T)) + dot(E,dot(X,A.T)) + Q, \
-                                      zeros((2,2)))
+        assert_array_almost_equal(A * X * E.T + E * X * A.T + Q, zeros((2,2)))
 
     def test_dlyap(self):
-        A = array([[-0.6, 0],[-0.1, -0.4]])
-        Q = array([[1,0],[0,1]])
+        A = matrix([[-0.6, 0],[-0.1, -0.4]])
+        Q = matrix([[1,0],[0,1]])
         X = dlyap(A,Q)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,dot(X,A.T))-X+Q,zeros((2,2)))
+        assert_array_almost_equal(A * X * A.T - X + Q, zeros((2,2)))
 
-        A = array([[-0.6, 0],[-0.1, -0.4]])
-        Q = array([[3, 1],[1, 1]])
+        A = matrix([[-0.6, 0],[-0.1, -0.4]])
+        Q = matrix([[3, 1],[1, 1]])
         X = dlyap(A,Q)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,dot(X,A.T))-X+Q,zeros((2,2)))
+        assert_array_almost_equal(A * X * A.T - X + Q, zeros((2,2)))
 
     def test_dlyap_g(self):
-        A = array([[-0.6, 0],[-0.1, -0.4]])
-        Q = array([[3, 1],[1, 1]])
-        E = array([[1, 1],[2, 1]])
+        A = matrix([[-0.6, 0],[-0.1, -0.4]])
+        Q = matrix([[3, 1],[1, 1]])
+        E = matrix([[1, 1],[2, 1]])
         X = dlyap(A,Q,None,E)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,dot(X,A.T))-dot(E,dot(X,E.T))+Q, \
-                                      zeros((2,2)))
+        assert_array_almost_equal(A * X * A.T - E * X * E.T + Q, zeros((2,2)))
 
     def test_dlyap_sylvester(self):
         A = 5
-        B = array([[4, 3], [4, 3]])
-        C = array([2, 1])
+        B = matrix([[4, 3], [4, 3]])
+        C = matrix([2, 1])
         X = dlyap(A,B,C)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,dot(X,B.T))-X+C,zeros((1,2)))
+        assert_array_almost_equal(A * X * B.T - X + C, zeros((1,2)))
 
-        A = array([[2,1],[1,2]])
-        B = array([[1,2],[0.5,0.1]])
-        C = array([[1,0],[0,1]])
+        A = matrix([[2,1],[1,2]])
+        B = matrix([[1,2],[0.5,0.1]])
+        C = matrix([[1,0],[0,1]])
         X = dlyap(A,B,C)
         # print("The solution obtained is ", X)
-        assert_array_almost_equal(dot(A,dot(X,B.T))-X+C,zeros((2,2)))
+        assert_array_almost_equal(A * X * B.T - X + C, zeros((2,2)))
 
     def test_care(self):
-        A = array([[-2, -1],[-1, -1]])
-        Q = array([[0, 0],[0, 1]])
-        B = array([[1, 0],[0, 4]])
+        A = matrix([[-2, -1],[-1, -1]])
+        Q = matrix([[0, 0],[0, 1]])
+        B = matrix([[1, 0],[0, 4]])
 
         X,L,G = care(A,B,Q)
         # print("The solution obtained is", X)
-        assert_array_almost_equal(dot(A.T,X) + dot(X,A) - \
-            dot(X,dot(B,dot(B.T,X))) + Q , zeros((2,2)))
-        assert_array_almost_equal(dot(B.T,X) , G)
+        assert_array_almost_equal(A.T * X + X * A - X * B * B.T * X + Q,
+                                  zeros((2,2)))
+        assert_array_almost_equal(B.T * X, G)
 
     def test_care_g(self):
-        A = array([[-2, -1],[-1, -1]])
-        Q = array([[0, 0],[0, 1]])
-        B = array([[1, 0],[0, 4]])
-        R = array([[2, 0],[0, 1]])
-        S = array([[0, 0],[0, 0]])
-        E = array([[2, 1],[1, 2]])
+        A = matrix([[-2, -1],[-1, -1]])
+        Q = matrix([[0, 0],[0, 1]])
+        B = matrix([[1, 0],[0, 4]])
+        R = matrix([[2, 0],[0, 1]])
+        S = matrix([[0, 0],[0, 0]])
+        E = matrix([[2, 1],[1, 2]])
 
         X,L,G = care(A,B,Q,R,S,E)
         # print("The solution obtained is", X)
-        assert_array_almost_equal(dot(A.T,dot(X,E)) + dot(E.T,dot(X,A)) - \
-            dot(dot(dot(E.T,dot(X,B))+S,inv(R) ) ,
-            dot(B.T,dot(X,E))+S.T ) + Q , \
-            zeros((2,2)))
-        assert_array_almost_equal(dot( inv(R) , dot(B.T,dot(X,E)) + S.T) , G)
-
-        A = array([[-2, -1],[-1, -1]])
-        Q = array([[0, 0],[0, 1]])
-        B = array([[1],[0]])
+        assert_array_almost_equal(
+            A.T * X * E + E.T * X * A -
+            (E.T * X * B + S) * inv(R) * (B.T * X * E + S.T)  + Q, zeros((2,2)))
+        assert_array_almost_equal(inv(R) * (B.T * X * E + S.T), G)
+
+        A = matrix([[-2, -1],[-1, -1]])
+        Q = matrix([[0, 0],[0, 1]])
+        B = matrix([[1],[0]])
         R = 1
-        S = array([[1],[0]])
-        E = array([[2, 1],[1, 2]])
+        S = matrix([[1],[0]])
+        E = matrix([[2, 1],[1, 2]])
 
         X,L,G = care(A,B,Q,R,S,E)
         # print("The solution obtained is", X)
-        assert_array_almost_equal(dot(A.T,dot(X,E)) + dot(E.T,dot(X,A)) - \
-            dot( dot( dot(E.T,dot(X,B))+S,1/R ) , dot(B.T,dot(X,E))+S.T ) \
-            + Q , zeros((2,2)))
+        assert_array_almost_equal(
+            A.T * X * E + E.T * X * A -
+            (E.T * X * B + S) / R * (B.T * X * E + S.T) + Q , zeros((2,2)))
         assert_array_almost_equal(dot( 1/R , dot(B.T,dot(X,E)) + S.T) , G)
 
     def test_dare(self):
-        A = array([[-0.6, 0],[-0.1, -0.4]])
-        Q = array([[2, 1],[1, 0]])
-        B = array([[2, 1],[0, 1]])
-        R = array([[1, 0],[0, 1]])
+        A = matrix([[-0.6, 0],[-0.1, -0.4]])
+        Q = matrix([[2, 1],[1, 0]])
+        B = matrix([[2, 1],[0, 1]])
+        R = matrix([[1, 0],[0, 1]])
 
         X,L,G = dare(A,B,Q,R)
         # print("The solution obtained is", X)
-        assert_array_almost_equal(dot(A.T,dot(X,A))-X-dot(dot(dot(A.T,dot(X,B)) , \
-            inv(dot(B.T,dot(X,B))+R)) , dot(B.T,dot(X,A))) + Q , zeros((2,2)) )
-        assert_array_almost_equal( dot( inv( dot(B.T,dot(X,B)) + R) , \
-            dot(B.T,dot(X,A)) ) , G)
-
-        A = array([[1, 0],[-1, 1]])
-        Q = array([[0, 1],[1, 1]])
-        B = array([[1],[0]])
+        assert_array_almost_equal(
+            A.T * X * A - X -
+            A.T * X * B * inv(B.T * X * B + R) * B.T * X * A + Q, zeros((2,2)))
+        assert_array_almost_equal(inv(B.T * X * B + R) * B.T * X * A, G)
+
+        A = matrix([[1, 0],[-1, 1]])
+        Q = matrix([[0, 1],[1, 1]])
+        B = matrix([[1],[0]])
         R = 2
 
         X,L,G = dare(A,B,Q,R)
         # print("The solution obtained is", X)
-        assert_array_almost_equal(dot(A.T,dot(X,A))-X-dot(dot(dot(A.T,dot(X,B)) , \
-            inv(dot(B.T,dot(X,B))+R)) , dot(B.T,dot(X,A))) + Q , zeros((2,2)) )
-        assert_array_almost_equal( dot( 1 / ( dot(B.T,dot(X,B)) + R) , \
-            dot(B.T,dot(X,A)) ) , G)
+        assert_array_almost_equal(
+            A.T * X * A - X -
+            A.T * X * B * inv(B.T *  X * B + R) * B.T * X * A + Q, zeros((2,2)))
+        assert_array_almost_equal(B.T * X * A / (B.T * X * B + R), G)
 
     def test_dare_g(self):
-        A = array([[-0.6, 0],[-0.1, -0.4]])
-        Q = array([[2, 1],[1, 3]])
-        B = array([[1, 5],[2, 4]])
-        R = array([[1, 0],[0, 1]])
-        S = array([[1, 0],[2, 0]])
-        E = array([[2, 1],[1, 2]])
+        A = matrix([[-0.6, 0],[-0.1, -0.4]])
+        Q = matrix([[2, 1],[1, 3]])
+        B = matrix([[1, 5],[2, 4]])
+        R = matrix([[1, 0],[0, 1]])
+        S = matrix([[1, 0],[2, 0]])
+        E = matrix([[2, 1],[1, 2]])
 
         X,L,G = dare(A,B,Q,R,S,E)
         # print("The solution obtained is", X)
-        assert_array_almost_equal(dot(A.T,dot(X,A))-dot(E.T,dot(X,E)) - \
-            dot( dot(A.T,dot(X,B))+S , dot( inv(dot(B.T,dot(X,B)) + R) ,
-            dot(B.T,dot(X,A))+S.T)) + Q , zeros((2,2)) )
-        assert_array_almost_equal( dot( inv( dot(B.T,dot(X,B)) + R) , \
-            dot(B.T,dot(X,A)) + S.T ) , G)
-
-        A = array([[-0.6, 0],[-0.1, -0.4]])
-        Q = array([[2, 1],[1, 3]])
-        B = array([[1],[2]])
+        assert_array_almost_equal(
+            A.T * X * A - E.T * X * E -
+            (A.T * X * B + S) * inv(B.T * X * B + R) * (B.T * X * A + S.T) + Q,
+            zeros((2,2)) )
+        assert_array_almost_equal(inv(B.T * X * B + R) * (B.T * X * A + S.T), G)
+
+        A = matrix([[-0.6, 0],[-0.1, -0.4]])
+        Q = matrix([[2, 1],[1, 3]])
+        B = matrix([[1],[2]])
         R = 1
-        S = array([[1],[2]])
-        E = array([[2, 1],[1, 2]])
+        S = matrix([[1],[2]])
+        E = matrix([[2, 1],[1, 2]])
 
         X,L,G = dare(A,B,Q,R,S,E)
         # print("The solution obtained is", X)
-        assert_array_almost_equal(dot(A.T,dot(X,A))-dot(E.T,dot(X,E)) - \
-            dot( dot(A.T,dot(X,B))+S , dot( inv(dot(B.T,dot(X,B)) + R) ,
-            dot(B.T,dot(X,A))+S.T)) + Q , zeros((2,2)) )
-        assert_array_almost_equal( dot( 1 / ( dot(B.T,dot(X,B)) + R) , \
-            dot(B.T,dot(X,A)) + S.T ) , G)
+        assert_array_almost_equal(
+            A.T * X * A - E.T * X * E -
+            (A.T * X * B + S) * inv(B.T * X * B + R) * (B.T * X * A + S.T) + Q,
+            zeros((2,2)) )
+        assert_array_almost_equal((B.T * X * A + S.T) / (B.T * X * B + R), G)
 
 def suite():
     return unittest.TestLoader().loadTestsFromTestCase(TestMatrixEquations)
