8000 Improve readability of matrix equation tests · MorS25/python-control@8c1fdeb · GitHub
[go: up one dir, main page]
Skip to content

Commit 8c1fdeb

Browse files
cwrowleycwrowley
committed
Improve readability of matrix equation tests
1 parent 38514c9 commit 8c1fdeb

File tree

1 file changed

+98
-101
lines changed

1 file changed

+98
-101
lines changed

‎control/tests/mateqn_test.py

Lines changed: 98 additions & 101 deletions
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@
4343
"""
4444

4545
import unittest
46-
from numpy import array
46+
from numpy import matrix
4747
from numpy.testing import assert_array_almost_equal
4848
from numpy.linalg import inv
4949
from scipy import zeros,dot
@@ -55,175 +55,172 @@ class TestMatrixEquations(unittest.TestCase):
5555
"""These are tests for the matrix equation solvers in mateqn.py"""
5656

5757
def test_lyap(self):
58-
A = array([[-1, 1],[-1, 0]])
59-
Q = array([[1,0],[0,1]])
58+
A = matrix([[-1, 1],[-1, 0]])
59+
Q = matrix([[1,0],[0,1]])
6060
X = lyap(A,Q)
6161
# print("The solution obtained is ", X)
62-
assert_array_almost_equal(dot(A,X)+dot(X,A.T)+Q,zeros((2,2)))
62+
assert_array_almost_equal(A * X + X * A.T + Q, zeros((2,2)))
6363

64-
A = array([[1, 2],[-3, -4]])
65-
Q = array([[3, 1],[1, 1]])
64+
A = matrix([[1, 2],[-3, -4]])
65+
Q = matrix([[3, 1],[1, 1]])
6666
X = lyap(A,Q)
6767
# print("The solution obtained is ", X)
68-
assert_array_almost_equal(dot(A,X)+dot(X,A.T)+Q,zeros((2,2)))
68+
assert_array_almost_equal(A * X + X * A.T + Q, zeros((2,2)))
6969

7070
def test_lyap_sylvester(self):
7171
A = 5
72-
B = array([[4, 3], [4, 3]])
73-
C = array([2, 1])
72+
B = matrix([[4, 3], [4, 3]])
73+
C = matrix([2, 1])
7474
X = lyap(A,B,C)
7575
# print("The solution obtained is ", X)
76-
assert_array_almost_equal(dot(A,X)+dot(X,B)+C,zeros((1,2)))
76+
assert_array_almost_equal(A * X + X * B + C, zeros((1,2)))
7777

78-
A = array([[2,1],[1,2]])
79-
B = array([[1,2],[0.5,0.1]])
80-
C = array([[1,0],[0,1]])
78+
A = matrix([[2,1],[1,2]])
79+
B = matrix([[1,2],[0.5,0.1]])
80+
C = matrix([[1,0],[0,1]])
8181
X = lyap(A,B,C)
8282
# print("The solution obtained is ", X)
83-
assert_array_almost_equal(dot(A,X)+dot(X,B)+C,zeros((2,2)))
83+
assert_array_almost_equal(A * X + X * B + C, zeros((2,2)))
8484

8585
def test_lyap_g(self):
86-
A = array([[-1, 2],[-3, -4]])
87-
Q = array([[3, 1],[1, 1]])
88-
E = array([[1,2],[2,1]])
86+
A = matrix([[-1, 2],[-3, -4]])
87+
Q = matrix([[3, 1],[1, 1]])
88+
E = matrix([[1,2],[2,1]])
8989
X = lyap(A,Q,None,E)
9090
# print("The solution obtained is ", X)
91-
assert_array_almost_equal(dot(A,dot(X,E.T)) + dot(E,dot(X,A.T)) + Q, \
92-
zeros((2,2)))
91+
assert_array_almost_equal(A * X * E.T + E * X * A.T + Q, zeros((2,2)))
9392

9493
def test_dlyap(self):
95-
A = array([[-0.6, 0],[-0.1, -0.4]])
96-
Q = array([[1,0],[0,1]])
94+
A = matrix([[-0.6, 0],[-0.1, -0.4]])
95+
Q = matrix([[1,0],[0,1]])
9796
X = dlyap(A,Q)
9897
# print("The solution obtained is ", X)
99-
assert_array_almost_equal(dot(A,dot(X,A.T))-X+Q,zeros((2,2)))
98+
assert_array_almost_equal(A * X * A.T - X + Q, zeros((2,2)))
10099

101-
A = array([[-0.6, 0],[-0.1, -0.4]])
102-
Q = array([[3, 1],[1, 1]])
100+
A = matrix([[-0.6, 0],[-0.1, -0.4]])
101+
Q = matrix([[3, 1],[1, 1]])
103102
X = dlyap(A,Q)
104103
# print("The solution obtained is ", X)
105-
assert_array_almost_equal(dot(A,dot(X,A.T))-X+Q,zeros((2,2)))
104+
assert_array_almost_equal(A * X * A.T - X + Q, zeros((2,2)))
106105

107106
def test_dlyap_g(self):
108-
A = array([[-0.6, 0],[-0.1, -0.4]])
109-
Q = array([[3, 1],[1, 1]])
110-
E = array([[1, 1],[2, 1]])
107+
A = matrix([[-0.6, 0],[-0.1, -0.4]])
108+
Q = matrix([[3, 1],[1, 1]])
109+
E = matrix([[1, 1],[2, 1]])
111110
X = dlyap(A,Q,None,E)
112111
# print("The solution obtained is ", X)
113-
assert_array_almost_equal(dot(A,dot(X,A.T))-dot(E,dot(X,E.T))+Q, \
114-
zeros((2,2)))
112+
assert_array_almost_equal(A * X * A.T - E * X * E.T + Q, zeros((2,2)))
115113

116114
def test_dlyap_sylvester(self):
117115
A = 5
118-
B = array([[4, 3], [4, 3]])
119-
C = array([2, 1])
116+
B = matrix([[4, 3], [4, 3]])
117+
C = matrix([2, 1])
120118
X = dlyap(A,B,C)
121119
# print("The solution obtained is ", X)
122-
assert_array_almost_equal(dot(A,dot(X,B.T))-X+C,zeros((1,2)))
120+
assert_array_almost_equal(A * X * B.T - X + C, zeros((1,2)))
123121

124-
A = array([[2,1],[1,2]])
125-
B = array([[1,2],[0.5,0.1]])
126-
C = array([[1,0],[0,1]])
122+
A = matrix([[2,1],[1,2]])
123+
B = matrix([[1,2],[0.5,0.1]])
124+
C = matrix([[1,0],[0,1]])
127125
X = dlyap(A,B,C)
128126
# print("The solution obtained is ", X)
129-
assert_array_almost_equal(dot(A,dot(X,B.T))-X+C,zeros((2,2)))
127+
assert_array_almost_equal(A * X * B.T - X + C, zeros((2,2)))
130128

131129
def test_care(self):
132-
A = array([[-2, -1],[-1, -1]])
133-
Q = array([[0, 0],[0, 1]])
134-
B = array([[1, 0],[0, 4]])
130+
A = matrix([[-2, -1],[-1, -1]])
131+
Q = matrix([[0, 0],[0, 1]])
132+
B = matrix([[1, 0],[0, 4]])
135133

136134
X,L,G = care(A,B,Q)
137135 E377
# print("The solution obtained is", X)
138-
assert_array_almost_equal(dot(A.T,X) + dot(X,A) - \
139-
dot(X,dot(B,dot(B.T,X))) + Q , zeros((2,2)))
140-
assert_array_almost_equal(dot(B.T,X) , G)
136+
assert_array_almost_equal(A.T * X + X * A - X * B * B.T * X + Q,
137+
zeros((2,2)))
138+
assert_array_almost_equal(B.T * X, G)
141139

142140
def test_care_g(self):
143-
A = array([[-2, -1],[-1, -1]])
144-
Q = array([[0, 0],[0, 1]])
145-
B = array([[1, 0],[0, 4]])
146-
R = array([[2, 0],[0, 1]])
147-
S = array([[0, 0],[0, 0]])
148-
E = array([[2, 1],[1, 2]])
141+
A = matrix([[-2, -1],[-1, -1]])
142+
Q = matrix([[0, 0],[0, 1]])
143+
B = matrix([[1, 0],[0, 4]])
144+
R = matrix([[2, 0],[0, 1]])
145+
S = matrix([[0, 0],[0, 0]])
146+
E = matrix([[2, 1],[1, 2]])
149147

150148
X,L,G = care(A,B,Q,R,S,E)
151149
# print("The solution obtained is", X)
152-
assert_array_almost_equal(dot(A.T,dot(X,E)) + dot(E.T,dot(X,A)) - \
153-
dot(dot(dot(E.T,dot(X,B))+S,inv(R) ) ,
154-
dot(B.T,dot(X,E))+S.T ) + Q , \
155-
zeros((2,2)))
156-
assert_array_almost_equal(dot( inv(R) , dot(B.T,dot(X,E)) + S.T) , G)
157-
158-
A = array([[-2, -1],[-1, -1]])
159-
Q = array([[0, 0],[0, 1]])
160-
B = array([[1],[0]])
150+
assert_array_almost_equal(
151+
A.T * X * E + E.T * X * A -
152+
(E.T * X * B + S) * inv(R) * (B.T * X * E + S.T) + Q, zeros((2,2)))
153+
assert_array_almost_equal(inv(R) * (B.T * X * E + S.T), G)
154+
155+
A = matrix([[-2, -1],[-1, -1]])
156+
Q = matrix([[0, 0],[0, 1]])
157+
B = matrix([[1],[0]])
161158
R = 1
162-
S = array([[1],[0]])
163-
E = array([[2, 1],[1, 2]])
159+
S = matrix([[1],[0]])
160+
E = matrix([[2, 1],[1, 2]])
164161

165162
X,L,G = care(A,B,Q,R,S,E)
166163
# print("The solution obtained is", X)
167-
assert_array_almost_equal(dot(A.T,dot(X,E)) + dot(E.T,dot(X,A)) - \
168-
dot( dot( dot(E.T,dot(X,B))+S,1/R ) , dot(B.T,dot(X,E))+S.T ) \
169-
+ Q , zeros((2,2)))
164+
assert_array_almost_equal(
165+
A.T * X * E + E.T * X * A -
166+
(E.T * X * B + S) / R * (B.T * X * E + S.T) + Q , zeros((2,2)))
170167
assert_array_almost_equal(dot( 1/R , dot(B.T,dot(X,E)) + S.T) , G)
171168

172169
def test_dare(self):
173-
A = array([[-0.6, 0],[-0.1, -0.4]])
174-
Q = array([[2, 1],[1, 0]])
175-
B = array([[2, 1],[0, 1]])
176-
R = array([[1, 0],[0, 1]])
170+
A = matrix([[-0.6, 0],[-0.1, -0.4]])
171+
Q = matrix([[2, 1],[1, 0]])
172+
B = matrix([[2, 1],[0, 1]])
173+
R = matrix([[1, 0],[0, 1]])
177174

178175
X,L,G = dare(A,B,Q,R)
179176
# print("The solution obtained is", X)
180-
assert_array_almost_equal(dot(A.T,dot(X,A))-X-dot(dot(dot(A.T,dot(X,B)) , \
181-
inv(dot(B.T,dot(X,B))+R)) , dot(B.T,dot(X,A))) + Q , zeros((2,2)) )
182-
assert_array_almost_equal( dot( inv( dot(B.T,dot(X,B)) + R) , \
183-
dot(B.T,dot(X,A)) ) , G)
184-
185-
A = array([[1, 0],[-1, 1]])
186-
Q = array([[0, 1],[1, 1]])
187-
B = array([[1],[0]])
177+
assert_array_almost_equal(
178+
A.T * X * A - X -
179+
A.T * X * B * inv(B.T * X * B + R) * B.T * X * A + Q, zeros((2,2)))
180+
assert_array_almost_equal(inv(B.T * X * B + R) * B.T * X * A, G)
181+
182+
A = matrix([[1, 0],[-1, 1]])
183+
Q = matrix([[0, 1],[1, 1]])
184+
B = matrix([[1],[0]])
188185
R = 2
189186

190187
X,L,G = dare(A,B,Q,R)
191188
# print("The solution obtained is", X)
192-
assert_array_almost_equal(dot(A.T,dot(X,A))-X-dot(dot(dot(A.T,dot(X,B)) , \
193-
inv(dot(B.T,dot(X,B))+R)) , dot(B.T,dot(X,A))) + Q , zeros((2,2)) )
194-
assert_array_almost_equal( dot( 1 / ( dot(B.T,dot(X,B)) + R) , \
195-
dot(B.T,dot(X,A)) ) , G)
189+
assert_array_almost_equal(
190+
A.T * X * A - X -
191+
A.T * X * B * inv(B.T * X * B + R) * B.T * X * A + Q, zeros((2,2)))
192+
assert_array_almost_equal(B.T * X * A / (B.T * X * B + R), G)
196193

197194
def test_dare_g(self):
198-
A = array([[-0.6, 0],[-0.1, -0.4]])
199-
Q = array([[2, 1],[1, 3]])
200-
B = array([[1, 5],[2, 4]])
201-
R = array([[1, 0],[0, 1]])
202-
S = array([[1, 0],[2, 0]])
203-
E = array([[2, 1],[1, 2]])
195+
A = matrix([[-0.6, 0],[-0.1, -0.4]])
196+
Q = matrix([[2, 1],[1, 3]])
197+
B = matrix([[1, 5],[2, 4]])
198+
R = matrix([[1, 0],[0, 1]])
199+
S = matrix([[1, 0],[2, 0]])
200+
E = matrix([[2, 1],[1, 2]])
204201

205202
X,L,G = dare(A,B,Q,R,S,E)
206203
# print("The solution obtained is", X)
207-
assert_array_almost_equal(dot(A.T,dot(X,A))-dot(E.T,dot(X,E)) - \
208-
dot( dot(A.T,dot(X,B))+S , dot( inv(dot(B.T,dot(X,B)) + R) ,
209-
dot(B.T,dot(X,A))+S.T)) + Q , zeros((2,2)) )
210-
assert_array_almost_equal( dot( inv( dot(B.T,dot(X,B)) + R) , \
211-
dot(B.T,dot(X,A)) + S.T ) , G)
212-
213-
A = array([[-0.6, 0],[-0.1, -0.4]])
214-
Q = array([[2, 1],[1, 3]])
215-
B = array([[1],[2]])
204+
assert_array_almost_equal(
205+
A.T * X * A - E.T * X * E -
206+
(A.T * X * B + S) * inv(B.T * X * B + R) * (B.T * X * A + S.T) + Q,
207+
zeros((2,2)) )
208+
assert_array_almost_equal(inv(B.T * X * B + R) * (B.T * X * A + S.T), G)
209+
210+
A = matrix([[-0.6, 0],[-0.1, -0.4]])
211+
Q = matrix([[2, 1],[1, 3]])
212+
B = matrix([[1],[2]])
216213
R = 1
217-
S = array([[1],[2]])
218-
E = array([[2, 1],[1, 2]])
214+
S = matrix([[1],[2]])
215+
E = matrix([[2, 1],[1, 2]])
219216

220217
X,L,G = dare(A,B,Q,R,S,E)
221218
# print("The solution obtained is", X)
222-
assert_array_almost_equal(dot(A.T,dot(X,A))-dot(E.T,dot(X,E)) - \
223-
dot( dot(A.T,dot(X,B))+S , dot( inv(dot(B.T,dot(X,B)) + R) ,
224-
dot(B.T,dot(X,A))+S.T)) + Q , zeros((2,2)) )
225-
assert_array_almost_equal( dot( 1 / ( dot(B.T,dot(X,B)) + R) , \
226-
dot(B.T,dot(X,A)) + S.T ) , G)
219+
assert_array_almost_equal(
220+
A.T * X * A - E.T * X * E -
221+
(A.T * X * B + S) * inv(B.T * X * B + R) * (B.T * X * A + S.T) + Q,
222+
zeros((2,2)) )
223+
assert_array_almost_equal((B.T * X * A + S.T) / (B.T * X * B + R), G)
227224

228225
def suite():
229226
return unittest.TestLoader().loadTestsFromTestCase(TestMatrixEquations)

0 commit comments

Comments
 (0)
0