From 9ec9e13edbb94df61701e54087fed2554e1ea7f5 Mon Sep 17 00:00:00 2001
From: Matt McKay <mmcky@users.noreply.github.com>
Date: Mon, 18 Nov 2024 16:47:28 +1100
Subject: [PATCH] MAINT: update @jit(nopython=True) to @jit with numba>=0.59
 (#395)

* MAINT: update @jit(nopython=True) to @jit with numba>=0.59

* update @njit to @jit

* update imports njit to jit and usage

* minor fixes for import

* remove njit from cass_koopmans_1

* remove njit from ak2
---
 lectures/aiyagari.md                     |  6 ++---
 lectures/ak2.md                          | 14 ++++++------
 lectures/career.md                       | 10 ++++-----
 lectures/cass_koopmans_1.md              | 20 ++++++++---------
 lectures/cass_koopmans_2.md              | 16 +++++++-------
 lectures/coleman_policy_iter.md          |  6 ++---
 lectures/egm_policy_iter.md              |  4 ++--
 lectures/eig_circulant.md                |  6 ++---
 lectures/exchangeable.md                 | 18 +++++++--------
 lectures/ifp.md                          |  6 ++---
 lectures/ifp_advanced.md                 |  6 ++---
 lectures/imp_sample.md                   | 12 +++++-----
 lectures/inventory_dynamics.md           |  6 ++---
 lectures/jv.md                           | 10 ++++-----
 lectures/kesten_processes.md             |  4 ++--
 lectures/likelihood_bayes.md             | 16 +++++++-------
 lectures/likelihood_ratio_process.md     | 12 +++++-----
 lectures/mccall_correlated.md            | 10 ++++-----
 lectures/mccall_fitted_vfi.md            |  8 +++----
 lectures/mccall_model.md                 | 10 ++++-----
 lectures/mccall_model_with_separation.md |  8 +++----
 lectures/mccall_q.md                     |  2 +-
 lectures/mix_model.md                    | 14 ++++++------
 lectures/multi_hyper.md                  |  4 ++--
 lectures/multivariate_normal.md          |  4 ++--
 lectures/navy_captain.md                 | 16 +++++++-------
 lectures/odu.md                          | 28 ++++++++++++------------
 lectures/optgrowth_fast.md               |  6 ++---
 lectures/perm_income.md                  |  6 ++---
 lectures/wald_friedman.md                |  6 ++---
 lectures/wealth_dynamics.md              |  6 ++---
 31 files changed, 150 insertions(+), 150 deletions(-)

diff --git a/lectures/aiyagari.md b/lectures/aiyagari.md
index 362e922c7..b465f1947 100644
--- a/lectures/aiyagari.md
+++ b/lectures/aiyagari.md
@@ -283,7 +283,7 @@ class Household:
 
 # Do the hard work using JIT-ed functions
 
-@jit(nopython=True)
+@jit
 def populate_R(R, a_size, z_size, a_vals, z_vals, r, w):
     n = a_size * z_size
     for s_i in range(n):
@@ -297,7 +297,7 @@ def populate_R(R, a_size, z_size, a_vals, z_vals, r, w):
             if c > 0:
                 R[s_i, new_a_i] = np.log(c)  # Utility
 
-@jit(nopython=True)
+@jit
 def populate_Q(Q, a_size, z_size, Π):
     n = a_size * z_size
     for s_i in range(n):
@@ -307,7 +307,7 @@ def populate_Q(Q, a_size, z_size, Π):
                 Q[s_i, a_i, a_i*z_size + next_z_i] = Π[z_i, next_z_i]
 
 
-@jit(nopython=True)
+@jit
 def asset_marginal(s_probs, a_size, z_size):
     a_probs = np.zeros(a_size)
     for a_i in range(a_size):
diff --git a/lectures/ak2.md b/lectures/ak2.md
index 67726502c..91a737c1b 100644
--- a/lectures/ak2.md
+++ b/lectures/ak2.md
@@ -408,7 +408,7 @@ $$
 ```{code-cell} ipython3
 import numpy as np
 import matplotlib.pyplot as plt
-from numba import njit
+from numba import jit
 from quantecon.optimize import brent_max
 ```
 
@@ -433,22 +433,22 @@ Knowing $\hat K$, we can calculate other equilibrium objects.
 Let's first define  some Python helper functions.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def K_to_Y(K, α):
 
     return K ** α
 
-@njit
+@jit
 def K_to_r(K, α):
 
     return α * K ** (α - 1)
 
-@njit
+@jit
 def K_to_W(K, α):
 
     return (1 - α) * K ** α
 
-@njit
+@jit
 def K_to_C(K, D, τ, r, α, β):
 
     # optimal consumption for the old when δ=0
@@ -913,7 +913,7 @@ Let's implement this "guess and verify" approach
 We start by defining the Cobb-Douglas utility function
 
 ```{code-cell} ipython3
-@njit
+@jit
 def U(Cy, Co, β):
 
     return (Cy ** β) * (Co ** (1-β))
@@ -924,7 +924,7 @@ We use `Cy_val` to compute the lifetime value of an arbitrary consumption plan,
 Note that it requires knowing future prices $r_{t+1}$ and tax rate $\tau_{t+1}$.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def Cy_val(Cy, W, r_next, τ, τ_next, δy, δo_next, β):
 
     # Co given by the budget constraint
diff --git a/lectures/career.md b/lectures/career.md
index 19047c780..ab2e43a90 100644
--- a/lectures/career.md
+++ b/lectures/career.md
@@ -51,7 +51,7 @@ import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
 import quantecon as qe
-from numba import njit, prange
+from numba import jit, prange
 from quantecon.distributions import BetaBinomial
 from scipy.special import binom, beta
 from mpl_toolkits.mplot3d.axes3d import Axes3D
@@ -234,7 +234,7 @@ def operator_factory(cw, parallel_flag=True):
     F_probs, G_probs = cw.F_probs, cw.G_probs
     F_mean, G_mean = cw.F_mean, cw.G_mean
 
-    @njit(parallel=parallel_flag)
+    @jit(parallel=parallel_flag)
     def T(v):
         "The Bellman operator"
 
@@ -249,7 +249,7 @@ def operator_factory(cw, parallel_flag=True):
 
         return v_new
 
-    @njit
+    @jit
     def get_greedy(v):
         "Computes the v-greedy policy"
 
@@ -472,7 +472,7 @@ T, get_greedy = operator_factory(cw)
 v_star = solve_model(cw, verbose=False)
 greedy_star = get_greedy(v_star)
 
-@njit
+@jit
 def passage_time(optimal_policy, F, G):
     t = 0
     i = j = 0
@@ -485,7 +485,7 @@ def passage_time(optimal_policy, F, G):
             i, j  = qe.random.draw(F), qe.random.draw(G)
         t += 1
 
-@njit(parallel=True)
+@jit(parallel=True)
 def median_time(optimal_policy, F, G, M=25000):
     samples = np.empty(M)
     for i in prange(M):
diff --git a/lectures/cass_koopmans_1.md b/lectures/cass_koopmans_1.md
index 889dc8f8b..f29e25a7a 100644
--- a/lectures/cass_koopmans_1.md
+++ b/lectures/cass_koopmans_1.md
@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.16.1
+    jupytext_version: 1.16.4
 kernelspec:
   display_name: Python 3 (ipykernel)
   language: python
@@ -66,7 +66,7 @@ Let's start with some standard imports:
 
 ```{code-cell} ipython3
 import matplotlib.pyplot as plt
-from numba import njit, float64
+from numba import jit, float64
 from numba.experimental import jitclass
 import numpy as np
 from quantecon.optimize import brentq
@@ -525,7 +525,7 @@ planning problem.
 $c_0$ instead of $\mu_0$ in the following code.)
 
 ```{code-cell} ipython3
-@njit
+@jit
 def shooting(pp, c0, k0, T=10):
     '''
     Given the initial condition of capital k0 and an initial guess
@@ -610,7 +610,7 @@ When $K_{T+1}$ gets close enough to $0$ (i.e., within an error
 tolerance bounds), we stop.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def bisection(pp, c0, k0, T=10, tol=1e-4, max_iter=500, k_ter=0, verbose=True):
 
     # initial boundaries for guess c0
@@ -804,7 +804,7 @@ over time.
 Let's calculate and  plot the saving rate.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def saving_rate(pp, c_path, k_path):
     'Given paths of c and k, computes the path of saving rate.'
     production = pp.f(k_path[:-1])
@@ -912,7 +912,7 @@ $$ (eq:tildeC)
 A positive fixed point  $C = \tilde C(K)$ exists only if $f\left(K\right)+\left(1-\delta\right)K-f^{\prime-1}\left(\frac{1}{\beta}-\left(1-\delta\right)\right)>0$
 
 ```{code-cell} ipython3
