import numpy as np

from interpolation import interp

from numba import njit, prange

from quantecon.optimize.scalar_maximization import brent_max

The right-hand side of the Bellman equation

"""

# First turn v into a function via interpolation

v_func = lambda x: interp(grid, v, x)

v_func = lambda x: np.interp(x, grid, v)

return u(c) + β * np.mean(v_func(f(y - c) * shocks))

@njit(parallel=parallel_flag)

:depth: 2

```

In addition to what's in Anaconda, this lecture will need the following libraries:

```{code-cell} ipython

---

tags: [hide-output]

---

!pip install interpolation

```

## Overview

In this section, we solve a simple on-the-job search model

```{code-cell} ipython

import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] = (11, 5) #set default figure size

import numpy as np

import scipy.stats as stats

from interpolation import interp

from numba import njit, prange

```

@njit

def state_action_values(z, x, v):

s, ϕ = z

v_func = lambda x: interp(x_grid, v, x)

v_func = lambda x: np.interp(x, x_grid, v)

integral = 0

for m in range(mc_size):

s_policy, ϕ_policy = get_greedy(v_star)

# Turn the policy function arrays into actual functions

s = lambda y: interp(x_grid, s_policy, y)

ϕ = lambda y: interp(x_grid, ϕ_policy, y)

s = lambda y: np.interp(y, x_grid, s_policy)

ϕ = lambda y: np.interp(y, x_grid, ϕ_policy)

def h(x, b, u):

return (1 - b) * g(x, ϕ(x)) + b * max(g(x, ϕ(x)), u)

tags: [hide-output]

---

!pip install quantecon

!pip install interpolation

```

## Overview

```{code-cell} ipython3

import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] = (11, 5) #set default figure size

import numpy as np

import quantecon as qe

from interpolation import interp

from numpy.random import randn

from numba import njit, prange, float64

from numba.experimental import jitclass

for m in range(M):

e1, e2 = js.e_draws[:, m]

z_next = d + ρ * z + σ * e1

go_val = interp(js.z_grid, f_in, z_next) # f(z')

go_val = np.interp(z_next, js.z_grid, f_in) # f(z')

y_next = np.exp(μ + s * e2) # y' draw

w_next = np.exp(z_next) + y_next # w' draw

stop_val = np.log(w_next) / (1 - β)

@njit

def f_star_function(z):

return interp(z_grid, f_star, z)

return np.interp(z, z_grid, f_star)

@njit

def draw_tau(t_max=10_000):

:depth: 2

```

In addition to what's in Anaconda, this lecture will need the following libraries:

```{code-cell} ipython

---

tags: [hide-output]

---

!pip install interpolation

```

## Overview

```{code-cell} ipython3

import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] = (11, 5) #set default figure size

import numpy as np

from interpolation import interp

from numba import njit, float64

from numba.experimental import jitclass

```

{cite}`gordon1995stable` or {cite}`stachurski2008continuous`) and

1. preserves useful shape properties such as monotonicity and concavity/convexity.

Linear interpolation will be implemented using a JIT-aware Python interpolation library called [interpolation.py](https://github.com/EconForge/interpolation.py).

Linear interpolation will be implemented using [numpy.interp](https://numpy.org/doc/stable/reference/generated/numpy.interp.html).

The next figure illustrates piecewise linear interpolation of an arbitrary

function on grid points $0, 0.2, 0.4, 0.6, 0.8, 1$.

f_grid = np.linspace(0, 1, 150)

def Af(x):

return interp(c_grid, f(c_grid), x)

return np.interp(x, c_grid, f(c_grid))

fig, ax = plt.subplots()

u = lambda x: np.log(x)

# Interpolate array represented value function

vf = lambda x: interp(w, v, x)

vf = lambda x: np.interp(x, w, v)

# Update d using Monte Carlo to evaluate integral

d_new = np.mean(np.maximum(vf(self.w_draws), u(c) + β * d))

:depth: 2

```

In addition to what's in Anaconda, this lecture will need the following libraries:

```{code-cell} ipython

---

tags: [hide-output]

---

!pip install interpolation

```

```{code-cell} ipython

import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] = (11, 5) #set default figure size

import numpy as np

from numba import njit, prange, float64, int64

from numba.experimental import jitclass

from interpolation import interp

from math import gamma

from scipy.optimize import minimize

```

κ = wf.κ

h_new = np.empty_like(π_grid)

h_func = lambda p: interp(π_grid, h, p)

h_func = lambda p: np.interp(p, π_grid, h)

for i in prange(len(π_grid)):

π = π_grid[i]

for j in prange(len(z_arr)):

π_next = wf.κ(z_arr[j], π)

V[i] += wf.c + interp(wf.π_grid, V_old, π_next)

V[i] += wf.c + np.interp(π_next, wf.π_grid, V_old)

V[i] /= wf.mc_size

```{code-cell} ipython

import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] = (11, 5) #set default figure size

from numba import njit, prange, vectorize

from interpolation import mlinterp, interp

from interpolation import mlinterp

from math import gamma

import numpy as np

from matplotlib import cm

@njit

def ω_func(p, ω):

return interp(π_grid, ω, p)

return np.interp(p, π_grid, ω)

@njit

def κ(w, π):

# Interpolate reservation wage function

π_grid = sp.π_grid

w_func = njit(lambda x: interp(π_grid, w_bar, x))

w_func = njit(lambda x: np.interp(x, π_grid, w_bar))

@njit

def update(a, b, e, π):

π = π * lw / (π * lw + 1 - π)

# move to next agent if accepts

if w >= interp(π_grid, w_bar, π):

if w >= np.interp(π, π_grid, w_bar):

break

# record the unemployment duration

tags: [hide-output]

---

!pip install quantecon

!pip install interpolation

```

## Overview

```{code-cell} ipython

import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] = (11, 5) #set default figure size

import numpy as np

from interpolation import interp

from numba import jit, njit

from quantecon.optimize.scalar_maximization import brent_max

```

We are using an interpolation function from

[interpolation.py](https://github.com/EconForge/interpolation.py) because it

helps us JIT-compile our code.

The function `brent_max` is also designed for embedding in JIT-compiled code.

These are alternatives to similar functions in SciPy (which, unfortunately, are not JIT-aware).

u, f, β, shocks = og.u, og.f, og.β, og.shocks

v = lambda x: interp(og.grid, v_array, x)

v = lambda x: np.interp(x, og.grid, v_array)

return u(c) + β * np.mean(v(f(y - c) * shocks))

```

v_greedy, v_solution = solve_model(og, verbose=False)

# Define an optimal policy function

σ_func = lambda x: interp(og.grid, v_greedy, x)

σ_func = lambda x: np.interp(x, og.grid, v_greedy)

y = simulate_og(σ_func, og)

ax.plot(y, lw=2, alpha=0.6, label=rf'$\beta = {β}$')

:depth: 2

```

In addition to what's in Anaconda, this lecture will need the following libraries:

```{code-cell} ipython3

:tags: [hide-output]

!pip install interpolation

```

## Overview

This lecture describes a statistical decision problem presented to Milton

import matplotlib.pyplot as plt

from numba import jit, prange, float64, int64

from numba.experimental import jitclass

from interpolation import interp

from math import gamma

```

κ = wf.κ

h_new = np.empty_like(π_grid)

h_func = lambda p: interp(π_grid, h, p)

h_func = lambda p: np.interp(p, π_grid, h)

for i in prange(len(π_grid)):

π = π_grid[i]