Skip to content

Commit 5b28121

Browse files
bnavigatorbnavigator
committed
replace ndarray.dot in tests
1 parent de85969 commit 5b28121

File tree

5 files changed

+67
-67
lines changed

5 files changed

+67
-67
lines changed

‎control/tests/canonical_test.py

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -29,9 +29,9 @@ def test_reachable_form(self):
2929
[-0.74855725, -0.39136285, -0.18142339, -0.50356997],
3030
[-0.40688007, 0.81416369, 0.38002113, -0.16483334],
3131
[-0.44769516, 0.15654653, -0.50060858, 0.72419146]])
32-
A = np.linalg.solve(T_true, A_true).dot(T_true)
32+
A = np.linalg.solve(T_true, A_true) @ T_true
3333
B = np.linalg.solve(T_true, B_true)
34-
C = C_true.dot(T_true)
34+
C = C_true @ T_true
3535
D = D_true
3636

3737
# Create a state space system and convert it to the reachable canonical form
@@ -77,9 +77,9 @@ def test_observable_form(self):
7777
[-0.74855725, -0.39136285, -0.18142339, -0.50356997],
7878
[-0.40688007, 0.81416369, 0.38002113, -0.16483334],
7979
[-0.44769516, 0.15654653, -0.50060858, 0.72419146]])
80-
A = np.linalg.solve(T_true, A_true).dot(T_true)
80+
A = np.linalg.solve(T_true, A_true) @ T_true
8181
B = np.linalg.solve(T_true, B_true)
82-
C = C_true.dot(T_true)
82+
C = C_true @ T_true
8383
D = D_true
8484

8585
# Create a state space system and convert it to the observable canonical form
@@ -266,7 +266,7 @@ def test_bdschur_ref(eigvals, condmax, blksizes):
266266
bdiag_b = scipy.linalg.block_diag(*extract_bdiag(b, test_blksizes))
267267
np.testing.assert_array_almost_equal(bdiag_b, b)
268268

269-
np.testing.assert_array_almost_equal(solve(t, a).dot(t), b)
269+
np.testing.assert_array_almost_equal(solve(t, a) @ t, b)
270270

271271

272272
@slycotonly
@@ -357,9 +357,9 @@ def test_modal_form(A_true, B_true, C_true, D_true):
357357
[-0.74855725, -0.39136285, -0.18142339, -0.50356997],
358358
[-0.40688007, 0.81416369, 0.38002113, -0.16483334],
359359
[-0.44769516, 0.15654653, -0.50060858, 0.72419146]])
360-
A = np.linalg.solve(T_true, A_true).dot(T_true)
360+
A = np.linalg.solve(T_true, A_true) @ T_true
361361
B = np.linalg.solve(T_true, B_true)
362-
C = C_true.dot(T_true)
362+
C = C_true @ T_true
363363
D = D_true
364364

365365
# Create a state space system and convert it to modal canonical form
@@ -370,7 +370,7 @@ def test_modal_form(A_true, B_true, C_true, D_true):
370370
np.testing.assert_array_almost_equal(sys_check.A, a_bds)
371371
np.testing.assert_array_almost_equal(T_check, t_bds)
372372
np.testing.assert_array_almost_equal(sys_check.B, np.linalg.solve(t_bds, B))
373-
np.testing.assert_array_almost_equal(sys_check.C, C.dot(t_bds))
373+
np.testing.assert_array_almost_equal(sys_check.C, C @ t_bds)
374374
np.testing.assert_array_almost_equal(sys_check.D, D)
375375

376376
# canonical_form(...,'modal') is the same as modal_form with default parameters
@@ -403,7 +403,7 @@ def test_modal_form_condmax(condmax, len_blksizes):
403403
np.testing.assert_array_almost_equal(zsys.A, amodal)
404404
np.testing.assert_array_almost_equal(t, tmodal)
405405
np.testing.assert_array_almost_equal(zsys.B, np.linalg.solve(tmodal, xsys.B))
406-
np.testing.assert_array_almost_equal(zsys.C, xsys.C.dot(tmodal))
406+
np.testing.assert_array_almost_equal(zsys.C, xsys.C @ tmodal)
407407
np.testing.assert_array_almost_equal(zsys.D, xsys.D)
408408