-@njit
+@jit
 def C_tilde(K, pp):
 
     return pp.f(K) + (1 - pp.δ) * K - pp.f_prime_inv(1 / pp.β - 1 + pp.δ)
@@ -931,11 +931,11 @@ K = \tilde K(C)
 $$ (eq:tildeK)
 
 ```{code-cell} ipython3
-@njit
+@jit
 def K_diff(K, C, pp):
     return pp.f(K) - pp.δ * K - C
 
-@njit
+@jit
 def K_tilde(C, pp):
 
     res = brentq(K_diff, 1e-6, 100, args=(C, pp))
@@ -951,7 +951,7 @@ It is thus the intersection of the two curves $\tilde{C}$ and $\tilde{K}$ that w
 We can compute $K_s$ by solving the equation $K_s = \tilde{K}\left(\tilde{C}\left(K_s\right)\right)$
 
 ```{code-cell} ipython3
-@njit
+@jit
 def K_tilde_diff(K, pp):
 
     K_out = K_tilde(C_tilde(K, pp), pp)
@@ -1003,7 +1003,7 @@ In addition to the three curves, Figure {numref}`stable_manifold` plots  arrows
 ---
 mystnb:
   figure:
-    caption: "Stable Manifold and Phase Plane"
+    caption: Stable Manifold and Phase Plane
     name: stable_manifold
 tags: [hide-input]
 ---
diff --git a/lectures/cass_koopmans_2.md b/lectures/cass_koopmans_2.md
index 5c35f5ad5..2613cc312 100644
--- a/lectures/cass_koopmans_2.md
+++ b/lectures/cass_koopmans_2.md
@@ -68,7 +68,7 @@ Let's start with some standard imports:
 ```{code-cell} ipython
 import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
-from numba import njit, float64
+from numba import jit, float64
 from numba.experimental import jitclass
 import numpy as np
 ```
@@ -751,7 +751,7 @@ class PlanningProblem():
 ```
 
 ```{code-cell} python3
