Revert test files to original state - separate library changes from test updates

Per feedback, this keeps only the library code changes with @ operator migrations
and reverts all test files to their original state. All 536 tests pass with the
library changes, confirming compatibility. Test file updates can be done in a
separate PR later.

Co-authored-by: mmcky <[email protected]>

Author: Copilot

quantecon/markov/tests/test_core.py

@@ -225,12 +225,12 @@ def test_left_eigen_vec(self):
         stationary_distributions = self.stationary
 
         if self.n_stat_dists == 1:
-            assert_allclose(stationary_distributions @ mc.P,
+            assert_allclose(np.dot(stationary_distributions, mc.P),
                             stationary_distributions, atol=self.TOL)
         else:
             for i in range(self.n_stat_dists):
                 curr_v = stationary_distributions[i, :]
-                assert_allclose(curr_v @ mc.P, curr_v, atol=self.TOL)
+                assert_allclose(np.dot(curr_v, mc.P), curr_v, atol=self.TOL)
 
 
 def test_simulate_shape():

quantecon/markov/tests/test_gth_solve.py

@@ -108,7 +108,7 @@ def __call__(self, x):
 
 class StationaryDistLeftEigenVec(AddDescription):
     def __call__(self, A, x):
-        assert_allclose(x @ A, x, atol=TOL)
+        assert_allclose(np.dot(x, A), x, atol=TOL)
 
 
 class StationaryDistEqualToKnown(AddDescription):

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 = self.C @ self.C.T
-        self.R = self.H @ self.H.T
+        self.Q = np.dot(self.C, self.C.T)
+        self.R = np.dot(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 @ sig_inf @ G.T + R)
+            mat_inv = np.linalg.inv(G.dot(sig_inf).dot(G.T) + R)
 
             # Compute the kalmain gain and sigma infinity according to the
             # recursive equations and compare
-            kal_recursion = (A @ sig_inf) @ G.T @ mat_inv
-            sig_recursion = (A @ sig_inf @ A.T -
-                                kal_recursion @ G @ sig_inf @ A.T + Q)
+            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)
 
             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 @ 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)
+        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)
 
-        new_xhat = A @ curr_x + curr_k @ (y_observed - G @ curr_x)
+        new_xhat = A.dot(curr_x) + curr_k.dot(y_observed - G.dot(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

@@ -83,7 +83,7 @@ def test_stationary_mat(self):
 
         for method in self.methods:
             P, F, d = lq_mat.stationary_values(method=method)
-            val_func_lq = x0 @ P @ x0
+            val_func_lq = np.dot(x0, P).dot(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 @ f1 - b2 @ f2
+        aaa = a - b1.dot(f1) - b2.dot(f2)
         aa = aaa[:2, :2]
         tf = np.eye(2)-aa
         tfi = np.linalg.inv(tf)
-        xbar = tfi @ aaa[:2, 2]
+        xbar = tfi.dot(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((A @ X @ A.conj().transpose()) - X, -B,
+    assert_allclose(np.dot(np.dot(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 - (A.T @ A) + (A.T @ np.linalg.solve(R + I, A))
+    Q = I - np.dot(A.T, A) + np.dot(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)