409409

@@ -421,13 +421,13 @@ def test_modal_form_sort(sys_type):
421421
xsys = ss(a, [[1],[0],[0],[0],], [0,0,0,1], 0, dt)
422422
zsys, t = modal_form(xsys, sort=True)
423423

424-
my_amodal = np.linalg.solve(tmodal, a).dot(tmodal)
424+
my_amodal = np.linalg.solve(tmodal, a) @ tmodal
425425
np.testing.assert_array_almost_equal(amodal, my_amodal)
426426

427427
np.testing.assert_array_almost_equal(t, tmodal)
428428
np.testing.assert_array_almost_equal(zsys.A, amodal)
429429
np.testing.assert_array_almost_equal(zsys.B, np.linalg.solve(tmodal, xsys.B))
430-
np.testing.assert_array_almost_equal(zsys.C, xsys.C.dot(tmodal))
430+
np.testing.assert_array_almost_equal(zsys.C, xsys.C @ tmodal)
431431
np.testing.assert_array_almost_equal(zsys.D, xsys.D)
432432

433433

‎control/tests/mateqn_test.py

Lines changed: 38 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -52,58 +52,58 @@ def test_lyap(self):
5252
Q = array([[1,0],[0,1]])
5353
X = lyap(A,Q)
5454
# print("The solution obtained is ", X)
55-
assert_array_almost_equal(A.dot(X) + X.dot(A.T) + Q, zeros((2,2)))
55+
assert_array_almost_equal(A @ X + X @ A.T + Q, zeros((2,2)))
5656

5757
A = array([[1, 2],[-3, -4]])
5858
Q = array([[3, 1],[1, 1]])
5959
X = lyap(A,Q)
6060
# print("The solution obtained is ", X)
61-
assert_array_almost_equal(A.dot(X) + X.dot(A.T) + Q, zeros((2,2)))
61+
assert_array_almost_equal(A @ X + X @ A.T + Q, zeros((2,2)))
6262

6363
def test_lyap_sylvester(self):
6464
A = 5
6565
B = array([[4, 3], [4, 3]])
6666
C = array([2, 1])
6767
X = lyap(A,B,C)
6868
# print("The solution obtained is ", X)
69-
assert_array_almost_equal(A * X + X.dot(B) + C, zeros((1,2)))
69+
assert_array_almost_equal(A * X + X @ B + C, zeros((1,2)))
7070

7171
A = array([[2,1],[1,2]])
7272
B = array([[1,2],[0.5,0.1]])
7373
C = array([[1,0],[0,1]])
7474
X = lyap(A,B,C)
7575
# print("The solution obtained is ", X)
76-
assert_array_almost_equal(A.dot(X) + X.dot(B) + C, zeros((2,2)))
76+
assert_array_almost_equal(A @ X + X @ B + C, zeros((2,2)))
7777