-@njit
+@jit
 def shooting(pp, c0, k0, T=10):
     '''
     Given the initial condition of capital k0 and an initial guess
@@ -779,7 +779,7 @@ def shooting(pp, c0, k0, T=10):
 ```
 
 ```{code-cell} python3
-@njit
+@jit
 def bisection(pp, c0, k0, T=10, tol=1e-4, max_iter=500, k_ter=0, verbose=True):
 
     # initial boundaries for guess c0
@@ -828,7 +828,7 @@ The above code from this lecture {doc}`Cass-Koopmans Planning Model <cass_koopma
 Now  we're ready to bring in Python code that we require to compute additional objects that appear in a competitive equilibrium.
 
 ```{code-cell} python3
-@njit
+@jit
 def q(pp, c_path):
     # Here we choose numeraire to be u'(c_0) -- this is q^(t_0)_t
     T = len(c_path) - 1
@@ -838,12 +838,12 @@ def q(pp, c_path):
         q_path[t] = pp.β ** t * pp.u_prime(c_path[t])
     return q_path
 
-@njit
+@jit
 def w(pp, k_path):
     w_path = pp.f(k_path) - k_path * pp.f_prime(k_path)
     return w_path
 
-@njit
+@jit
 def η(pp, k_path):
     η_path = pp.f_prime(k_path)
     return η_path
@@ -953,7 +953,7 @@ years, and define a new function for $r$, then plot both.
 We begin by continuing to assume that  $t_0=0$ and plot things for different maturities $t=T$, with $K_0$ below the steady state
 
 ```{code-cell} python3
-@njit
+@jit
 def q_generic(pp, t0, c_path):
     # simplify notations
     β = pp.β
@@ -966,7 +966,7 @@ def q_generic(pp, t0, c_path):
         q_path[t-t0] = β ** (t-t0) * u_prime(c_path[t]) / u_prime(c_path[t0])
     return q_path
 
-@njit
+@jit
 def r(pp, t0, q_path):
     '''Yield to maturity'''
     r_path = - np.log(q_path[1:]) / np.arange(1, len(q_path))
diff --git a/lectures/coleman_policy_iter.md b/lectures/coleman_policy_iter.md
index 1eade63c6..d24810d2f 100644
--- a/lectures/coleman_policy_iter.md
+++ b/lectures/coleman_policy_iter.md
@@ -63,7 +63,7 @@ Let's start with some imports:
 import matplotlib.pyplot as plt
 import numpy as np
 from quantecon.optimize import brentq
-from numba import njit
+from numba import jit
 ```
 
 ## The Euler Equation
@@ -286,7 +286,7 @@ u'(c) - \beta \int (u' \circ \sigma) (f(y - c) z ) f'(y - c) z \phi(dz)
 ```
 
 ```{code-cell} ipython
-@njit
+@jit
 def euler_diff(c, σ, y, og):
     """
     Set up a function such that the root with respect to c,
@@ -314,7 +314,7 @@ state $y$ and $σ$, the current guess of the policy.
 Here's the operator $K$, that implements the root-finding step.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def K(σ, og):
     """
     The Coleman-Reffett operator
diff --git a/lectures/egm_policy_iter.md b/lectures/egm_policy_iter.md
index 6350499a1..32522aadb 100644
--- a/lectures/egm_policy_iter.md
+++ b/lectures/egm_policy_iter.md
@@ -44,7 +44,7 @@ Let's start with some standard imports:
 ```{code-cell} ipython
 import matplotlib.pyplot as plt
 import numpy as np
-from numba import njit
+from numba import jit
 ```
 
 ## Key Idea
@@ -161,7 +161,7 @@ We reuse the `OptimalGrowthModel` class
 Here's an implementation of $K$ using EGM as described above.
 
 ```{code-cell} python3
-@njit
+@jit
 def K(σ_array, og):
     """
     The Coleman-Reffett operator using EGM
diff --git a/lectures/eig_circulant.md b/lectures/eig_circulant.md
index bac735ced..270aa6046 100644
--- a/lectures/eig_circulant.md
+++ b/lectures/eig_circulant.md
@@ -31,7 +31,7 @@ We begin by importing some Python packages
 
 ```{code-cell} ipython3
 import numpy as np
-from numba import njit
+from numba import jit
 import matplotlib.pyplot as plt
 ```
 
@@ -66,7 +66,7 @@ first column needs to be specified.
 Let's write some Python code to generate a circulant matrix.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def construct_cirlulant(row):
 
     N = row.size
@@ -200,7 +200,7 @@ $$
 Let's write some Python code to illustrate these ideas.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def construct_P(N):
 
     P = np.zeros((N, N))
diff --git a/lectures/exchangeable.md b/lectures/exchangeable.md
index e220b11d0..b6ab05012 100644
--- a/lectures/exchangeable.md
+++ b/lectures/exchangeable.md
@@ -72,7 +72,7 @@ tags: [hide-output]
 ---
 import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
-from numba import njit, vectorize
+from numba import jit, vectorize
 from math import gamma
 import scipy.optimize as op
 from scipy.integrate import quad
@@ -416,8 +416,8 @@ def learning_example(F_a=1, F_b=1, G_a=3, G_b=1.2):
     given the parameters which specify F and G distributions.
     """
 
-    f = njit(lambda x: p(x, F_a, F_b))
-    g = njit(lambda x: p(x, G_a, G_b))
+    f = jit(lambda x: p(x, F_a, F_b))
+    g = jit(lambda x: p(x, G_a, G_b))
 
     # l(w) = f(w) / g(w)
     l = lambda w: f(w) / g(w)
@@ -557,10 +557,10 @@ To proceed, we create some Python code.
 def function_factory(F_a=1, F_b=1, G_a=3, G_b=1.2):
 
     # define f and g
-    f = njit(lambda x: p(x, F_a, F_b))
-    g = njit(lambda x: p(x, G_a, G_b))
+    f = jit(lambda x: p(x, F_a, F_b))
+    g = jit(lambda x: p(x, G_a, G_b))
 
-    @njit
+    @jit
     def update(a, b, π):
         "Update π by drawing from beta distribution with parameters a and b"
 
@@ -572,7 +572,7 @@ def function_factory(F_a=1, F_b=1, G_a=3, G_b=1.2):
 
         return π
 
-    @njit
+    @jit
     def simulate_path(a, b, T=50):
         "Simulates a path of beliefs π with length T"
 
@@ -678,8 +678,8 @@ The following code approximates the integral above:
 def expected_ratio(F_a=1, F_b=1, G_a=3, G_b=1.2):
 
     # define f and g
-    f = njit(lambda x: p(x, F_a, F_b))
-    g = njit(lambda x: p(x, G_a, G_b))
+    f = jit(lambda x: p(x, F_a, F_b))
+    g = jit(lambda x: p(x, G_a, G_b))
 
     l = lambda w: f(w) / g(w)
     integrand_f = lambda w, π: f(w) * l(w) / (π * l(w) + 1 - π)
diff --git a/lectures/ifp.md b/lectures/ifp.md
index 06eaf1984..6c5aa7356 100644
--- a/lectures/ifp.md
+++ b/lectures/ifp.md
@@ -61,7 +61,7 @@ We'll need the following imports:
 import matplotlib.pyplot as plt
 import numpy as np
 from quantecon.optimize import brentq
-from numba import njit, float64
+from numba import jit, float64
 from numba.experimental import jitclass
 from quantecon import MarkovChain
 ```
@@ -414,7 +414,7 @@ u'(c) - \max \left\{
 ```
 
 ```{code-cell} python3
-@njit
+@jit
 def euler_diff(c, a, z, σ_vals, ifp):
     """
     The difference between the left- and right-hand side
@@ -450,7 +450,7 @@ policy function.
 The next step is to obtain the root of the Euler difference.
 
 ```{code-cell} python3
-@njit
+@jit
 def K(σ, ifp):
     """
     The operator K.
diff --git a/lectures/ifp_advanced.md b/lectures/ifp_advanced.md
index 259b6ffdf..4277c27bd 100644
--- a/lectures/ifp_advanced.md
+++ b/lectures/ifp_advanced.md
@@ -57,7 +57,7 @@ We require the following imports:
 ```{code-cell} ipython
 import matplotlib.pyplot as plt
 import numpy as np
-from numba import njit, float64
+from numba import jit, float64
 from numba.experimental import jitclass
 from quantecon import MarkovChain
 ```
@@ -415,7 +415,7 @@ class IFP:
 Here's the Coleman-Reffett operator based on EGM:
 
 ```{code-cell} ipython
-@njit
+@jit
 def K(a_in, σ_in, ifp):
     """
     The Coleman--Reffett operator for the income fluctuation problem,
@@ -619,7 +619,7 @@ The reason we do this is that `solve_model_time_iter` is not
 JIT-compiled.
 
 ```{code-cell} python3
-@njit
+@jit
 def compute_asset_series(ifp, a_star, σ_star, z_seq, T=500_000):
     """
     Simulates a time series of length T for assets, given optimal
diff --git a/lectures/imp_sample.md b/lectures/imp_sample.md
index 3520b5547..b428a3d49 100644
--- a/lectures/imp_sample.md
+++ b/lectures/imp_sample.md
@@ -31,7 +31,7 @@ We start by importing some Python packages.
 
 ```{code-cell} ipython3
 import numpy as np
-from numba import njit, vectorize, prange
+from numba import jit, vectorize, prange
 import matplotlib.pyplot as plt
 from math import gamma
 ```
@@ -81,8 +81,8 @@ def p(w, a, b):
     return r * w ** (a-1) * (1 - w) ** (b-1)
 
 # The two density functions.
-f = njit(lambda w: p(w, F_a, F_b))
-g = njit(lambda w: p(w, G_a, G_b))
+f = jit(lambda w: p(w, F_a, F_b))
+g = jit(lambda w: p(w, G_a, G_b))
 ```
 
 ```{code-cell} ipython3
@@ -99,7 +99,7 @@ plt.show()
 The likelihood ratio is `l(w)=f(w)/g(w)`.
 
 ```{code-cell} ipython3
-l = njit(lambda w: f(w) / g(w))
+l = jit(lambda w: f(w) / g(w))
 ```
 
 ```{code-cell} ipython3
@@ -197,7 +197,7 @@ Here $\frac{p\left(\omega_{i,t}^q\right)}{q\left(\omega_{i,t}^q\right)}$ is the
 Below we prepare a Python function for computing the importance sampling estimates given any beta distributions $p$, $q$.
 
 ```{code-cell} ipython3
-@njit(parallel=True)
+@jit(parallel=True)
 def estimate(p_a, p_b, q_a, q_b, T=1, N=10000):
 
     μ_L = 0
@@ -255,7 +255,7 @@ We next study the bias and efficiency of the Monte Carlo and importance sampling
 The code  below produces distributions of estimates using both Monte Carlo and importance sampling methods.
 
 ```{code-cell} ipython3
-@njit(parallel=True)
+@jit(parallel=True)
 def simulate(p_a, p_b, q_a, q_b, N_simu, T=1):
 
     μ_L_p = np.empty(N_simu)
diff --git a/lectures/inventory_dynamics.md b/lectures/inventory_dynamics.md
index 67a25d596..3acf9c388 100644
--- a/lectures/inventory_dynamics.md
+++ b/lectures/inventory_dynamics.md
@@ -50,7 +50,7 @@ Let's start with some imports
 import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
-from numba import njit, float64, prange
+from numba import jit, float64, prange
 from numba.experimental import jitclass
 ```
 
@@ -316,7 +316,7 @@ This meant writing a specialized function rather than using the class above.
 ```{code-cell} ipython3
 s, S, mu, sigma = firm.s, firm.S, firm.mu, firm.sigma
 
-@njit(parallel=True)
+@jit(parallel=True)
 def shift_firms_forward(current_inventory_levels, num_periods):
 
     num_firms = len(current_inventory_levels)
@@ -396,7 +396,7 @@ specialized function rather than using the class above.
 We will also use parallelization across firms.
 
 ```{code-cell} ipython3
-@njit(parallel=True)
+@jit(parallel=True)
 def compute_freq(sim_length=50, x_init=70, num_firms=1_000_000):
 
     firm_counter = 0  # Records number of firms that restock 2x or more
diff --git a/lectures/jv.md b/lectures/jv.md
index 7ebc8cfd1..788b43c51 100644
--- a/lectures/jv.md
+++ b/lectures/jv.md
@@ -39,7 +39,7 @@ Let's start with some imports:
 import matplotlib.pyplot as plt
 import numpy as np
 import scipy.stats as stats
-from numba import njit, prange
+from numba import jit, prange
 ```
 
 ### Model Features
@@ -197,7 +197,7 @@ class JVWorker:
         self.A, self.α, self.β, self.π = A, α, β, π
         self.mc_size, self.ɛ = mc_size, ɛ
 
-        self.g = njit(lambda x, ϕ: A * (x * ϕ)**α)    # Transition function
+        self.g = jit(lambda x, ϕ: A * (x * ϕ)**α)    # Transition function
         self.f_rvs = np.random.beta(a, b, mc_size)
 
         # Max of grid is the max of a large quantile value for f and the
@@ -255,7 +255,7 @@ def operator_factory(jv, parallel_flag=True):
     x_grid, ɛ, mc_size = jv.x_grid, jv.ɛ, jv.mc_size
     f_rvs, g = jv.f_rvs, jv.g
 
-    @njit
+    @jit
     def state_action_values(z, x, v):
         s, ϕ = z
         v_func = lambda x: np.interp(x, x_grid, v)
@@ -269,7 +269,7 @@ def operator_factory(jv, parallel_flag=True):
         q = π(s) * integral + (1 - π(s)) * v_func(g(x, ϕ))
         return x * (1 - ϕ - s) + β * q
 
-    @njit(parallel=parallel_flag)
+    @jit(parallel=parallel_flag)
     def T(v):
         """
         The Bellman operator
@@ -291,7 +291,7 @@ def operator_factory(jv, parallel_flag=True):
 
         return v_new
 
-    @njit
+    @jit
     def get_greedy(v):
         """
         Computes the v-greedy policy of a given function v
diff --git a/lectures/kesten_processes.md b/lectures/kesten_processes.md
index 77c648628..94eb90cf4 100644
--- a/lectures/kesten_processes.md
+++ b/lectures/kesten_processes.md
@@ -675,11 +675,11 @@ Here's one solution.
 First we generate the observations:
 
 ```{code-cell} ipython3
-from numba import njit, prange
+from numba import jit, prange
 from numpy.random import randn
 
 
-@njit(parallel=True)
+@jit(parallel=True)
 def generate_draws(μ_a=-0.5,
                    σ_a=0.1,
                    μ_b=0.0,
diff --git a/lectures/likelihood_bayes.md b/lectures/likelihood_bayes.md
index 3968bb7b4..e2cbb300d 100644
--- a/lectures/likelihood_bayes.md
+++ b/lectures/likelihood_bayes.md
@@ -52,14 +52,14 @@ We'll begin by loading some Python modules.
 import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
-from numba import vectorize, njit, prange
+from numba import vectorize, jit, prange
 from math import gamma
 import pandas as pd
 
 import seaborn as sns
 colors = sns.color_palette()
 
-@njit
+@jit
 def set_seed():
     np.random.seed(142857)
 set_seed()
@@ -147,12 +147,12 @@ def p(x, a, b):
     return r * x** (a-1) * (1 - x) ** (b-1)
 
 # The two density functions.
-f = njit(lambda x: p(x, F_a, F_b))
-g = njit(lambda x: p(x, G_a, G_b))
+f = jit(lambda x: p(x, F_a, F_b))
+g = jit(lambda x: p(x, G_a, G_b))
 ```
 
 ```{code-cell} python3
-@njit
+@jit
 def simulate(a, b, T=50, N=500):
     '''
     Generate N sets of T observations of the likelihood ratio,
