update tests

Author: HumphreyYang

quantecon/tests/test_kalman.py

@@ -17,8 +17,8 @@ def setup_method(self):
         self.G = np.eye(2) * .5
         self.H = np.eye(2) * np.sqrt(0.2)
 
-        self.Q = np.dot(self.C, self.C.T)
-        self.R = np.dot(self.H, self.H.T)
+        self.Q = self.C @ self.C.T
+        self.R = self.H @ self.H.T
 
         ss = LinearStateSpace(self.A, self.C, self.G, self.H)
 
@@ -38,13 +38,13 @@ def test_stationarity(self):
         for method in self.methods:
             sig_inf, kal_gain = kf.stationary_values(method=method)
 
-            mat_inv = np.linalg.inv(G.dot(sig_inf).dot(G.T) + R)
+            mat_inv = np.linalg.inv(G @ sig_inf @ G.T + R)
 
             # Compute the kalmain gain and sigma infinity according to the
             # recursive equations and compare
-            kal_recursion = np.dot(A, sig_inf).dot(G.T).dot(mat_inv)
-            sig_recursion = (A.dot(sig_inf).dot(A.T) -
-                                kal_recursion.dot(G).dot(sig_inf).dot(A.T) + Q)
+            kal_recursion = A @ sig_inf @ G.T @ mat_inv
+            sig_recursion = (A @ sig_inf @ A.T -
+                                kal_recursion @ G @ sig_inf @ A.T + Q)
 
             assert_allclose(kal_gain, kal_recursion, rtol=1e-4, atol=1e-2)
             assert_allclose(sig_inf, sig_recursion, rtol=1e-4, atol=1e-2)
@@ -75,12 +75,12 @@ def test_update_nonstationary(self):
         kf.set_state(curr_x, curr_sigma)
         kf.update(y_observed)
 
-        mat_inv = np.linalg.inv(G.dot(curr_sigma).dot(G.T) + R)
-        curr_k = np.dot(A, curr_sigma).dot(G.T).dot(mat_inv)
-        new_sigma = (A.dot(curr_sigma).dot(A.T) -
-                    curr_k.dot(G).dot(curr_sigma).dot(A.T) + Q)
+        mat_inv = np.linalg.inv(G @ curr_sigma @ G.T + R)
+        curr_k = A @ curr_sigma @ G.T @ mat_inv
+        new_sigma = (A @ curr_sigma@ A.T -
+                    curr_k @ G @ curr_sigma @ A.T  + Q)
 
-        new_xhat = A.dot(curr_x) + curr_k.dot(y_observed - G.dot(curr_x))
+        new_xhat = A @ curr_x + curr_k @ (y_observed - G @ curr_x)
 
         assert_allclose(kf.Sigma, new_sigma, rtol=1e-4, atol=1e-2)
         assert_allclose(kf.x_hat, new_xhat, rtol=1e-4, atol=1e-2)

quantecon/tests/test_lqcontrol.py

@@ -4,7 +4,6 @@
 """
 import numpy as np
 from numpy.testing import assert_allclose, assert_raises
-from numpy import dot
 from quantecon import LQ, LQMarkov
 
 
@@ -49,7 +48,7 @@ def test_scalar_sequences(self):
             (2*lq_scalar.Q+lq_scalar.beta*lq_scalar.Rf*2*lq_scalar.B**2) \
             * x0
         x_1 = lq_scalar.A * x0 + lq_scalar.B * u_0 + \
-            dot(lq_scalar.C, w_seq[0, -1])
+            np.dot(lq_scalar.C, w_seq[0, -1])
 
         assert_allclose(u_0, u_seq, rtol=1e-4)
         assert_allclose(x_1, x_seq[0, -1], rtol=1e-4)
@@ -83,7 +82,7 @@ def test_stationary_mat(self):
 
         for method in self.methods:
             P, F, d = lq_mat.stationary_values(method=method)
-            val_func_lq = np.dot(x0, P).dot(x0)
+            val_func_lq = x0 @ P @ x0
 
             assert_allclose(f_answer, F, atol=1e-3)
             assert_allclose(val_func_lq, val_func_answer, atol=1e-3)

quantecon/tests/test_lqnash.py

@@ -86,11 +86,11 @@ def test_nnash(self):
         f1, f2, p1, p2 = nnash(a, b1, b2, r1, r2, q1, q2, s1, s2, w1, w2, m1,
                                m2)
 
-        aaa = a - b1.dot(f1) - b2.dot(f2)
+        aaa = a - b1 @ f1 - b2 @ f2
         aa = aaa[:2, :2]
         tf = np.eye(2)-aa
         tfi = np.linalg.inv(tf)
-        xbar = tfi.dot(aaa[:2, 2])
+        xbar = tfi @ aaa[:2, 2]
 
         # Define answers from matlab. TODO: this is ghetto
         f1_ml = np.array([

quantecon/tests/test_matrix_eqn.py

@@ -34,5 +34,5 @@ def test_solve_discrete_lyapunov_complex():
 
     X = qme.solve_discrete_lyapunov(A, B)
 
-    assert_allclose(np.dot(np.dot(A, X), A.conj().transpose()) - X, -B,
+    assert_allclose( A @ X @ A.conj().transpose() - X, -B,
                     atol=1e-15)

quantecon/tests/test_ricatti.py

@@ -62,7 +62,7 @@ def dare_tjm_3(method):
     B = I
     R = [[1, r],
          [r, r*r]]
-    Q = I - np.dot(A.T, A) + np.dot(A.T, np.linalg.solve(R + I, A))
+    Q = I - A.T @ A + A.T @ np.linalg.solve(R + I, A)
     X = solve_discrete_riccati(A, B, Q, R, method=method)
     Y = np.identity(2)
     assert_allclose(X, Y, atol=1e-07)