7878
def test_lyap_g(self):
7979
A = array([[-1, 2],[-3, -4]])
8080
Q = array([[3, 1],[1, 1]])
8181
E = array([[1,2],[2,1]])
8282
X = lyap(A,Q,None,E)
8383
# print("The solution obtained is ", X)
84-
assert_array_almost_equal(A.dot(X).dot(E.T) + E.dot(X).dot(A.T) + Q,
84+
assert_array_almost_equal(A @ X @ E.T + E @ X @ A.T + Q,
8585
zeros((2,2)))
8686

8787
def test_dlyap(self):
8888
A = array([[-0.6, 0],[-0.1, -0.4]])
8989
Q = array([[1,0],[0,1]])
9090
X = dlyap(A,Q)
9191
# print("The solution obtained is ", X)
92-
assert_array_almost_equal(A.dot(X).dot(A.T) - X + Q, zeros((2,2)))
92+
assert_array_almost_equal(A @ X @ A.T - X + Q, zeros((2,2)))
9393

9494
A = array([[-0.6, 0],[-0.1, -0.4]])
9595
Q = array([[3, 1],[1, 1]])
9696
X = dlyap(A,Q)
9797
# print("The solution obtained is ", X)
98-
assert_array_almost_equal(A.dot(X).dot(A.T) - X + Q, zeros((2,2)))
98+
assert_array_almost_equal(A @ X @ A.T - X + Q, zeros((2,2)))
9999

100100
def test_dlyap_g(self):
101101
A = array([[-0.6, 0],[-0.1, -0.4]])
102102
Q = array([[3, 1],[1, 1]])
103103
E = array([[1, 1],[2, 1]])
104104
X = dlyap(A,Q,None,E)
105105
# print("The solution obtained is ", X)
106-
assert_array_almost_equal(A.dot(X).dot(A.T) - E.dot(X).dot(E.T) + Q,
106+
assert_array_almost_equal(A @ X @ A.T - E @ X @ E.T + Q,
107107
zeros((2,2)))
108108

109109
def test_dlyap_sylvester(self):
@@ -112,14 +112,14 @@ def test_dlyap_sylvester(self):
112112
C = array([2, 1])
113113
X = dlyap(A,B,C)
114114
# print("The solution obtained is ", X)
115-
assert_array_almost_equal(A * X.dot(B.T) - X + C, zeros((1,2)))
115+
assert_array_almost_equal(A * X @ B.T - X + C, zeros((1,2)))
116116

117117
A = array([[2,1],[1,2]])
118118
B = array([[1,2],[0.5,0.1]])
119119
C = array([[1,0],[0,1]])
120120
X = dlyap(A,B,C)
121121
# print("The solution obtained is ", X)
122-
assert_array_almost_equal(A.dot(X).dot(B.T) - X + C, zeros((2,2)))
122+
assert_array_almost_equal(A @ X @ B.T - X + C, zeros((2,2)))
123123

124124
def test_care(self):
125125
A = array([[-2, -1],[-1, -1]])
@@ -128,10 +128,10 @@ def test_care(self):
128128

129129
X,L,G = care(A,B,Q)
130130
# print("The solution obtained is", X)
131-
M = A.T.dot(X) + X.dot(A) - X.dot(B).dot(B.T).dot(X) + Q
131+
M = A.T @ X + X @ A - X @ B @ B.T @ X + Q
132132
assert_array_almost_equal(M,
133133
zeros((2,2)))
134-
assert_array_almost_equal(B.T.dot(X), G)
134+
assert_array_almost_equal(B.T @ X, G)
135135

136136
def test_care_g(self):
137137
A = array([[-2, -1],[-1, -1]])
@@ -143,11 +143,11 @@ def test_care_g(self):
143143

144144
X,L,G = care(A,B,Q,R,S,E)
145145
# print("The solution obtained is", X)
146-
Gref = solve(R, B.T.dot(X).dot(E) + S.T)
146+
Gref = solve(R, B.T @ X @ E + S.T)
147147
assert_array_almost_equal(Gref, G)
148148
assert_array_almost_equal(
149-
A.T.dot(X).dot(E) + E.T.dot(X).dot(A)
150-
- (E.T.dot(X).dot(B) + S).dot(Gref) + Q,
149+
A.T @ X @ E + E.T @ X @ A
150+
- (E.T @ X @ B + S) @ Gref + Q,
151151
zeros((2,2)))
152152

153153
def test_care_g2(self):
@@ -160,10 +160,10 @@ def test_care_g2(self):
160160

161161
X,L,G = care(A,B,Q,R,S,E)
162162
# print("The solution obtained is", X)
163-
Gref = 1/R * (B.T.dot(X).dot(E) + S.T)
163+
Gref = 1/R * (B.T @ X @ E + S.T)
164164
assert_array_almost_equal(
165-
A.T.dot(X).dot(E) + E.T.dot(X).dot(A)
166-
- (E.T.dot(X).dot(B) + S).dot(Gref) + Q ,
165+
A.T @ X @ E + E.T @ X @ A
166+
- (E.T @ X @ B + S) @ Gref + Q ,
167167
zeros((2,2)))
168168
assert_array_almost_equal(Gref , G)
169169

@@ -175,12 +175,12 @@ def test_dare(self):
175175

176176
X,L,G = dare(A,B,Q,R)
177177
# print("The solution obtained is", X)
178-
Gref = solve(B.T.dot(X).dot(B) + R, B.T.dot(X).dot(A))
178+
Gref = solve(B.T @ X @ B + R, B.T @ X @ A)
179179
assert_array_almost_equal(Gref, G)
180180
assert_array_almost_equal(
181-
X, A.T.dot(X).dot(A) - A.T.dot(X).dot(B).dot(Gref) + Q)
181+
X, A.T @ X @ A - A.T @ X @ B @ Gref + Q)
182182
# check for stable closed loop
183-
lam = eigvals(A - B.dot(G))
183+
lam = eigvals(A - B @ G)
184184
assert_array_less(abs(lam), 1.0)
185185

186186
A = array([[1, 0],[-1, 1]])
@@ -190,15 +190,15 @@ def test_dare(self):
190190

191191
X,L,G = dare(A,B,Q,R)
192192
# print("The solution obtained is", X)
193-
AtXA = A.T.dot(X).dot(A)
194-
AtXB = A.T.dot(X).dot(B)
195-
BtXA = B.T.dot(X).dot(A)
196-
BtXB = B.T.dot(X).dot(B)
193+
AtXA = A.T @ X @ A
194+
AtXB = A.T @ X @ B
195+
BtXA = B.T @ X @ A
196+
BtXB = B.T @ X @ B
197197
assert_array_almost_equal(
198-
X, AtXA - AtXB.dot(solve(BtXB + R, BtXA)) + Q)
198+
X, AtXA - AtXB @ solve(BtXB + R, BtXA) + Q)
199199
assert_array_almost_equal(BtXA / (BtXB + R), G)
200200
# check for stable closed loop
201-
lam = eigvals(A - B.dot(G))
201+
lam = eigvals(A - B @ G)
202202
assert_array_less(abs(lam), 1.0)
203203