@@ -209,7 +209,7 @@ Below we define a Python function that updates belief $\pi$ using
 likelihood ratio $\ell$ according to  recursion {eq}`eq_recur1`
 
 ```{code-cell} python3
-@njit
+@jit
 def update(π, l):
     "Update π using likelihood l"
 
@@ -591,7 +591,7 @@ $$
 We'll plot a large sample of paths.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def martingale_simulate(π0, N=5000, T=200):
 
     π_path = np.empty((N,T+1))
@@ -778,7 +778,7 @@ We approximate it for  a grid of points $\pi_{t-1} \in [0,1]$.
 Then we'll plot it.
 
 ```{code-cell} ipython3
-@njit
+@jit
 def compute_cond_var(pi, mc_size=int(1e6)):
     # create monte carlo draws
     mc_draws = np.zeros(mc_size)
diff --git a/lectures/likelihood_ratio_process.md b/lectures/likelihood_ratio_process.md
index 7c913c49b..fc02187a1 100644
--- a/lectures/likelihood_ratio_process.md
+++ b/lectures/likelihood_ratio_process.md
@@ -46,7 +46,7 @@ Let's start  by importing some Python tools.
 import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
-from numba import vectorize, njit
+from numba import vectorize, jit
 from math import gamma
 from scipy.integrate import quad
 ```
@@ -131,12 +131,12 @@ def p(x, a, b):
     return r * x** (a-1) * (1 - x) ** (b-1)
 
 # The two density functions.
-f = njit(lambda x: p(x, F_a, F_b))
-g = njit(lambda x: p(x, G_a, G_b))
+f = jit(lambda x: p(x, F_a, F_b))
+g = jit(lambda x: p(x, G_a, G_b))
 ```
 
 ```{code-cell} python3
-@njit
+@jit
 def simulate(a, b, T=50, N=500):
     '''
     Generate N sets of T observations of the likelihood ratio,
@@ -601,7 +601,7 @@ $h$ is closer to $g$
 ```{code-cell} python3
 H_a, H_b = 3.5, 1.8
 
