DLE.compute_sequence fails under NumPy 2.4 (setting an array element with a sequence)

[mmcky]

Summary

quantecon.DLE.compute_sequence raises under NumPy 2.4 when it computes the asset-price terms R1_Price, R2_Price, R5_Price. The same code runs fine under NumPy 2.3.x, so this is a regression triggered by NumPy tightening size-1-array → scalar conversion on assignment.

Environment

• quantecon latest (installed via pip install --upgrade quantecon)
• numpy==2.4.6 (ships with anaconda=2026.06) — fails
• numpy==2.3.5 (ships with anaconda=2025.12) — works
• Python 3.13

Traceback

ValueError                                Traceback (most recent call last)
----> 1 econ1.compute_sequence(x0, ts_length=100)

File .../site-packages/quantecon/_dle.py:215, in DLE.compute_sequence(self, x0, ts_length, Pay)
    213     self.R5_Price = np.empty((ts_length + 1, 1))
    214     for i in range(ts_length + 1):
--> 215         self.R1_Price[i, 0] = self.beta * e1 @ self.Mc @ np.linalg.matrix_power(
    216             self.A0, 1) @ xp[:, i] / (e1 @ self.Mc @ xp[:, i])

TypeError: only 0-dimensional arrays can be converted to Python scalars
The above exception was the direct cause of the following exception:
ValueError: setting an array element with a sequence.

Root cause

In compute_sequence, the selector e1 is a 2-D row vector:

e1 = np.zeros((1, self.nc))
e1[0, 0] = 1

so each price expression e1 @ self.Mc @ ... @ xp[:, i] / (e1 @ self.Mc @ xp[:, i]) evaluates to a size-1 array (shape (1,)), not a Python scalar. Assigning that into the scalar slot self.R1_Price[i, 0] used to work because NumPy silently converted a size-1 array to a scalar, but NumPy 2.4 now raises (only 0-dimensional arrays can be converted to Python scalars → setting an array element with a sequence).

Suggested fix

Coerce each price term to a scalar with .item() (works regardless of e1's shape):

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])).item()
    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])).item()
    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])).item()

Alternatively, define e1 as 1-D (e1 = np.zeros(self.nc); e1[0] = 1) so the matmul chain reduces to a 0-d scalar.

Downstream impact

This breaks 5 lectures in lecture-python-advanced.myst under anaconda=2026.06 (numpy 2.4.6): cattle_cycles, growth_in_dles, irfs_in_hall_model, lucas_asset_pricing_dles, permanent_income_dles. See the validation in QuantEcon/lecture-python-advanced.myst#346. It affects any DLE whose dimensions make the price expression size-1 (lectures that don't reach the price path, e.g. gorman_heterogeneous_households, hs_invertibility_example, rosen_schooling_model, are unaffected).

[oyamad]

@mmcky Do you have a MWE that raises that error?

[mmcky]

Validated minimal reproduction

Self-contained MWE (Hall's permanent-income economy, the most compact of the affected setups). It reproduces the exact traceback under NumPy 2.4 and runs cleanly under NumPy 2.3, isolating the regression boundary.

import numpy as np
import quantecon
from quantecon import DLE

print("numpy:", np.__version__, "| quantecon:", quantecon.__version__)

γ_1 = 0.1
γ   = np.array([[γ_1], [0]])
ϕ_c = np.array([[1], [0]])
ϕ_g = np.array([[0], [1]])
ϕ_1 = 1e-5
ϕ_i = np.array([[1], [-ϕ_1]])
δ_k = np.array([[.95]])
θ_k = np.array([[1]])
β   = np.array([[1 / 1.05]])
l_λ = np.array([[0]])
π_h = np.array([[1]])
δ_h = np.array([[.9]])
θ_h = np.array([[1]])
a22 = np.array([[1, 0, 0], [0, 0.8, 0], [0, 0, 0.5]])
c2  = np.array([[0, 0], [1, 0], [0, 1]])
ud  = np.array([[5, 1, 0], [0, 0, 0]])
ub  = np.array([[30, 0, 0]])
x0  = np.array([[5], [150], [1], [0], [0]])

info1 = (a22, c2, ub, ud)
tech1 = (ϕ_c, ϕ_g, ϕ_i, γ, δ_k, θ_k)
pref1 = (β, l_λ, π_h, δ_h, θ_h)

econ1 = DLE(info1, tech1, pref1)
econ1.compute_sequence(x0, ts_length=300)
print("OK:", econ1.R1_Price[:3].ravel())

Results (quantecon 0.11.2 in every case)

numpy	result
2.3.5	✅ runs — R1_Price[:3] = [0.95238095, 0.95238095, 0.95238095]
2.4.6	❌ raises (traceback below)
2.4.6 with the .item() fix	✅ runs — identical R1_Price[:3] = [0.95238095, 0.95238095, 0.95238095]

So the regression boundary is numpy 2.3 → 2.4, and the suggested .item() patch both fixes the error and reproduces the original values exactly (here R1_Price = β = 1/1.05 = 0.95238…, the one-period risk-free price).

Traceback under numpy 2.4.6

Traceback (most recent call last):
  File "dle_mwe.py", line 30, in <module>
    econ1.compute_sequence(x0, ts_length=300)
    ~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^
  File ".../site-packages/quantecon/_dle.py", line 215, in compute_sequence
    self.R1_Price[i, 0] = self.beta * e1 @ self.Mc @ np.linalg.matrix_power(
    ~~~~~~~~~~~~~^^^^^^
ValueError: setting an array element with a sequence.

(The underlying cause is TypeError: only 0-dimensional arrays can be converted to Python scalars — the price expression is a size-1 array, and NumPy 2.4 no longer implicitly converts it to a scalar on assignment, as described above.)

[mmcky]

Confirmed — this lines up with the NumPy 2.4.0 release notes. Under Expired deprecations they note: "Conversion of an array with ndim > 0 to a scalar was deprecated in NumPy 1.25. Now, attempting to do so raises TypeError. Ensure you extract a single element from your array before performing this operation." (https://numpy.org/doc/2.4/release/2.4.0-notes.html) That matches the diagnosis here exactly: it's an expired deprecation that became a hard error in 2.4, which is why 2.3.x works and 2.4.x doesn't.

The trigger in _dle.py is that e1 is a 2-D row vector (e1 = np.zeros((1, self.nc)); e1[0, 0] = 1), so e1 @ self.Mc @ ... @ xp[:, i] reduces to a size-1 1-D array of shape (1,) rather than a 0-d scalar. Assigning that into the scalar slot self.R1_Price[i, 0] (and R2_Price, R5_Price) requires an ndim > 0 → scalar conversion, which NumPy ≤ 2.3 did implicitly and 2.4 now rejects.

One small thing to tidy up in the report: the issue lists the error as ValueError: setting an array element with a sequence., but the root-cause text quotes only 0-dimensional arrays can be converted to Python scalars, which is the TypeError from the release note above. Those are two different exceptions. Could you paste the full traceback so we capture the one NumPy 2.4 actually raises here?

On the fix, I'd lean toward redefining e1 as 1-D rather than sprinkling .item() calls at each assignment:

e1 = np.zeros(self.nc)
e1[0] = 1

Then (nc,) @ (nc, nc) @ (nc,) reduces to a 0-d scalar and the price assignments are clean, with no fragile size-1 intermediary. It addresses the root cause rather than the symptom and is backward-compatible across NumPy versions.