204204
def test_dare_g(self):
@@ -211,13 +211,13 @@ def test_dare_g(self):
211211

212212
X,L,G = dare(A,B,Q,R,S,E)
213213
# print("The solution obtained is", X)
214-
Gref = solve(B.T.dot(X).dot(B) + R, B.T.dot(X).dot(A) + S.T)
214+
Gref = solve(B.T @ X @ B + R, B.T @ X @ A + S.T)
215215
assert_array_almost_equal(Gref, G)
216216
assert_array_almost_equal(
217-
E.T.dot(X).dot(E),
218-
A.T.dot(X).dot(A) - (A.T.dot(X).dot(B) + S).dot(Gref) + Q)
217+
E.T @ X @ E,
218+
A.T @ X @ A - (A.T @ X @ B + S) @ Gref + Q)
219219
# check for stable closed loop
220-
lam = eigvals(A - B.dot(G), E)
220+
lam = eigvals(A - B @ G, E)
221221
assert_array_less(abs(lam), 1.0)
222222

223223
def test_dare_g2(self):
@@ -230,16 +230,16 @@ def test_dare_g2(self):
230230

231231
X, L, G = dare(A, B, Q, R, S, E)
232232
# print("The solution obtained is", X)
233-
AtXA = A.T.dot(X).dot(A)
234-
AtXB = A.T.dot(X).dot(B)
235-
BtXA = B.T.dot(X).dot(A)
236-
BtXB = B.T.dot(X).dot(B)
237-
EtXE = E.T.dot(X).dot(E)
233+
AtXA = A.T @ X @ A
234+
AtXB = A.T @ X @ B
235+
BtXA = B.T @ X @ A
236+
BtXB = B.T @ X @ B
237+
EtXE = E.T @ X @ E
238238
assert_array_almost_equal(
239-
EtXE, AtXA - (AtXB + S).dot(solve(BtXB + R, BtXA + S.T)) + Q)
239+
EtXE, AtXA - (AtXB + S) @ solve(BtXB + R, BtXA + S.T) + Q)
240240
assert_array_almost_equal((BtXA + S.T) / (BtXB + R), G)
241241
# check for stable closed loop
242-
lam = eigvals(A - B.dot(G), E)
242+
lam = eigvals(A - B @ G, E)
243243
assert_array_less(abs(lam), 1.0)
244244