-h = njit(lambda x: p(x, H_a, H_b))
+h = jit(lambda x: p(x, H_a, H_b))
 ```
 
 ```{code-cell} python3
@@ -665,7 +665,7 @@ $g$ so that now $K_g$ is larger than $K_f$.
 
 ```{code-cell} python3
 H_a, H_b = 1.2, 1.2
-h = njit(lambda x: p(x, H_a, H_b))
+h = jit(lambda x: p(x, H_a, H_b))
 ```
 
 ```{code-cell} python3
diff --git a/lectures/mccall_correlated.md b/lectures/mccall_correlated.md
index 8ab7c23fa..019ee7af3 100644
--- a/lectures/mccall_correlated.md
+++ b/lectures/mccall_correlated.md
@@ -50,7 +50,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import quantecon as qe
 from numpy.random import randn
-from numba import njit, prange, float64
+from numba import jit, prange, float64
 from numba.experimental import jitclass
 ```
 
@@ -223,7 +223,7 @@ class JobSearch:
 Next we implement the $Q$ operator.
 
 ```{code-cell} ipython3
-@njit(parallel=True)
+@jit(parallel=True)
 def Q(js, f_in, f_out):
     """
     Apply the operator Q.
@@ -348,11 +348,11 @@ def compute_unemployment_duration(js, seed=1234):
     z_grid = js.z_grid
     np.random.seed(seed)
 
-    @njit
+    @jit
     def f_star_function(z):
         return np.interp(z, z_grid, f_star)
 
-    @njit
+    @jit
     def draw_tau(t_max=10_000):
         z = 0
         t = 0
@@ -373,7 +373,7 @@ def compute_unemployment_duration(js, seed=1234):
                 t += 1
         return τ
 
-    @njit(parallel=True)
+    @jit(parallel=True)
     def compute_expected_tau(num_reps=100_000):
         sum_value = 0
         for i in prange(num_reps):
diff --git a/lectures/mccall_fitted_vfi.md b/lectures/mccall_fitted_vfi.md
index bfb95d486..8ca789016 100644
--- a/lectures/mccall_fitted_vfi.md
+++ b/lectures/mccall_fitted_vfi.md
@@ -51,7 +51,7 @@ We will use the following imports:
 ```{code-cell} ipython3
 import matplotlib.pyplot as plt
 import numpy as np
-from numba import njit, float64
+from numba import jit, float64
 from numba.experimental import jitclass
 ```
 
@@ -184,7 +184,7 @@ We will adopt the lognormal distribution for wages, with $w = \exp(\mu + \sigma
 when $z$ is standard normal and $\mu, \sigma$ are parameters.
 
 ```{code-cell} python3
-@njit
+@jit
 def lognormal_draws(n=1000, μ=2.5, σ=0.5, seed=1234):
     np.random.seed(seed)
     z = np.random.randn(n)
@@ -242,7 +242,7 @@ class McCallModelContinuous:
 We then return the current iterate as an approximate solution.
 
 ```{code-cell} python3
-@njit
+@jit
 def solve_model(mcm, tol=1e-5, max_iter=2000):
     """
     Iterates to convergence on the Bellman equations
@@ -273,7 +273,7 @@ and returns the associated reservation wage.
 If $v(w) < h$ for all $w$, then the function returns np.inf
 
 ```{code-cell} python3
-@njit
+@jit
 def compute_reservation_wage(mcm):
     """
     Computes the reservation wage of an instance of the McCall model
diff --git a/lectures/mccall_model.md b/lectures/mccall_model.md
index 241a61415..e5ea968e8 100644
--- a/lectures/mccall_model.md
+++ b/lectures/mccall_model.md
@@ -461,7 +461,7 @@ the reservation wage.
 We'll be using JIT compilation via Numba to turbocharge our loops.
 
 ```{code-cell} python3
-@jit(nopython=True)
+@jit
 def compute_reservation_wage(mcm,
                              max_iter=500,
                              tol=1e-6):
@@ -612,7 +612,7 @@ The big difference here, however, is that we're iterating on a scalar $h$, rathe
 Here's an implementation:
 
 ```{code-cell} python3
-@jit(nopython=True)
+@jit
 def compute_reservation_wage_two(mcm,
                                  max_iter=500,
                                  tol=1e-5):
@@ -669,7 +669,7 @@ Here's one solution
 ```{code-cell} python3
 cdf = np.cumsum(q_default)
 
-@jit(nopython=True)
+@jit
 def compute_stopping_time(w_bar, seed=1234):
 
     np.random.seed(seed)
@@ -685,7 +685,7 @@ def compute_stopping_time(w_bar, seed=1234):
             t += 1
     return stopping_time
 
-@jit(nopython=True)
+@jit
 def compute_mean_stopping_time(w_bar, num_reps=100000):
     obs = np.empty(num_reps)
     for i in range(num_reps):
@@ -799,7 +799,7 @@ class McCallModelContinuous:
         self.w_draws = np.exp(μ+ σ * s)
 
 
-@jit(nopython=True)
+@jit
 def compute_reservation_wage_continuous(mcmc, max_iter=500, tol=1e-5):
 
     c, β, σ, μ, w_draws = mcmc.c, mcmc.β, mcmc.σ, mcmc.μ, mcmc.w_draws
diff --git a/lectures/mccall_model_with_separation.md b/lectures/mccall_model_with_separation.md
index 9dd57cfa6..7b08854ac 100644
--- a/lectures/mccall_model_with_separation.md
+++ b/lectures/mccall_model_with_separation.md
@@ -58,7 +58,7 @@ We'll need the following imports
 import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
-from numba import njit, float64
+from numba import jit, float64
 from numba.experimental import jitclass
 from quantecon.distributions import BetaBinomial
 ```
@@ -307,7 +307,7 @@ This helps to tidy up the code and provides an object that's easy to pass to fun
 The default utility function is a CRRA utility function
 
 ```{code-cell} python3
-@njit
+@jit
 def u(c, σ=2.0):
     return (c**(1 - σ) - 1) / (1 - σ)
 ```
@@ -364,7 +364,7 @@ Now we iterate until successive realizations are closer together than some small
 We then return the current iterate as an approximate solution.
 
 ```{code-cell} python3
-@njit
+@jit
 def solve_model(mcm, tol=1e-5, max_iter=2000):
     """
     Iterates to convergence on the Bellman equations
@@ -425,7 +425,7 @@ Here's a function `compute_reservation_wage` that takes an instance of `McCallMo
 and returns the associated reservation wage.
 
 ```{code-cell} python3
-@njit
+@jit
 def compute_reservation_wage(mcm):
     """
     Computes the reservation wage of an instance of the McCall model
diff --git a/lectures/mccall_q.md b/lectures/mccall_q.md
index 76f182423..0e8fcce6c 100644
--- a/lectures/mccall_q.md
+++ b/lectures/mccall_q.md
@@ -581,7 +581,7 @@ class Qlearning_McCall:
 
         return qtable_new
 
-@jit(nopython=True)
+@jit
 def run_epochs(N, qlmc, qtable):
     """
     Run epochs N times with qtable from the last iteration each time.
diff --git a/lectures/mix_model.md b/lectures/mix_model.md
index 4846cb769..d1bddc225 100644
--- a/lectures/mix_model.md
+++ b/lectures/mix_model.md
@@ -125,7 +125,7 @@ As usual, we'll start by importing some Python tools.
 import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
-from numba import vectorize, njit
+from numba import vectorize, jit
 from math import gamma
 import pandas as pd
 import scipy.stats as sp
@@ -143,7 +143,7 @@ from jax import random
 
 np.random.seed(142857)
 
-@njit
+@jit
 def set_seed():
     np.random.seed(142857)
 set_seed()
@@ -164,14 +164,14 @@ def p(x, a, b):
     return r * x** (a-1) * (1 - x) ** (b-1)
 
 # The two density functions.
-f = njit(lambda x: p(x, F_a, F_b))
-g = njit(lambda x: p(x, G_a, G_b))
+f = jit(lambda x: p(x, F_a, F_b))
+g = jit(lambda x: p(x, G_a, G_b))
 ```
 
 ```{code-cell} ipython3
 :hide-output: false
 
-@njit
+@jit
 def simulate(a, b, T=50, N=500):
     '''
     Generate N sets of T observations of the likelihood ratio,
@@ -250,7 +250,7 @@ from our target mixture distribution.
 
 
 ```{code-cell} ipython3
-@njit
+@jit
 def draw_lottery(p, N):
     "Draw from the compound lottery directly."
 
@@ -339,7 +339,7 @@ likelihood ratio $ \ell $ according to  recursion {eq}`equation-eq-recur1`
 ```{code-cell} ipython3
 :hide-output: false
 
-@njit
+@jit
 def update(π, l):
     "Update π using likelihood l"
 
diff --git a/lectures/multi_hyper.md b/lectures/multi_hyper.md
index 89318ee3e..dccbd9757 100644
--- a/lectures/multi_hyper.md
+++ b/lectures/multi_hyper.md
@@ -116,7 +116,7 @@ plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
 from scipy.special import comb
 from scipy.stats import normaltest
-from numba import njit, prange
+from numba import jit, prange
 ```
 
 To recapitulate, we assume there are in total $c$ types of objects in an urn.
@@ -394,7 +394,7 @@ def bivariate_normal(x, y, μ, Σ, i, j):
 ```
 
 ```{code-cell} python3
-@njit
+@jit
 def count(vec1, vec2, n):
     size = sample.shape[0]
 
diff --git a/lectures/multivariate_normal.md b/lectures/multivariate_normal.md
index 49aa0f9e9..44d2dbd0e 100644
--- a/lectures/multivariate_normal.md
+++ b/lectures/multivariate_normal.md
@@ -64,7 +64,7 @@ We  use the following imports:
 import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
-from numba import njit
+from numba import jit
 import statsmodels.api as sm
 ```
 
@@ -84,7 +84,7 @@ covariance matrix of $z$.
 The covariance matrix $\Sigma$ is symmetric and positive definite.
 
 ```{code-cell} python3
-@njit
+@jit
 def f(z, μ, Σ):
     """
     The density function of multivariate normal distribution.
diff --git a/lectures/navy_captain.md b/lectures/navy_captain.md
index f9a97a1c9..d441d5415 100644
--- a/lectures/navy_captain.md
+++ b/lectures/navy_captain.md
@@ -28,7 +28,7 @@ kernelspec:
 ```{code-cell} ipython
 import matplotlib.pyplot as plt
 import numpy as np
-from numba import njit, prange, float64, int64
+from numba import jit, prange, float64, int64
 from numba.experimental import jitclass
 from math import gamma
 from scipy.optimize import minimize
@@ -110,7 +110,7 @@ $b_{1}=1.2$, respectively.
 Below is some Python code that sets up these objects.
 
 ```{code-cell} python3
-@njit
+@jit
 def p(x, a, b):
     "Beta distribution."
 
@@ -346,7 +346,7 @@ consequently the minimal $\bar{V}_{fre}\left(t\right)$.
 Here is Python code that does that and then plots a useful graph.
 
 ```{code-cell} python3
-@njit
+@jit
 def V_fre_d_t(d, t, L0_arr, L1_arr, π_star, wf):
 
     N = L0_arr.shape[0]
@@ -475,7 +475,7 @@ lecture {doc}`A Problem that Stumped Milton Friedman <wald_friedman>`
 that computes $\alpha$ and $\beta$.
 
 ```{code-cell} python3
-@njit(parallel=True)
+@jit(parallel=True)
 def Q(h, wf):
 
     c, π_grid = wf.c, wf.π_grid
@@ -508,7 +508,7 @@ def Q(h, wf):
 ```
 
 ```{code-cell} python3
-@njit
+@jit
 def solve_model(wf, tol=1e-4, max_iter=1000):
     """
     Compute the continuation value function
@@ -538,7 +538,7 @@ h_star = solve_model(wf)
 ```
 
 ```{code-cell} python3
-@njit
+@jit
 def find_cutoff_rule(wf, h):
 
     """
@@ -645,7 +645,7 @@ $V^{0}\left(\pi\right)$ and $V^{1}\left(\pi\right)$
 numerically.
 
 ```{code-cell} python3
-@njit(parallel=True)
+@jit(parallel=True)
 def V_q(wf, flag):
     V = np.zeros(wf.π_grid_size)
     if flag == 0:
@@ -877,7 +877,7 @@ On average the Bayesian rule decides **earlier** than the frequentist
 rule when $q= f_0$ and **later** when $q = f_1$.
 
 ```{code-cell} python3
-@njit(parallel=True)
+@jit(parallel=True)
 def check_results(L_arr, α, β, flag, π0):
 
     N, T = L_arr.shape
diff --git a/lectures/odu.md b/lectures/odu.md
index 979f00b74..b8284cdde 100644
--- a/lectures/odu.md
+++ b/lectures/odu.md
@@ -58,7 +58,7 @@ Let’s start with some imports
 
 ```{code-cell} ipython
 import matplotlib.pyplot as plt
-from numba import njit, prange, vectorize
+from numba import jit, prange, vectorize
 from interpolation import mlinterp
 from math import gamma
 import numpy as np
@@ -299,8 +299,8 @@ class SearchProblem:
 
         self.β, self.c, self.w_max = β, c, w_max
 
-        self.f = njit(lambda x: p(x, F_a, F_b))
-        self.g = njit(lambda x: p(x, G_a, G_b))
+        self.f = jit(lambda x: p(x, F_a, F_b))
+        self.g = jit(lambda x: p(x, G_a, G_b))
 
         self.π_min, self.π_max = 1e-3, 1-1e-3    # Avoids instability
         self.w_grid = np.linspace(0, w_max, w_grid_size)
@@ -326,11 +326,11 @@ def operator_factory(sp, parallel_flag=True):
     mc_size = sp.mc_size
     w_grid, π_grid = sp.w_grid, sp.π_grid
 
-    @njit
+    @jit
     def v_func(x, y, v):
         return mlinterp((w_grid, π_grid), v, (x, y))
 
-    @njit
+    @jit
     def κ(w, π):
         """
         Updates π using Bayes' rule and the current wage observation w.
@@ -340,7 +340,7 @@ def operator_factory(sp, parallel_flag=True):
 
         return π_new
 
-    @njit(parallel=parallel_flag)
+    @jit(parallel=parallel_flag)
     def T(v):
         """
         The Bellman operator.
@@ -366,7 +366,7 @@ def operator_factory(sp, parallel_flag=True):
 
         return v_new
 
-    @njit(parallel=parallel_flag)
+    @jit(parallel=parallel_flag)
     def get_greedy(v):
         """"
         Compute optimal actions taking v as the value function.
