quantecon 0.11.2__tar.gz → 0.11.4__tar.gz

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

@@ -2,6 +2,14 @@
 
 Future CHANGELOG entries will be documented under the [release notes on GitHub](https://github.com/QuantEcon/QuantEcon.py/releases)
 
+## Ver 0.11.4 (14th-July-2026)
+
+See [release notes](https://github.com/QuantEcon/QuantEcon.py/releases/tag/v0.11.4)
+
+## 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.4/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.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantecon
-Version: 0.11.2
+Version: 0.11.4
 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.4}/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.4}/quantecon/__init__.py

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

{quantecon-0.11.2 → quantecon-0.11.4}/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.4}/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.4}/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.4}/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.4}/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.4}/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.4}/quantecon/markov/core.py

@@ -223,7 +223,7 @@ class MarkovChain:
             return msg.format(self.P, self._stationary_dists)
 
     def __str__(self):
-        return str(self.__repr__)
+        return self.__repr__()
 
     @property
     def state_values(self):
@@ -463,7 +463,9 @@ class MarkovChain:
 
         init : int or array_like(int, ndim=1), optional
             Initial state(s). If None, the initial state is randomly
-            drawn.
+            drawn. Negative values count from the end, as with Python
+            indexing; the returned paths contain the equivalent
+            nonnegative indices.
 
         num_reps : scalar(int), optional(default=None)
             Number of repetitions of simulation.
@@ -516,6 +518,13 @@ class MarkovChain:
                     'init must be int, array_like of ints, or None'
                 )
 
+        # Map negative indices into {0, ..., n-1}: the sparse kernel does
+        # not support wraparound indexing, and, intentionally, the
+        # returned paths then contain nonnegative indices only (a path
+        # with init=-k starts with n-k, not -k)
+        init_states = np.where(init_states < 0, init_states + self.n,
+                               init_states)
+
         # === set up array to store output === #
         X = np.empty((k, ts_length), dtype=int)
 
@@ -614,11 +623,20 @@ def _generate_sample_paths(P_cdfs, init_states, random_values, out):
 
     """
     num_reps, ts_length = out.shape
+    n = P_cdfs.shape[0]
 
     for i in range(num_reps):
         out[i, 0] = init_states[i]
         for t in range(ts_length-1):
-            out[i, t+1] = np.searchsorted(P_cdfs[out[i, t]], random_values[i, t], side='right')
+            k = np.searchsorted(P_cdfs[out[i, t]], random_values[i, t],
+                                side='right')
+            if k == n:
+                # random value beyond the last CDF value due to rounding:
+                # fall back to the last state with positive probability,
+                # i.e., the first position attaining the final CDF value
+                k = np.searchsorted(P_cdfs[out[i, t]],
+                                    P_cdfs[out[i, t], n-1], side='left')
+            out[i, t+1] = k
 
 
 @jit(nopython=True)
@@ -662,9 +680,17 @@ def _generate_sample_paths_sparse(P_cdfs1d, indices, indptr, init_states,
     for i in range(num_reps):
         out[i, 0] = init_states[i]
         for t in range(ts_length-1):
-            k = np.searchsorted(P_cdfs1d[indptr[out[i, t]]:indptr[out[i, t]+1]],
-                                random_values[i, t], side='right')
-            out[i, t+1] = indices[indptr[out[i, t]]+k]
+            lo, hi = indptr[out[i, t]], indptr[out[i, t]+1]
+            k = np.searchsorted(P_cdfs1d[lo:hi], random_values[i, t],
+                                side='right')
+            if k == hi - lo:
+                # random value beyond the last CDF value due to rounding:
+                # fall back to the last state with positive probability
+                # (explicitly stored zeros do not increase the CDF), i.e.,
+                # the first position attaining the final CDF value
+                k = np.searchsorted(P_cdfs1d[lo:hi], P_cdfs1d[hi-1],
+                                    side='left')
+            out[i, t+1] = indices[lo+k]
 
 
 def mc_compute_stationary(P):
@@ -713,14 +739,26 @@ def mc_sample_path(P, init=0, sample_size=1000, random_state=None):
 
     """
     random_state = check_random_state(random_state)
+    mc = MarkovChain(P)
 
     if isinstance(init, numbers.Integral):
         X_0 = init
     else:
+        init = np.asarray(init)
+        if init.ndim != 1 or init.shape[0] != mc.n:
+            raise ValueError('init must be an int or a 1-dim array of '
+                             'length n')
+        if (init < 0).any() or not np.allclose(init.sum(), 1):
+            raise ValueError('init must be a probability distribution '
+                             '(nonnegative, summing to 1)')
         cdf0 = np.cumsum(init)
         u_0 = random_state.random()
         X_0 = np.searchsorted(cdf0, u_0, side='right')
+        if X_0 == mc.n:
+            # u_0 beyond the last CDF value due to rounding: fall back to
+            # the last state with positive probability, as in
+            # _generate_sample_paths
+            X_0 = np.searchsorted(cdf0, cdf0[-1], side='left')
 
-    mc = MarkovChain(P)
     return mc.simulate(ts_length=sample_size, init=X_0,
                        random_state=random_state)