quantecon 0.11.2__tar.gz → 0.11.3__tar.gz

{quantecon-0.11.2 → quantecon-0.11.3}/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 Future CHANGELOG entries will be documented under the [release notes on GitHub](https://github.com/QuantEcon/QuantEcon.py/releases)
 
+## Ver 0.11.3 (8th-July-2026)
+
+See [release notes](https://github.com/QuantEcon/QuantEcon.py/releases/tag/v0.11.3)
+
 ## Ver 0.11.2 (6th-April-2026)
 
 See [release notes](https://github.com/QuantEcon/QuantEcon.py/releases/tag/v0.11.2)

quantecon-0.11.3/CONTRIBUTING.md

@@ -0,0 +1,11 @@
+# Contributing to QuantEcon.py
+
+Thanks for your interest in contributing to QuantEcon.py.
+
+The contribution guide is maintained in the project documentation:
+
+- [Rendered guide on Read the Docs](https://quanteconpy.readthedocs.io/en/latest/contributing.html)
+- [Source file in this repository](docs/source/contributing.rst)
+
+The guide covers where to start, how to set up a development environment,
+and expectations for tests and documentation.

{quantecon-0.11.2 → quantecon-0.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantecon
-Version: 0.11.2
+Version: 0.11.3
 Summary: Import the main names to top level.
 Keywords: quantitative,economics
 Author-email: QuantEcon Project <admin@quantecon.org>

{quantecon-0.11.2 → quantecon-0.11.3}/environment_np2.yml

@@ -10,7 +10,7 @@ dependencies:
   - numpy>=2
   - scipy
   - pandas
-  - numba>=0.64
+  - numba=0.66.0rc1
   - sympy
   - ipython
   - flake8

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/__init__.py

@@ -3,7 +3,7 @@
 Import the main names to top level.
 """
 
-__version__ = '0.11.2'
+__version__ = '0.11.3'
 
 try:
     import numba

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/_compute_fp.py

@@ -357,7 +357,7 @@ def _square_sum(a):  # pragma: no cover
     pass
 
 
-@overload(_square_sum, jit_options={'cache':True})
+@overload(_square_sum, jit_options={'cache': True})
 def _square_sum_ol(a):
     if isinstance(a, types.Number):
         return lambda a: a**2

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/_dle.py

@@ -211,13 +211,26 @@ class DLE(object):
         self.R1_Price = np.empty((ts_length + 1, 1))
         self.R2_Price = np.empty((ts_length + 1, 1))
         self.R5_Price = np.empty((ts_length + 1, 1))
+        # Hoist the loop-invariant terms out of the loop: ``e1 @ self.Mc`` and
+        # the matrix powers of ``self.A0`` do not depend on ``i``.
+        eMc = e1 @ self.Mc
+        A0_1 = np.linalg.matrix_power(self.A0, 1)
+        A0_2 = np.linalg.matrix_power(self.A0, 2)
+        A0_5 = np.linalg.matrix_power(self.A0, 5)
+        # Each price expression evaluates to a size-1 array (``self.beta`` is a
+        # (1, 1) array and ``eMc`` is a row vector). Coerce the size-1 result to
+        # a scalar with ``.item()`` *after* dividing, so assignment works under
+        # NumPy >= 2.4 (which raises instead of silently converting an
+        # ``ndim > 0`` array to a scalar on assignment). Keeping the division
+        # inside NumPy preserves the pre-2.4 behaviour when ``denom == 0`` (an
+        # ``inf``/``nan`` with a warning, rather than a ``ZeroDivisionError``).
+        # See #839.
         for i in range(ts_length + 1):
-            self.R1_Price[i, 0] = self.beta * e1 @ self.Mc @ np.linalg.matrix_power(
-                self.A0, 1) @ xp[:, i] / (e1 @ self.Mc @ xp[:, i])
-            self.R2_Price[i, 0] = self.beta**2 * (e1 @ self.Mc @
-                np.linalg.matrix_power(self.A0, 2) @ xp[:, i]) / (e1 @ self.Mc @ xp[:, i])
-            self.R5_Price[i, 0] = self.beta**5 * (e1 @ self.Mc @
-                np.linalg.matrix_power(self.A0, 5) @ xp[:, i]) / (e1 @ self.Mc @ xp[:, i])
+            xi = xp[:, i]
+            denom = eMc @ xi
+            self.R1_Price[i, 0] = (self.beta * eMc @ A0_1 @ xi / denom).item()
+            self.R2_Price[i, 0] = (self.beta**2 * (eMc @ A0_2 @ xi) / denom).item()
+            self.R5_Price[i, 0] = (self.beta**5 * (eMc @ A0_5 @ xi) / denom).item()
 
         # === Gross rates of return on 1-period risk-free bonds === #
         self.R1_Gross = 1 / self.R1_Price
@@ -239,12 +252,14 @@ class DLE(object):
             self.Pay_Price = np.empty((ts_length + 1, 1))
             self.Pay_Gross = np.empty((ts_length + 1, 1))
             self.Pay_Gross[0, 0] = np.nan
+            # As above, coerce each size-1 result to a scalar with ``.item()``
+            # so assignment works under NumPy >= 2.4. See #839.
             for i in range(ts_length + 1):
-                self.Pay_Price[i, 0] = (xp[:, i].T @ self.Q @
-                    xp[:, i] + self.q) / (e1 @ self.Mc @ xp[:, i])
+                self.Pay_Price[i, 0] = ((xp[:, i].T @ self.Q @
+                    xp[:, i] + self.q) / (e1 @ self.Mc @ xp[:, i])).item()
             for i in range(ts_length):
-                self.Pay_Gross[i + 1, 0] = self.Pay_Price[i + 1,
-                                                          0] / (self.Pay_Price[i, 0] - Pay @ xp[:, i])
+                self.Pay_Gross[i + 1, 0] = (self.Pay_Price[i + 1,
+                    0] / (self.Pay_Price[i, 0] - Pay @ xp[:, i])).item()
         return
 
     def irf(self, ts_length=100, shock=None):

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/_gridtools.py

@@ -254,7 +254,7 @@ def _cartesian_index(indices, nums_grids):
     n = len(indices)
     idx = 0
     de_cumprod = 1
-    for i in range(1,n+1):
+    for i in range(1, n+1):
         idx += de_cumprod * indices[n-i]
         de_cumprod *= nums_grids[n-i]
     return idx

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/game_theory/repeated_game.py

@@ -60,7 +60,9 @@ class RepeatedGame:
                 max_iter : scalar(int)
                     Maximum number of iterations.
                 u_init : ndarray(float, ndim=1)
-                    The initial guess of threat points.
+                    The initial guess of threat points. By default, the
+                    minimum payoff of each player is used. A supplied
+                    guess is clipped from below by the minimum payoffs.
         
         Returns
         -------
@@ -88,7 +90,7 @@ class RepeatedGame:
 
 
 def _equilibrium_payoffs_abreu_sannikov(rpg, tol=1e-12, max_iter=500,
-                                        u_init=np.zeros(2)):
+                                        u_init=None):
     """
     Using 'abreu_sannikov' algorithm to compute the set of payoff pairs
     of all pure-strategy subgame-perfect equilibria with public randomization
@@ -106,8 +108,11 @@ def _equilibrium_payoffs_abreu_sannikov(rpg, tol=1e-12, max_iter=500,
     max_iter : scalar(int), optional(default=500)
         Maximum number of iterations.
 
-    u_init : ndarray(float, ndim=1), optional(default=np.zeros(2))
-        The initial guess of threat points.
+    u_init : ndarray(float, ndim=1), optional
+        The initial guess of threat points. It must not exceed the
+        threat points of the equilibrium payoff set. By default, the
+        minimum payoff of each player is used. A supplied guess is
+        clipped from below by the minimum payoffs.
 
     Returns
     -------
@@ -142,8 +147,14 @@ def _equilibrium_payoffs_abreu_sannikov(rpg, tol=1e-12, max_iter=500,
     # count the new points generated in each iteration
     n_new_pt = 0
 
-    # copy the threat points
-    u = np.copy(u_init)
+    # initial threat points: the minimum payoffs by default; a supplied
+    # guess is clipped from below by the minimum payoffs
+    payoff_mins = np.array([sg.payoff_arrays[0].min(),
+                            sg.payoff_arrays[1].min()], dtype=float)
+    if u_init is None:
+        u = payoff_mins
+    else:
+        u = np.maximum(np.asarray(u_init, dtype=float), payoff_mins)
 
     # initialization
     payoff_pts = \
@@ -163,18 +174,29 @@ def _equilibrium_payoffs_abreu_sannikov(rpg, tol=1e-12, max_iter=500,
                hull.equations, u, IC, action_profile_payoff,
                extended_payoff, new_pts, W_new)
 
+        if n_new_pt == 0:
+            msg = ("no incentive-compatible payoff vector found; the game "
+                   "may have no pure-action subgame perfect equilibrium "
+                   "for this value of delta")
+            raise ValueError(msg)
+
         n_iter += 1
         if n_iter >= max_iter:
             break
 
-        # check convergence
-        if n_new_pt == n_old_pt:
+        # update threat points; done before the convergence check, since
+        # the set has not converged while the threat points are moving
+        u_old = np.copy(u)
+        _update_u(u, W_new[:n_new_pt])
+
+        # check convergence; u is updated only by assignment from payoff
+        # values in _update_u, so exact comparison is appropriate, and
+        # stopping while u is still moving by sub-tol amounts can leave
+        # near-duplicate vertices in the hull
+        if n_new_pt == n_old_pt and np.array_equal(u, u_old):
             if np.linalg.norm(W_new[:n_new_pt] - W_old[:n_new_pt]) < tol:
                 break
 
-        # update threat points
-        _update_u(u, W_new[:n_new_pt])
-
     hull = ConvexHull(W_new[:n_new_pt])
 
     return hull

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/game_theory/tests/test_repeated_game.py

@@ -3,6 +3,7 @@ Tests for repeated_game.py
 
 """
 import numpy as np
+import pytest
 from numpy.testing import assert_allclose
 from quantecon.game_theory import NormalFormGame, RepeatedGame
 
@@ -47,3 +48,25 @@ class TestAS():
                 hull = rpg.equilibrium_payoffs(method=method,
                                                options={'u_init': d['u']})
                 assert_allclose(hull.points[hull.vertices], d['vertices'])
+
+    def test_abreu_sannikov_default_u_init(self):
+        for d in self.game_dicts:
+            rpg = RepeatedGame(d['sg'], d['delta'])
+            hull = rpg.equilibrium_payoffs()
+            assert_allclose(hull.points[hull.vertices], d['vertices'])
+
+    def test_abreu_sannikov_low_u_init(self):
+        # A u_init below the threat points must not stop the iteration
+        # before the first threat point update
+        for d in self.game_dicts:
+            rpg = RepeatedGame(d['sg'], d['delta'])
+            hull = rpg.equilibrium_payoffs(options={'u_init': np.zeros(2)})
+            assert_allclose(hull.points[hull.vertices], d['vertices'])
+
+    def test_abreu_sannikov_no_pure_action_spe(self):
+        # Game with no pure-action subgame perfect equilibrium at low delta
+        bimatrix = [[(1, -1), (-1, 2)],
+                    [(-2, 2), (1, 0)]]
+        rpg = RepeatedGame(NormalFormGame(bimatrix), 0.05)
+        with pytest.raises(ValueError):
+            rpg.equilibrium_payoffs()

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/game_theory/vertex_enumeration.py

@@ -136,18 +136,22 @@ def _vertex_enumeration_gen(labelings_bits_tup, equations_tup, trans_recips):
     m, n = equations_tup[0].shape[1] - 1, equations_tup[1].shape[1] - 1
     num_vertices0, num_vertices1 = \
         equations_tup[0].shape[0], equations_tup[1].shape[0]
-    ZERO_LABELING0_BITS = (np.uint64(1) << np.uint64(m)) - np.uint64(1)
     COMPLETE_LABELING_BITS = (np.uint64(1) << np.uint64(m+n)) - np.uint64(1)
+    ZERO_LABELING1_BITS = \
+        ((np.uint64(1) << np.uint64(n)) - np.uint64(1)) << np.uint64(m)
 
     labelings_bits_dict1 = Dict.empty(key_type=types.uint64,
                                       value_type=types.intp)
     for j in range(num_vertices1):
         labelings_bits_dict1[labelings_bits_tup[1][j]] = j
 
+    try:
+        del labelings_bits_dict1[ZERO_LABELING1_BITS]
+    except Exception:
+        pass
+
     for i in range(num_vertices0):
         bits0 = labelings_bits_tup[0][i]
-        if bits0 == ZERO_LABELING0_BITS:
-            continue
         complement0 = bits0 ^ COMPLETE_LABELING_BITS
         try:
             j = labelings_bits_dict1[complement0]

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/markov/tests/test_approximation.py

@@ -179,9 +179,9 @@ class TestDiscreteVar:
             [0.00000000e+00, 4.70588235e-01, 3.08823529e-01, 0.00000000e+00, 
             1.76470588e-01, 4.41176471e-02]]
 
-        self.A, self.C, self.S_out, self.P_out, self.S_out_orderF,\
+        self.A, self.C, self.S_out, self.P_out, self.S_out_orderF, \
         self.P_out_orderF, self.P_out_non_square \
-            = map(np.array,(self.A, self.C, self.S_out, self.P_out, 
+            = map(np.array, (self.A, self.C, self.S_out, self.P_out,
                                 self.S_out_orderF, self.P_out_orderF, 
                                 self.P_out_non_square))
 

{quantecon-0.11.2 → quantecon-0.11.3}/quantecon/util/numba.py

@@ -21,7 +21,7 @@ def _numba_linalg_solve(a, b):  # pragma: no cover
     pass
 
 
-@overload(_numba_linalg_solve, jit_options={'cache':True})
+@overload(_numba_linalg_solve, jit_options={'cache': True})
 def _numba_linalg_solve_ol(a, b):
     """
     Solve the linear equation ax = b directly calling a Numba internal