@@ -638,11 +638,11 @@ def Q_factory(sp, parallel_flag=True):
     mc_size = sp.mc_size
     w_grid, π_grid = sp.w_grid, sp.π_grid
 
-    @njit
+    @jit
     def ω_func(p, ω):
         return np.interp(p, π_grid, ω)
 
-    @njit
+    @jit
     def κ(w, π):
         """
         Updates π using Bayes' rule and the current wage observation w.
@@ -652,7 +652,7 @@ def Q_factory(sp, parallel_flag=True):
 
         return π_new
 
-    @njit(parallel=parallel_flag)
+    @jit(parallel=parallel_flag)
     def Q(ω):
         """
 
@@ -790,9 +790,9 @@ w_bar = solve_wbar(sp, verbose=False)
 
 # Interpolate reservation wage function
 π_grid = sp.π_grid
-w_func = njit(lambda x: np.interp(x, π_grid, w_bar))
+w_func = jit(lambda x: np.interp(x, π_grid, w_bar))
 
-@njit
+@jit
 def update(a, b, e, π):
     "Update e and π by drawing wage offer from beta distribution with parameters a and b"
 
@@ -805,7 +805,7 @@ def update(a, b, e, π):
 
     return e, π
 
-@njit
+@jit
 def simulate_path(F_a=F_a,
                   F_b=F_b,
                   G_a=G_a,
@@ -868,7 +868,7 @@ empirical distributions of unemployment duration and π at the time of
 employment.
 
 ```{code-cell} python3
-@njit
+@jit
 def empirical_dist(F_a, F_b, G_a, G_b, w_bar, π_grid,
                    N=10000, T=600):
     """
diff --git a/lectures/optgrowth_fast.md b/lectures/optgrowth_fast.md
index dd07a1ffc..69c4776c4 100644
--- a/lectures/optgrowth_fast.md
+++ b/lectures/optgrowth_fast.md
@@ -61,7 +61,7 @@ Let's start with some imports:
 ```{code-cell} ipython
 import matplotlib.pyplot as plt
 import numpy as np
-from numba import jit, njit
+from numba import jit, jit
 from quantecon.optimize.scalar_maximization import brent_max
 ```
 
@@ -131,7 +131,7 @@ We will use JIT compilation to accelerate the Bellman operator.
 First, here's a function that returns the value of a particular consumption choice `c`, given state `y`, as per the Bellman equation {eq}`fpb30`.
 
 ```{code-cell} python3
-@njit
+@jit
 def state_action_value(c, y, v_array, og):
     """
     Right hand side of the Bellman equation.
@@ -154,7 +154,7 @@ Now we can implement the Bellman operator, which maximizes the right hand side
 of the Bellman equation:
 
 ```{code-cell} python3
-@jit(nopython=True)
+@jit
 def T(v, og):
     """
     The Bellman operator.
diff --git a/lectures/perm_income.md b/lectures/perm_income.md
index 600df8444..af1973607 100644
--- a/lectures/perm_income.md
+++ b/lectures/perm_income.md
@@ -51,7 +51,7 @@ import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
 import random
-from numba import njit
+from numba import jit
 ```
 
 ## The Savings Problem
@@ -479,7 +479,7 @@ r = 0.05
 μ = 1
 T = 60
 
-@njit
+@jit
 def time_path(T):
     w = np.random.randn(T+1)  # w_0, w_1, ..., w_T
     w[0] = 0
@@ -807,7 +807,7 @@ r = 0.05
 S = 5   # Impulse date
 σ1 = σ2 = 0.15
 
-@njit
+@jit
 def time_path(T, permanent=False):
     "Time path of consumption and debt given shock sequence"
     w1 = np.zeros(T+1)
diff --git a/lectures/wald_friedman.md b/lectures/wald_friedman.md
index b64437851..b284176e7 100644
--- a/lectures/wald_friedman.md
+++ b/lectures/wald_friedman.md
@@ -186,7 +186,7 @@ The next figure shows two beta distributions in the top panel.
 The bottom panel presents mixtures of these distributions, with various mixing probabilities $\pi_k$
 
 ```{code-cell} ipython3
-@jit(nopython=True)
+@jit
 def p(x, a, b):
     r = gamma(a + b) / (gamma(a) * gamma(b))
     return r * x**(a-1) * (1 - x)**(b-1)
@@ -502,7 +502,7 @@ def Q(h, wf):
 To solve the key functional equation, we will iterate using `Q` to find the fixed point
 
 ```{code-cell} ipython3
-@jit(nopython=True)
+@jit
 def solve_model(wf, tol=1e-4, max_iter=1000):
     """
     Compute the continuation cost function
@@ -557,7 +557,7 @@ We will also set up a function to compute the cutoffs $\alpha$ and $\beta$
 and plot these on our cost function plot
 
 ```{code-cell} ipython3
-@jit(nopython=True)
+@jit
 def find_cutoff_rule(wf, h):
 
     """
diff --git a/lectures/wealth_dynamics.md b/lectures/wealth_dynamics.md
index 9236d6eb2..e7d34ed5e 100644
--- a/lectures/wealth_dynamics.md
+++ b/lectures/wealth_dynamics.md
@@ -80,7 +80,7 @@ import matplotlib.pyplot as plt
 plt.rcParams["figure.figsize"] = (11, 5)  #set default figure size
 import numpy as np
 import quantecon as qe
-from numba import njit, float64, prange
+from numba import jit, float64, prange
 from numba.experimental import jitclass
 ```
 
@@ -352,7 +352,7 @@ Here's function to simulate the time series of wealth for in individual househol
 
 ```{code-cell} ipython3
 
-@njit
+@jit
 def wealth_time_series(wdy, w_0, n):
     """
     Generate a single time series of length n for wealth given
@@ -381,7 +381,7 @@ Note the use of parallelization to speed up computation.
 
 ```{code-cell} ipython3
 
-@njit(parallel=True)
+@jit(parallel=True)
 def update_cross_section(wdy, w_distribution, shift_length=500):
     """
     Shifts a cross-section of household forward in time