245245
def test_raise(self):

‎control/tests/statefbk_test.py

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -203,7 +203,7 @@ def testPlace(self, matarrayin):
203203
P = matarrayin([-0.5 + 1j, -0.5 - 1j, -5.0566, -8.6659])
204204
K = place(A, B, P)
205205
assert ismatarrayout(K)
206-
P_placed = np.linalg.eigvals(A - B.dot(K))
206+
P_placed = np.linalg.eigvals(A - B @ K)
207207
self.checkPlaced(P, P_placed)
208208

209209
# Test that the dimension checks work.
@@ -228,7 +228,7 @@ def testPlace_varga_continuous(self, matarrayin):
228228

229229
P = [-2., -2.]
230230
K = place_varga(A, B, P)
231-
P_placed = np.linalg.eigvals(A - B.dot(K))
231+
P_placed = np.linalg.eigvals(A - B @ K)
232232
self.checkPlaced(P, P_placed)
233233

234234
# Test that the dimension checks work.
@@ -241,7 +241,7 @@ def testPlace_varga_continuous(self, matarrayin):
241241
B = matarrayin([[0], [1]])
242242
P = matarrayin([-20 + 10*1j, -20 - 10*1j])
243243
K = place_varga(A, B, P)
244-
P_placed = np.linalg.eigvals(A - B.dot(K))
244+
P_placed = np.linalg.eigvals(A - B @ K)
245245
self.checkPlaced(P, P_placed)
246246

247247

@@ -261,7 +261,7 @@ def testPlace_varga_continuous_partial_eigs(self, matarrayin):
261261
alpha = -1.5
262262
K = place_varga(A, B, P, alpha=alpha)
263263

264-
P_placed = np.linalg.eigvals(A - B.dot(K))
264+
P_placed = np.linalg.eigvals(A - B @ K)
265265
# No guarantee of the ordering, so sort them
266266
self.checkPlaced(P_expected, P_placed)
267267

@@ -275,7 +275,7 @@ def testPlace_varga_discrete(self, matarrayin):
275275

276276
P = matarrayin([0.5, 0.5])
277277
K = place_varga(A, B, P, dtime=True)
278-
P_placed = np.linalg.eigvals(A - B.dot(K))
278+
P_placed = np.linalg.eigvals(A - B @ K)
279279
# No guarantee of the ordering, so sort them
280280
self.checkPlaced(P, P_placed)
281281

@@ -293,12 +293,12 @@ def testPlace_varga_discrete_partial_eigs(self, matarrayin):
293293
P_expected = np.array([0.5, 0.6])
294294
alpha = 0.51
295295
K = place_varga(A, B, P, dtime=True, alpha=alpha)
296-
P_placed = np.linalg.eigvals(A - B.dot(K))
296+
P_placed = np.linalg.eigvals(A - B @ K)
297297
self.checkPlaced(P_expected, P_placed)
298298

299299

300300
def check_LQR(self, K, S, poles, Q, R):
301-
S_expected = asmatarrayout(np.sqrt(Q.dot(R)))
301+
S_expected = asmatarrayout(np.sqrt(Q @ R))
302302
K_expected = asmatarrayout(S_expected / R)
303303
poles_expected = -np.squeeze(np.asarray(K_expected))
304304
np.testing.assert_array_almost_equal(S, S_expected)
@@ -373,7 +373,7 @@ def test_lqr_call_format(self):
373373
K, S, E = lqr(sys.A, sys.B, sys.C, R, Q)
374374

375375
def check_LQE(self, L, P, poles, G, QN, RN):
376-
P_expected = asmatarrayout(np.sqrt(G.dot(QN.dot(G).dot(RN))))
376+
P_expected = asmatarrayout(np.sqrt(G @ QN @ G @ RN))
377377
L_expected = asmatarrayout(P_expected / RN)
378378
poles_expected = -np.squeeze(np.asarray(L_expected))
379379
np.testing.assert_array_almost_equal(P, P_expected)

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy