From c227f9c60304b445bd332eac3abed27ec55856e7 Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Mon, 20 Oct 2025 17:27:54 +0900 Subject: [PATCH 01/12] update markov_asset --- lectures/markov_asset.md | 166 +++++++++++++++++++++------------------ 1 file changed, 91 insertions(+), 75 deletions(-) diff --git a/lectures/markov_asset.md b/lectures/markov_asset.md index 1739dde0f..0c4264df0 100644 --- a/lectures/markov_asset.md +++ b/lectures/markov_asset.md @@ -75,7 +75,10 @@ Let's start with some imports: import matplotlib.pyplot as plt import numpy as np import quantecon as qe -from numpy.linalg import eigvals, solve +import jax +import jax.numpy as jnp +from jax.numpy.linalg import eigvals, solve +from typing import NamedTuple ``` ## {index}`Pricing Models ` @@ -91,7 +94,7 @@ Let $\{d_t\}_{t \geq 0}$ be a stream of dividends Let's look at some equations that we expect to hold for prices of assets under ex-dividend contracts (we will consider cum-dividend pricing in the exercises). -### Risk-Neutral Pricing +### Risk-neutral pricing ```{index} single: Pricing Models; Risk-Neutral ``` @@ -116,7 +119,7 @@ Here ${\mathbb E}_t [y]$ denotes the best forecast of $y$, conditioned on inform More precisely, ${\mathbb E}_t [y]$ is the mathematical expectation of $y$ conditional on information available at time $t$. -### Pricing with Random Discount Factor +### Pricing with random discount factor ```{index} single: Pricing Models; Risk Aversion ``` @@ -145,7 +148,7 @@ This is because such assets pay well when funds are more urgently wanted. We give examples of how the stochastic discount factor has been modeled below. -### Asset Pricing and Covariances +### Asset pricing and covariances Recall that, from the definition of a conditional covariance ${\rm cov}_t (x_{t+1}, y_{t+1})$, we have @@ -174,7 +177,7 @@ Equation {eq}`lteeqs102` asserts that the covariance of the stochastic discount We give examples of some models of stochastic discount factors that have been proposed later in this lecture and also in a [later lecture](https://python-advanced.quantecon.org/lucas_model.html). -### The Price-Dividend Ratio +### The price-dividend ratio Aside from prices, another quantity of interest is the **price-dividend ratio** $v_t := p_t / d_t$. @@ -190,7 +193,7 @@ v_t = {\mathbb E}_t \left[ m_{t+1} \frac{d_{t+1}}{d_t} (1 + v_{t+1}) \right] Below we'll discuss the implication of this equation. -## Prices in the Risk-Neutral Case +## Prices in the risk-neutral case What can we say about price dynamics on the basis of the models described above? @@ -203,7 +206,7 @@ For now we'll study the risk-neutral case in which the stochastic discount fac We'll focus on how an asset price depends on a dividend process. -### Example 1: Constant Dividends +### Example 1: constant dividends The simplest case is risk-neutral price of a constant, non-random dividend stream $d_t = d > 0$. @@ -234,7 +237,7 @@ This is the equilibrium price in the constant dividend case. Indeed, simple algebra shows that setting $p_t = \bar p$ for all $t$ satisfies the difference equation $p_t = \beta (d + p_{t+1})$. -### Example 2: Dividends with Deterministic Growth Paths +### Example 2: dividends with deterministic growth paths Consider a growing, non-random dividend process $d_{t+1} = g d_t$ where $0 < g \beta < 1$. @@ -267,7 +270,7 @@ $$ This is called the *Gordon formula*. (mass_mg)= -### Example 3: Markov Growth, Risk-Neutral Pricing +### Example 3: Markov growth, risk-neutral pricing Next, we consider a dividend process @@ -310,14 +313,14 @@ The next figure shows a simulation, where * $\{X_t\}$ evolves as a discretized AR1 process produced using {ref}`Tauchen's method `. * $g_t = \exp(X_t)$, so that $\ln g_t = X_t$ is the growth rate. -```{code-cell} ipython +```{code-cell} ipython3 n = 7 mc = qe.tauchen(n, 0.96, 0.25) sim_length = 80 -x_series = mc.simulate(sim_length, init=np.median(mc.state_values)) -g_series = np.exp(x_series) -d_series = np.cumprod(g_series) # Assumes d_0 = 1 +x_series = mc.simulate(sim_length, init=jnp.median(mc.state_values)) +g_series = jnp.exp(x_series) +d_series = jnp.cumprod(g_series) # Assumes d_0 = 1 series = [x_series, g_series, d_series, np.log(d_series)] labels = ['$X_t$', '$g_t$', '$d_t$', r'$\log \, d_t$'] @@ -330,7 +333,7 @@ plt.tight_layout() plt.show() ``` -#### Pricing Formula +#### Pricing formula To obtain asset prices in this setting, let's adapt our analysis from the case of deterministic growth. @@ -400,18 +403,18 @@ As before, we'll generate $\{X_t\}$ as a {ref}`discretized AR1 process Here's the code, including a test of the spectral radius condition -```{code-cell} python3 +```{code-cell} ipython3 n = 25 # Size of state space β = 0.9 mc = qe.tauchen(n, 0.96, 0.02) -K = mc.P * np.exp(mc.state_values) +K = mc.P * jnp.exp(mc.state_values) warning_message = "Spectral radius condition fails" -assert np.max(np.abs(eigvals(K))) < 1 / β, warning_message +assert jnp.max(jnp.abs(eigvals(K))) < 1 / β, warning_message -I = np.identity(n) -v = solve(I - β * K, β * K @ np.ones(n)) +I = jnp.identity(n) +v = solve(I - β * K, β * K @ jnp.ones(n)) fig, ax = plt.subplots() ax.plot(mc.state_values, v, 'g-o', lw=2, alpha=0.7, label='$v$') @@ -440,7 +443,7 @@ We'll price several distinct assets, including * A consol (a type of bond issued by the UK government in the 19th century) * Call options on a consol -### Pricing a Lucas Tree +### Pricing a Lucas tree ```{index} single: Finite Markov Asset Pricing; Lucas Tree ``` @@ -539,46 +542,51 @@ v = (I - \beta J)^{-1} \beta J {\mathbb 1} We will define a function tree_price to compute $v$ given parameters stored in the class AssetPriceModel -```{code-cell} python3 -class AssetPriceModel: +```{code-cell} ipython3 +class AssetPriceModel(NamedTuple): """ A class that stores the primitives of the asset pricing model. Parameters ---------- - β : scalar, float - Discount factor mc : MarkovChain - Contains the transition matrix and set of state values for the state - process - γ : scalar(float) - Coefficient of risk aversion + Contains the transition matrix and set of state values g : callable The function mapping states to growth rates - + β : float + Discount factor + γ : float + Coefficient of risk aversion + n: int + The number of states + """ + mc: qe.MarkovChain + g: callable + β: float + γ: float + n: int + + +def create_ap_model(mc=None, g=jnp.exp, β=0.96, γ=2.0): + """Create an AssetPriceModel class""" + if mc is None: + n, ρ, σ = 25, 0.9, 0.02 + mc = qe.tauchen(n, ρ, σ) + else: + mc = mc + n = mc.P.shape[0] + + return AssetPriceModel(mc=mc, g=g, β=β, γ=γ, n=n) + + +def test_stability(Q, β): """ - def __init__(self, β=0.96, mc=None, γ=2.0, g=np.exp): - self.β, self.γ = β, γ - self.g = g - - # A default process for the Markov chain - if mc is None: - self.ρ = 0.9 - self.σ = 0.02 - self.mc = qe.tauchen(n, self.ρ, self.σ) - else: - self.mc = mc - - self.n = self.mc.P.shape[0] - - def test_stability(self, Q): - """ - Stability test for a given matrix Q. - """ - sr = np.max(np.abs(eigvals(Q))) - if not sr < 1 / self.β: - msg = f"Spectral radius condition failed with radius = {sr}" - raise ValueError(msg) + Stability test for a given matrix Q. + """ + sr = np.max(np.abs(eigvals(Q))) + if not sr < 1 / β: + msg = f"Spectral radius condition failed with radius = {sr}" + raise ValueError(msg) def tree_price(ap): @@ -601,11 +609,11 @@ def tree_price(ap): J = P * ap.g(y)**(1 - γ) # Make sure that a unique solution exists - ap.test_stability(J) + test_stability(J, β) # Compute v - I = np.identity(ap.n) - Ones = np.ones(ap.n) + I = jnp.identity(ap.n) + Ones = jnp.ones(ap.n) v = solve(I - β * J, β * J @ Ones) return v @@ -614,16 +622,16 @@ def tree_price(ap): Here's a plot of $v$ as a function of the state for several values of $\gamma$, with a positively correlated Markov process and $g(x) = \exp(x)$ -```{code-cell} python3 +```{code-cell} ipython3 γs = [1.2, 1.4, 1.6, 1.8, 2.0] -ap = AssetPriceModel() +ap = create_ap_model() states = ap.mc.state_values fig, ax = plt.subplots() for γ in γs: - ap.γ = γ - v = tree_price(ap) + tem_ap = create_ap_model(mc=ap.mc, g=ap.g, β=ap.β, γ=γ) + v = tree_price(tem_ap) ax.plot(states, v, lw=2, alpha=0.6, label=rf"$\gamma = {γ}$") ax.set_title('Price-dividend ratio as a function of the state') @@ -706,7 +714,7 @@ p = (I - \beta M)^{-1} \beta M \zeta {\mathbb 1} The above is implemented in the function consol_price. -```{code-cell} python3 +```{code-cell} ipython3 def consol_price(ap, ζ): """ Computes price of a consol bond with payoff ζ @@ -715,7 +723,7 @@ def consol_price(ap, ζ): ---------- ap: AssetPriceModel An instance of AssetPriceModel containing primitives - + ζ : scalar(float) Coupon of the console @@ -723,18 +731,17 @@ def consol_price(ap, ζ): ------- p : array_like(float) Console bond prices - """ # Simplify names, set up matrices β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values M = P * ap.g(y)**(- γ) # Make sure that a unique solution exists - ap.test_stability(M) + test_stability(M, β) # Compute price - I = np.identity(ap.n) - Ones = np.ones(ap.n) + I = jnp.identity(ap.n) + Ones = jnp.ones(ap.n) p = solve(I - β * M, β * ζ * M @ Ones) return p @@ -812,7 +819,7 @@ Start at some initial $w$ and iterate with $T$ to convergence . We can find the solution with the following function call_option -```{code-cell} python3 +```{code-cell} ipython3 def call_option(ap, ζ, p_s, ϵ=1e-7): """ Computes price of a call option on a consol bond. @@ -828,7 +835,7 @@ def call_option(ap, ζ, p_s, ϵ=1e-7): p_s : scalar(float) Strike price - ϵ : scalar(float), optional(default=1e-8) + ϵ : scalar(float), optional(default=1e-7) Tolerance for infinite horizon problem Returns @@ -842,26 +849,35 @@ def call_option(ap, ζ, p_s, ϵ=1e-7): M = P * ap.g(y)**(- γ) # Make sure that a unique consol price exists - ap.test_stability(M) + test_stability(M, β) # Compute option price p = consol_price(ap, ζ) - w = np.zeros(ap.n) + w = jnp.zeros(ap.n) error = ϵ + 1 - while error > ϵ: + + def step(state): + w, error = state # Maximize across columns - w_new = np.maximum(β * M @ w, p - p_s) + w_new = jnp.maximum(β * M @ w, p - p_s) # Find maximal difference of each component and update - error = np.amax(np.abs(w - w_new)) - w = w_new + error_new = jnp.amax(jnp.abs(w - w_new)) + return (w_new, error_new) - return w + # Check whether converged + def cond(state): + _, error = state + return error > ϵ + + final_w, _ = jax.lax.while_loop(cond, step, (w, error)) + + return final_w ``` Here's a plot of $w$ compared to the consol price when $P_S = 40$ -```{code-cell} python3 -ap = AssetPriceModel(β=0.9) +```{code-cell} ipython3 +ap = create_ap_model(β=0.9) ζ = 1.0 strike_price = 40 From 0317e4a9f51861b3102dec1a15759f3f46ec04f3 Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Wed, 22 Oct 2025 15:36:53 +0900 Subject: [PATCH 02/12] modified: lectures/markov_asset.md --- lectures/markov_asset.md | 53 ++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 19 deletions(-) diff --git a/lectures/markov_asset.md b/lectures/markov_asset.md index 0c4264df0..298d43433 100644 --- a/lectures/markov_asset.md +++ b/lectures/markov_asset.md @@ -35,6 +35,16 @@ kernelspec: "Asset pricing is all about covariances" -- Lars Peter Hansen ``` +```{admonition} GPU +:class: warning + +This lecture is accelerated via [hardware](status:machine-details) that has access to a GPU and JAX for GPU programming. + +Free GPUs are available on Google Colab. To use this option, please click on the play icon top right, select Colab, and set the runtime environment to include a GPU. + +Alternatively, if you have your own GPU, you can follow the [instructions](https://github.com/google/jax) for installing JAX with GPU support. If you would like to install JAX running on the `cpu` only you can use `pip install jax[cpu]` +``` + In addition to what's in Anaconda, this lecture will need the following libraries: ```{code-cell} ipython @@ -976,10 +986,12 @@ $$ Consider the following primitives -```{code-cell} python3 +```{code-cell} ipython3 n = 5 # Size of State Space -P = np.full((n, n), 0.0125) -P[range(n), range(n)] += 1 - P.sum(1) +P = jnp.full((n, n), 0.0125) +P = P.at[jnp.arange(n), jnp.arange(n)].set( + P[jnp.arange(n), jnp.arange(n)] + 1 - P.sum(1) + ) # State values of the Markov chain s = np.array([0.95, 0.975, 1.0, 1.025, 1.05]) γ = 2.0 @@ -1004,11 +1016,13 @@ Do the same for First, let's enter the parameters: -```{code-cell} python3 +```{code-cell} ipython3 n = 5 -P = np.full((n, n), 0.0125) -P[range(n), range(n)] += 1 - P.sum(1) -s = np.array([0.95, 0.975, 1.0, 1.025, 1.05]) # State values +P = jnp.full((n, n), 0.0125) +P = P.at[jnp.arange(n), jnp.arange(n)].set( + P[jnp.arange(n), jnp.arange(n)] + 1 - P.sum(1) + ) +s = jnp.array([0.95, 0.975, 1.0, 1.025, 1.05]) # State values mc = qe.MarkovChain(P, state_values=s) γ = 2.0 @@ -1020,27 +1034,27 @@ p_s = 150.0 Next, we'll create an instance of `AssetPriceModel` to feed into the functions -```{code-cell} python3 -apm = AssetPriceModel(β=β, mc=mc, γ=γ, g=lambda x: x) +```{code-cell} ipython3 +apm = create_ap_model(mc=mc, g=lambda x: x, β=β, γ=γ) ``` Now we just need to call the relevant functions on the data: -```{code-cell} python3 +```{code-cell} ipython3 tree_price(apm) ``` -```{code-cell} python3 +```{code-cell} ipython3 consol_price(apm, ζ) ``` -```{code-cell} python3 +```{code-cell} ipython3 call_option(apm, ζ, p_s) ``` Let's show the last two functions as a plot -```{code-cell} python3 +```{code-cell} ipython3 fig, ax = plt.subplots() ax.plot(s, consol_price(apm, ζ), label='consol') ax.plot(s, call_option(apm, ζ, p_s), label='call option') @@ -1101,7 +1115,7 @@ Is one higher than the other? Can you give intuition? Here's a suitable function: -```{code-cell} python3 +```{code-cell} ipython3 def finite_horizon_call_option(ap, ζ, p_s, k): """ Computes k period option value. @@ -1111,15 +1125,16 @@ def finite_horizon_call_option(ap, ζ, p_s, k): M = P * ap.g(y)**(- γ) # Make sure that a unique solution exists - ap.test_stability(M) - + test_stability(M, β) # Compute option price p = consol_price(ap, ζ) - w = np.zeros(ap.n) - for i in range(k): + def step(i, w): # Maximize across columns - w = np.maximum(β * M @ w, p - p_s) + w = jnp.maximum(β * M @ w, p - p_s) + return w + + w = jax.lax.fori_loop(0, k, step, jnp.zeros(ap.n)) return w ``` From 17396978b84468c0e83f50365659e6762ebf90ab Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Wed, 22 Oct 2025 17:09:33 +0900 Subject: [PATCH 03/12] add metadata cell for figures --- lectures/markov_asset.md | 45 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/lectures/markov_asset.md b/lectures/markov_asset.md index 298d43433..90e20c315 100644 --- a/lectures/markov_asset.md +++ b/lectures/markov_asset.md @@ -324,6 +324,13 @@ The next figure shows a simulation, where * $g_t = \exp(X_t)$, so that $\ln g_t = X_t$ is the growth rate. ```{code-cell} ipython3 +--- +mystnb: + figure: + caption: | + State, growth, and dividend simulation + name: fig_markov_sim +--- n = 7 mc = qe.tauchen(n, 0.96, 0.25) sim_length = 80 @@ -414,6 +421,13 @@ As before, we'll generate $\{X_t\}$ as a {ref}`discretized AR1 process Here's the code, including a test of the spectral radius condition ```{code-cell} ipython3 +--- +mystnb: + figure: + caption: | + Price-dividend ratio risk-neutral case + name: fig_pdv_neutral +--- n = 25 # Size of state space β = 0.9 mc = qe.tauchen(n, 0.96, 0.02) @@ -633,6 +647,13 @@ Here's a plot of $v$ as a function of the state for several values of $\gamma$, with a positively correlated Markov process and $g(x) = \exp(x)$ ```{code-cell} ipython3 +--- +mystnb: + figure: + caption: | + Lucas tree prices for varying risk aversion + name: fig_lucas_gamma +--- γs = [1.2, 1.4, 1.6, 1.8, 2.0] ap = create_ap_model() states = ap.mc.state_values @@ -644,7 +665,6 @@ for γ in γs: v = tree_price(tem_ap) ax.plot(states, v, lw=2, alpha=0.6, label=rf"$\gamma = {γ}$") -ax.set_title('Price-dividend ratio as a function of the state') ax.set_ylabel("price-dividend ratio") ax.set_xlabel("state") ax.legend(loc='upper right') @@ -887,6 +907,13 @@ def call_option(ap, ζ, p_s, ϵ=1e-7): Here's a plot of $w$ compared to the consol price when $P_S = 40$ ```{code-cell} ipython3 +--- +mystnb: + figure: + caption: | + Consol price and call option value + name: fig_consol_call +--- ap = create_ap_model(β=0.9) ζ = 1.0 strike_price = 40 @@ -1055,6 +1082,13 @@ call_option(apm, ζ, p_s) Let's show the last two functions as a plot ```{code-cell} ipython3 +--- +mystnb: + figure: + caption: | + Consol and call option exercise two comparison + name: fig_ex2_prices +--- fig, ax = plt.subplots() ax.plot(s, consol_price(apm, ζ), label='consol') ax.plot(s, call_option(apm, ζ, p_s), label='call option') @@ -1141,7 +1175,14 @@ def finite_horizon_call_option(ap, ζ, p_s, k): Now let's compute the option values at `k=5` and `k=25` -```{code-cell} python3 +```{code-cell} ipython3 +--- +mystnb: + figure: + caption: | + Finite horizon call option values + name: fig_ex3_finite +--- fig, ax = plt.subplots() for k in [5, 25]: w = finite_horizon_call_option(apm, ζ, p_s, k) From 76c64b2a050b0036945d58d4e20ad5b441f75fba Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Wed, 22 Oct 2025 17:27:57 +0900 Subject: [PATCH 04/12] delete metadata cell in solutions --- lectures/markov_asset.md | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/lectures/markov_asset.md b/lectures/markov_asset.md index 90e20c315..a7e04a010 100644 --- a/lectures/markov_asset.md +++ b/lectures/markov_asset.md @@ -1082,13 +1082,6 @@ call_option(apm, ζ, p_s) Let's show the last two functions as a plot ```{code-cell} ipython3 ---- -mystnb: - figure: - caption: | - Consol and call option exercise two comparison - name: fig_ex2_prices ---- fig, ax = plt.subplots() ax.plot(s, consol_price(apm, ζ), label='consol') ax.plot(s, call_option(apm, ζ, p_s), label='call option') @@ -1176,13 +1169,6 @@ def finite_horizon_call_option(ap, ζ, p_s, k): Now let's compute the option values at `k=5` and `k=25` ```{code-cell} ipython3 ---- -mystnb: - figure: - caption: | - Finite horizon call option values - name: fig_ex3_finite ---- fig, ax = plt.subplots() for k in [5, 25]: w = finite_horizon_call_option(apm, ζ, p_s, k) From 02dfe6e50889b1fc45843b2e3c6fa91dc1e6ebac Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Mon, 27 Oct 2025 13:31:16 +0900 Subject: [PATCH 05/12] modify document link --- lectures/markov_asset.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lectures/markov_asset.md b/lectures/markov_asset.md index a7e04a010..ef6c8d3c2 100644 --- a/lectures/markov_asset.md +++ b/lectures/markov_asset.md @@ -185,7 +185,7 @@ It is useful to regard equation {eq}`lteeqs102` as a generalization of equatio Equation {eq}`lteeqs102` asserts that the covariance of the stochastic discount factor with the one period payout $d_{t+1} + p_{t+1}$ is an important determinant of the price $p_t$. -We give examples of some models of stochastic discount factors that have been proposed later in this lecture and also in a [later lecture](https://python-advanced.quantecon.org/lucas_model.html). +We give examples of some models of stochastic discount factors that have been proposed later in this lecture and also in a {doc}`later lecture`. ### The price-dividend ratio @@ -496,7 +496,7 @@ m_{t+1} = \beta \frac{u'(c_{t+1})}{u'(c_t)} where $u$ is a concave utility function and $c_t$ is time $t$ consumption of a representative consumer. -(A derivation of this expression is given in a [later lecture](https://python-advanced.quantecon.org/lucas_model.html)) +(A derivation of this expression is given in a {doc}`later lecture`) Assume the existence of an endowment that follows growth process {eq}`mass_fmce`. From 211ec24cdcea153cab421f4c96090ed8d0caeed1 Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Mon, 27 Oct 2025 16:56:50 +0900 Subject: [PATCH 06/12] Made functions more JAX-compatible --- lectures/markov_asset.md | 73 +++++++++++++++++++++++++++------------- 1 file changed, 50 insertions(+), 23 deletions(-) diff --git a/lectures/markov_asset.md b/lectures/markov_asset.md index ef6c8d3c2..93fb6d5d2 100644 --- a/lectures/markov_asset.md +++ b/lectures/markov_asset.md @@ -88,6 +88,7 @@ import quantecon as qe import jax import jax.numpy as jnp from jax.numpy.linalg import eigvals, solve +from jax.experimental import checkify from typing import NamedTuple ``` @@ -567,6 +568,20 @@ We will define a function tree_price to compute $v$ given parameters stored in the class AssetPriceModel ```{code-cell} ipython3 +class MarkovChain(NamedTuple): + """ + A class that stores the primitives of a Markov chain. + Parameters + ---------- + P : jnp.ndarray + Transition matrix + state_values : jnp.ndarray + The values associated with each state + """ + P: jnp.ndarray + state_values: jnp.ndarray + + class AssetPriceModel(NamedTuple): """ A class that stores the primitives of the asset pricing model. @@ -584,34 +599,42 @@ class AssetPriceModel(NamedTuple): n: int The number of states """ - mc: qe.MarkovChain + mc: MarkovChain g: callable β: float γ: float n: int -def create_ap_model(mc=None, g=jnp.exp, β=0.96, γ=2.0): - """Create an AssetPriceModel class""" - if mc is None: - n, ρ, σ = 25, 0.9, 0.02 - mc = qe.tauchen(n, ρ, σ) - else: - mc = mc - n = mc.P.shape[0] +def create_ap_model(g=jnp.exp, β=0.96, γ=2.0): + """Create an AssetPriceModel class using standard Markov chain.""" + n, ρ, σ = 25, 0.9, 0.02 + qe_mc = qe.tauchen(n, ρ, σ) + P = jnp.array(qe_mc.P) + state_values = jnp.array(qe_mc.state_values) + mc = MarkovChain(P=P, state_values=state_values) return AssetPriceModel(mc=mc, g=g, β=β, γ=γ, n=n) +def create_customized_ap_model(mc: MarkovChain, g=jnp.exp, β=0.96, γ=2.0): + """Create an AssetPriceModel class using a customized Markov chain.""" + n = mc.P.shape[0] + return AssetPriceModel(mc=mc, g=g, β=β, γ=γ, n=n) + + def test_stability(Q, β): - """ - Stability test for a given matrix Q. - """ - sr = np.max(np.abs(eigvals(Q))) - if not sr < 1 / β: - msg = f"Spectral radius condition failed with radius = {sr}" - raise ValueError(msg) + """Stability test for a given matrix Q.""" + sr = jnp.max(jnp.abs(eigvals(Q))) + checkify.check( + sr < 1 / β, + "Spectral radius condition failed with radius = {sr}", sr=sr + ) + return sr + +# Wrap the check function to be JIT-safe +test_stability = checkify.checkify(test_stability, errors=checkify.user_checks) def tree_price(ap): """ @@ -633,7 +656,8 @@ def tree_price(ap): J = P * ap.g(y)**(1 - γ) # Make sure that a unique solution exists - test_stability(J, β) + err, out = test_stability(J, β) + err.throw() # Compute v I = jnp.identity(ap.n) @@ -661,7 +685,7 @@ states = ap.mc.state_values fig, ax = plt.subplots() for γ in γs: - tem_ap = create_ap_model(mc=ap.mc, g=ap.g, β=ap.β, γ=γ) + tem_ap = create_customized_ap_model(mc=ap.mc, β=ap.β, γ=γ) v = tree_price(tem_ap) ax.plot(states, v, lw=2, alpha=0.6, label=rf"$\gamma = {γ}$") @@ -767,7 +791,8 @@ def consol_price(ap, ζ): M = P * ap.g(y)**(- γ) # Make sure that a unique solution exists - test_stability(M, β) + err, _ = test_stability(M, β) + err.throw() # Compute price I = jnp.identity(ap.n) @@ -879,7 +904,8 @@ def call_option(ap, ζ, p_s, ϵ=1e-7): M = P * ap.g(y)**(- γ) # Make sure that a unique consol price exists - test_stability(M, β) + err, _ = test_stability(M, β) + err.throw() # Compute option price p = consol_price(ap, ζ) @@ -887,7 +913,7 @@ def call_option(ap, ζ, p_s, ϵ=1e-7): error = ϵ + 1 def step(state): - w, error = state + w, _ = state # Maximize across columns w_new = jnp.maximum(β * M @ w, p - p_s) # Find maximal difference of each component and update @@ -1062,7 +1088,7 @@ Next, we'll create an instance of `AssetPriceModel` to feed into the functions ```{code-cell} ipython3 -apm = create_ap_model(mc=mc, g=lambda x: x, β=β, γ=γ) +apm = create_customized_ap_model(mc=mc, g=lambda x: x, β=β, γ=γ) ``` Now we just need to call the relevant functions on the data: @@ -1152,7 +1178,8 @@ def finite_horizon_call_option(ap, ζ, p_s, k): M = P * ap.g(y)**(- γ) # Make sure that a unique solution exists - test_stability(M, β) + err, _ = test_stability(M, β) + err.throw() # Compute option price p = consol_price(ap, ζ) From 2cfda1acaa1e9db487b20dc606789632ab1c9cad Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Wed, 29 Oct 2025 17:57:23 +0900 Subject: [PATCH 07/12] jit computation functions --- lectures/markov_asset.md | 149 ++++++++++++++++++++++----------------- 1 file changed, 84 insertions(+), 65 deletions(-) diff --git a/lectures/markov_asset.md b/lectures/markov_asset.md index 93fb6d5d2..b8b533d98 100644 --- a/lectures/markov_asset.md +++ b/lectures/markov_asset.md @@ -63,7 +63,7 @@ An asset is a claim on one or more future payoffs. The spot price of an asset depends primarily on -* the anticipated income stream +* the anticipated income stream * attitudes about risk * rates of time preference @@ -75,7 +75,7 @@ We also look at creating and pricing *derivative* assets that repackage income s Key tools for the lecture are -* Markov processses +* Markov processes * formulas for predicting future values of functions of a Markov state * a formula for predicting the discounted sum of future values of a Markov state @@ -83,7 +83,6 @@ Let's start with some imports: ```{code-cell} ipython import matplotlib.pyplot as plt -import numpy as np import quantecon as qe import jax import jax.numpy as jnp @@ -151,7 +150,7 @@ for some **stochastic discount factor** $m_{t+1}$. Here the fixed discount factor $\beta$ in {eq}`rnapex` has been replaced by the random variable $m_{t+1}$. -How anticipated future payoffs are evaluated now depends on statistical properties of $m_{t+1}$. +How anticipated future payoffs are evaluated now depends on statistical properties of $m_{t+1}$. The stochastic discount factor can be specified to capture the idea that assets that tend to have good payoffs in bad states of the world are valued more highly than other assets whose payoffs don't behave that way. @@ -177,12 +176,12 @@ If we apply this definition to the asset pricing equation {eq}`lteeqs0` we obtai p_t = {\mathbb E}_t m_{t+1} {\mathbb E}_t (d_{t+1} + p_{t+1}) + {\rm cov}_t (m_{t+1}, d_{t+1}+ p_{t+1}) ``` -It is useful to regard equation {eq}`lteeqs102` as a generalization of equation {eq}`rnapex` +It is useful to regard equation {eq}`lteeqs102` as a generalization of equation {eq}`rnapex` -* In equation {eq}`rnapex`, the stochastic discount factor $m_{t+1} = \beta$, a constant. +* In equation {eq}`rnapex`, the stochastic discount factor $m_{t+1} = \beta$, a constant. * In equation {eq}`rnapex`, the covariance term ${\rm cov}_t (m_{t+1}, d_{t+1}+ p_{t+1})$ is zero because $m_{t+1} = \beta$. * In equation {eq}`rnapex`, ${\mathbb E}_t m_{t+1}$ can be interpreted as the reciprocal of the one-period risk-free gross interest rate. -* When $m_{t+1}$ covaries more negatively with the payout $p_{t+1} + d_{t+1}$, the price of the asset is lower. +* When $m_{t+1}$ covaries more negatively with the payout $p_{t+1} + d_{t+1}$, the price of the asset is lower. Equation {eq}`lteeqs102` asserts that the covariance of the stochastic discount factor with the one period payout $d_{t+1} + p_{t+1}$ is an important determinant of the price $p_t$. @@ -213,9 +212,9 @@ The answer to this question depends on 1. the process we specify for dividends 1. the stochastic discount factor and how it correlates with dividends -For now we'll study the risk-neutral case in which the stochastic discount factor is constant. +For now we'll study the risk-neutral case in which the stochastic discount factor is constant. -We'll focus on how an asset price depends on a dividend process. +We'll focus on how an asset price depends on a dividend process. ### Example 1: constant dividends @@ -340,7 +339,7 @@ x_series = mc.simulate(sim_length, init=jnp.median(mc.state_values)) g_series = jnp.exp(x_series) d_series = jnp.cumprod(g_series) # Assumes d_0 = 1 -series = [x_series, g_series, d_series, np.log(d_series)] +series = [x_series, g_series, d_series, jnp.log(d_series)] labels = ['$X_t$', '$g_t$', '$d_t$', r'$\log \, d_t$'] fig, axes = plt.subplots(2, 2) @@ -564,8 +563,8 @@ Assuming that the spectral radius of $J$ is strictly less than $\beta^{-1}$, thi v = (I - \beta J)^{-1} \beta J {\mathbb 1} ``` -We will define a function tree_price to compute $v$ given parameters stored in -the class AssetPriceModel +We will define a function `tree_price` to compute $v$ given parameters stored in +the class `AssetPriceModel` ```{code-cell} ipython3 class MarkovChain(NamedTuple): @@ -578,8 +577,8 @@ class MarkovChain(NamedTuple): state_values : jnp.ndarray The values associated with each state """ - P: jnp.ndarray - state_values: jnp.ndarray + P: jax.Array + state_values: jax.Array class AssetPriceModel(NamedTuple): @@ -590,20 +589,17 @@ class AssetPriceModel(NamedTuple): ---------- mc : MarkovChain Contains the transition matrix and set of state values - g : callable - The function mapping states to growth rates + G : jax.Array + The vector form of the function mapping states to growth rates β : float Discount factor γ : float Coefficient of risk aversion - n: int - The number of states """ mc: MarkovChain - g: callable + G: jax.Array β: float γ: float - n: int def create_ap_model(g=jnp.exp, β=0.96, γ=2.0): @@ -612,15 +608,16 @@ def create_ap_model(g=jnp.exp, β=0.96, γ=2.0): qe_mc = qe.tauchen(n, ρ, σ) P = jnp.array(qe_mc.P) state_values = jnp.array(qe_mc.state_values) + G = g(state_values) mc = MarkovChain(P=P, state_values=state_values) - return AssetPriceModel(mc=mc, g=g, β=β, γ=γ, n=n) + return AssetPriceModel(mc=mc, G=G, β=β, γ=γ) def create_customized_ap_model(mc: MarkovChain, g=jnp.exp, β=0.96, γ=2.0): """Create an AssetPriceModel class using a customized Markov chain.""" - n = mc.P.shape[0] - return AssetPriceModel(mc=mc, g=g, β=β, γ=γ, n=n) + G = g(mc.state_values) + return AssetPriceModel(mc=mc, G=G, β=β, γ=γ) def test_stability(Q, β): @@ -633,9 +630,6 @@ def test_stability(Q, β): return sr -# Wrap the check function to be JIT-safe -test_stability = checkify.checkify(test_stability, errors=checkify.user_checks) - def tree_price(ap): """ Computes the price-dividend ratio of the Lucas tree. @@ -649,22 +643,24 @@ def tree_price(ap): ------- v : array_like(float) Lucas tree price-dividend ratio - """ # Simplify names, set up matrices - β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values - J = P * ap.g(y)**(1 - γ) + β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G + J = P * G**(1 - γ) # Make sure that a unique solution exists - err, out = test_stability(J, β) - err.throw() + test_stability(J, β) # Compute v - I = jnp.identity(ap.n) - Ones = jnp.ones(ap.n) + n = J.shape[0] + I = jnp.identity(n) + Ones = jnp.ones(n) v = solve(I - β * J, β * J @ Ones) return v + +# Wrap the function to be safely jitted +tree_price_jit = jax.jit(checkify.checkify(tree_price)) ``` Here's a plot of $v$ as a function of the state for several values of $\gamma$, @@ -685,8 +681,12 @@ states = ap.mc.state_values fig, ax = plt.subplots() for γ in γs: - tem_ap = create_customized_ap_model(mc=ap.mc, β=ap.β, γ=γ) - v = tree_price(tem_ap) + tem_ap = create_customized_ap_model(ap.mc, γ=γ) + # checkify returns a tuple + # err indicates whether errors happened + err, v = tree_price_jit(tem_ap) + # Stop if errors raised + err.throw() ax.plot(states, v, lw=2, alpha=0.6, label=rf"$\gamma = {γ}$") ax.set_ylabel("price-dividend ratio") @@ -766,7 +766,7 @@ yields the solution p = (I - \beta M)^{-1} \beta M \zeta {\mathbb 1} ``` -The above is implemented in the function consol_price. +The above is implemented in the function `consol_price`. ```{code-cell} ipython3 def consol_price(ap, ζ): @@ -787,19 +787,22 @@ def consol_price(ap, ζ): Console bond prices """ # Simplify names, set up matrices - β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values - M = P * ap.g(y)**(- γ) + β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G + M = P * G**(- γ) # Make sure that a unique solution exists - err, _ = test_stability(M, β) - err.throw() + test_stability(M, β) # Compute price - I = jnp.identity(ap.n) - Ones = jnp.ones(ap.n) + n = M.shape[0] + I = jnp.identity(n) + Ones = jnp.ones(n) p = solve(I - β * M, β * ζ * M @ Ones) return p + +# Wrap the function to be safely jitted +consol_price_jit = jax.jit(checkify.checkify(consol_price)) ``` ### Pricing an Option to Purchase the Consol @@ -870,9 +873,9 @@ T w = \max \{ \beta M w,\; p - p_S {\mathbb 1} \} $$ -Start at some initial $w$ and iterate with $T$ to convergence . +Start at some initial $w$ and iterate with $T$ to convergence. -We can find the solution with the following function call_option +We can find the solution with the following function `call_option` ```{code-cell} ipython3 def call_option(ap, ζ, p_s, ϵ=1e-7): @@ -900,16 +903,17 @@ def call_option(ap, ζ, p_s, ϵ=1e-7): """ # Simplify names, set up matrices - β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values - M = P * ap.g(y)**(- γ) + β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G + M = P * G**(- γ) # Make sure that a unique consol price exists - err, _ = test_stability(M, β) - err.throw() + test_stability(M, β) # Compute option price p = consol_price(ap, ζ) - w = jnp.zeros(ap.n) + err.throw() + n = M.shape[0] + w = jnp.zeros(n) error = ϵ + 1 def step(state): @@ -928,6 +932,8 @@ def call_option(ap, ζ, p_s, ϵ=1e-7): final_w, _ = jax.lax.while_loop(cond, step, (w, error)) return final_w + +call_option_jit = jax.jit(checkify.checkify(call_option)) ``` Here's a plot of $w$ compared to the consol price when $P_S = 40$ @@ -945,8 +951,10 @@ ap = create_ap_model(β=0.9) strike_price = 40 x = ap.mc.state_values -p = consol_price(ap, ζ) -w = call_option(ap, ζ, strike_price) +err, p = consol_price_jit(ap, ζ) +err.throw() +err, w = call_option_jit(ap, ζ, strike_price) +err.throw() fig, ax = plt.subplots() ax.plot(x, p, 'b-', lw=2, label='consol price') @@ -1046,7 +1054,7 @@ P = P.at[jnp.arange(n), jnp.arange(n)].set( P[jnp.arange(n), jnp.arange(n)] + 1 - P.sum(1) ) # State values of the Markov chain -s = np.array([0.95, 0.975, 1.0, 1.025, 1.05]) +s = jnp.array([0.95, 0.975, 1.0, 1.025, 1.05]) γ = 2.0 β = 0.94 ``` @@ -1076,7 +1084,7 @@ P = P.at[jnp.arange(n), jnp.arange(n)].set( P[jnp.arange(n), jnp.arange(n)] + 1 - P.sum(1) ) s = jnp.array([0.95, 0.975, 1.0, 1.025, 1.05]) # State values -mc = qe.MarkovChain(P, state_values=s) +mc = MarkovChain(P=P, state_values=s) γ = 2.0 β = 0.94 @@ -1094,23 +1102,29 @@ apm = create_customized_ap_model(mc=mc, g=lambda x: x, β=β, γ=γ) Now we just need to call the relevant functions on the data: ```{code-cell} ipython3 -tree_price(apm) +err, v = tree_price_jit(apm) +err.throw() +print(v) ``` ```{code-cell} ipython3 -consol_price(apm, ζ) +err, p = consol_price_jit(apm, ζ) +err.throw() +print(p) ``` ```{code-cell} ipython3 -call_option(apm, ζ, p_s) +err, w = call_option_jit(apm, ζ, p_s) +err.throw() +print(w) ``` Let's show the last two functions as a plot ```{code-cell} ipython3 fig, ax = plt.subplots() -ax.plot(s, consol_price(apm, ζ), label='consol') -ax.plot(s, call_option(apm, ζ, p_s), label='call option') +ax.plot(s, p, label='consol') +ax.plot(s, w, label='call option') ax.legend() plt.show() ``` @@ -1169,28 +1183,32 @@ Is one higher than the other? Can you give intuition? Here's a suitable function: ```{code-cell} ipython3 -def finite_horizon_call_option(ap, ζ, p_s, k): +def finite_call_option(ap, ζ, p_s, k): """ Computes k period option value. """ # Simplify names, set up matrices - β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values - M = P * ap.g(y)**(- γ) + β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G + M = P * G**(- γ) # Make sure that a unique solution exists - err, _ = test_stability(M, β) - err.throw() + test_stability(M, β) # Compute option price p = consol_price(ap, ζ) + n = M.shape[0] def step(i, w): # Maximize across columns w = jnp.maximum(β * M @ w, p - p_s) return w - w = jax.lax.fori_loop(0, k, step, jnp.zeros(ap.n)) + w = jax.lax.fori_loop(0, k, step, jnp.zeros(n)) return w + +finite_call_option_jit = jax.jit( + checkify.checkify(finite_call_option) + ) ``` Now let's compute the option values at `k=5` and `k=25` @@ -1198,7 +1216,8 @@ Now let's compute the option values at `k=5` and `k=25` ```{code-cell} ipython3 fig, ax = plt.subplots() for k in [5, 25]: - w = finite_horizon_call_option(apm, ζ, p_s, k) + err, w = finite_call_option_jit(apm, ζ, p_s, k) + err.throw() ax.plot(s, w, label=rf'$k = {k}$') ax.legend() plt.show() From 5956102848d0cb6b5ad03296412e278d339dc4be Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Fri, 6 Feb 2026 15:08:05 +0800 Subject: [PATCH 08/12] Add a ipynb file --- lectures/markov_asset.ipynb | 1589 +++++++++++++++++++++++++++++++++++ 1 file changed, 1589 insertions(+) create mode 100644 lectures/markov_asset.ipynb diff --git a/lectures/markov_asset.ipynb b/lectures/markov_asset.ipynb new file mode 100644 index 000000000..70299125b --- /dev/null +++ b/lectures/markov_asset.ipynb @@ -0,0 +1,1589 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c264c82a", + "metadata": {}, + "source": [ + "(mass)=\n", + "```{raw} jupyter\n", + "
\n", + " \n", + " \"QuantEcon\"\n", + " \n", + "
\n", + "```\n", + "\n", + "# {index}`Asset Pricing: Finite State Models `\n", + "\n", + "```{index} single: Models; Markov Asset Pricing\n", + "```\n", + "\n", + "```{contents} Contents\n", + ":depth: 2\n", + "```\n", + "\n", + "```{epigraph}\n", + "\"A little knowledge of geometric series goes a long way\" -- Robert E. Lucas, Jr.\n", + "```\n", + "\n", + "```{epigraph}\n", + "\"Asset pricing is all about covariances\" -- Lars Peter Hansen\n", + "```\n", + "\n", + "```{admonition} GPU\n", + ":class: warning\n", + "\n", + "This lecture is accelerated via [hardware](status:machine-details) that has access to a GPU and JAX for GPU programming.\n", + "\n", + "Free GPUs are available on Google Colab. To use this option, please click on the play icon top right, select Colab, and set the runtime environment to include a GPU.\n", + "\n", + "Alternatively, if you have your own GPU, you can follow the [instructions](https://github.com/google/jax) for installing JAX with GPU support. If you would like to install JAX running on the `cpu` only you can use `pip install jax[cpu]`\n", + "```\n", + "\n", + "In addition to what's in Anaconda, this lecture will need the following libraries:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c69339f7", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: quantecon in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (0.10.1)\n", + "Requirement already satisfied: numba>=0.49.0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (0.61.0)\n", + "Requirement already satisfied: numpy>=1.17.0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (2.1.3)\n", + "Requirement already satisfied: requests in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (2.32.3)\n", + "Requirement already satisfied: scipy>=1.5.0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (1.15.3)\n", + "Requirement already satisfied: sympy in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (1.13.3)\n", + "Requirement already satisfied: llvmlite<0.45,>=0.44.0dev0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from numba>=0.49.0->quantecon) (0.44.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from requests->quantecon) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from requests->quantecon) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from requests->quantecon) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from requests->quantecon) (2025.4.26)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from sympy->quantecon) (1.3.0)\n" + ] + } + ], + "source": [ + "!pip install quantecon" + ] + }, + { + "cell_type": "markdown", + "id": "60bb52a4", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "```{index} single: Markov Asset Pricing; Overview\n", + "```\n", + "\n", + "An asset is a claim on one or more future payoffs.\n", + "\n", + "The spot price of an asset depends primarily on\n", + "\n", + "* the anticipated income stream\n", + "* attitudes about risk\n", + "* rates of time preference\n", + "\n", + "In this lecture, we consider some standard pricing models and dividend stream specifications.\n", + "\n", + "We study how prices and dividend-price ratios respond in these different scenarios.\n", + "\n", + "We also look at creating and pricing *derivative* assets that repackage income streams.\n", + "\n", + "Key tools for the lecture are\n", + "\n", + "* Markov processes\n", + "* formulas for predicting future values of functions of a Markov state\n", + "* a formula for predicting the discounted sum of future values of a Markov state\n", + "\n", + "Let's start with some imports:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ce7fce98", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import quantecon as qe\n", + "import jax\n", + "import jax.numpy as jnp\n", + "from jax.numpy.linalg import eigvals, solve\n", + "from jax.experimental import checkify\n", + "from typing import NamedTuple" + ] + }, + { + "cell_type": "markdown", + "id": "66b8e8b0", + "metadata": {}, + "source": [ + "## {index}`Pricing Models `\n", + "\n", + "```{index} single: Models; Pricing\n", + "```\n", + "\n", + "Let $\\{d_t\\}_{t \\geq 0}$ be a stream of dividends\n", + "\n", + "* A time-$t$ **cum-dividend** asset is a claim to the stream $d_t, d_{t+1}, \\ldots$.\n", + "* A time-$t$ **ex-dividend** asset is a claim to the stream $d_{t+1}, d_{t+2}, \\ldots$.\n", + "\n", + "Let's look at some equations that we expect to hold for prices of assets under ex-dividend contracts\n", + "(we will consider cum-dividend pricing in the exercises).\n", + "\n", + "### Risk-neutral pricing\n", + "\n", + "```{index} single: Pricing Models; Risk-Neutral\n", + "```\n", + "\n", + "Our first scenario is risk-neutral pricing.\n", + "\n", + "Let $\\beta = 1/(1+\\rho)$ be an intertemporal discount **factor**, where\n", + "$\\rho$ is the **rate** at which agents discount the future.\n", + "\n", + "The basic risk-neutral asset pricing equation for pricing one unit of an ex-dividend asset is\n", + "\n", + "(mass_pra)=\n", + "```{math}\n", + ":label: rnapex\n", + "\n", + "p_t = \\beta {\\mathbb E}_t [d_{t+1} + p_{t+1}]\n", + "```\n", + "\n", + "This is a simple \"cost equals expected benefit\" relationship.\n", + "\n", + "Here ${\\mathbb E}_t [y]$ denotes the best forecast of $y$, conditioned on information available at time $t$.\n", + "\n", + "More precisely, ${\\mathbb E}_t [y]$ is the mathematical expectation of $y$ conditional on information available at time $t$.\n", + "\n", + "### Pricing with random discount factor\n", + "\n", + "```{index} single: Pricing Models; Risk Aversion\n", + "```\n", + "\n", + "What happens if for some reason traders discount payouts differently depending on the state of the world?\n", + "\n", + "Michael Harrison and David Kreps {cite}`HarrisonKreps1979` and Lars Peter Hansen\n", + "and Scott Richard {cite}`HansenRichard1987` showed that in quite general\n", + "settings the price of an ex-dividend asset obeys\n", + "\n", + "```{math}\n", + ":label: lteeqs0\n", + "\n", + "p_t = {\\mathbb E}_t \\left[ m_{t+1} ( d_{t+1} + p_{t+1} ) \\right]\n", + "```\n", + "\n", + "for some **stochastic discount factor** $m_{t+1}$.\n", + "\n", + "Here the fixed discount factor $\\beta$ in {eq}`rnapex` has been replaced by the random variable $m_{t+1}$.\n", + "\n", + "How anticipated future payoffs are evaluated now depends on statistical properties of $m_{t+1}$.\n", + "\n", + "The stochastic discount factor can be specified to capture the idea that assets that tend to have good payoffs in bad states of the world are valued more highly than other assets whose payoffs don't behave that way.\n", + "\n", + "This is because such assets pay well when funds are more urgently wanted.\n", + "\n", + "We give examples of how the stochastic discount factor has been modeled below.\n", + "\n", + "### Asset pricing and covariances\n", + "\n", + "Recall that, from the definition of a conditional covariance ${\\rm cov}_t (x_{t+1}, y_{t+1})$, we have\n", + "\n", + "```{math}\n", + ":label: lteeqs101\n", + "\n", + "{\\mathbb E}_t (x_{t+1} y_{t+1}) = {\\rm cov}_t (x_{t+1}, y_{t+1}) + {\\mathbb E}_t x_{t+1} {\\mathbb E}_t y_{t+1}\n", + "```\n", + "\n", + "If we apply this definition to the asset pricing equation {eq}`lteeqs0` we obtain\n", + "\n", + "```{math}\n", + ":label: lteeqs102\n", + "\n", + "p_t = {\\mathbb E}_t m_{t+1} {\\mathbb E}_t (d_{t+1} + p_{t+1}) + {\\rm cov}_t (m_{t+1}, d_{t+1}+ p_{t+1})\n", + "```\n", + "\n", + "It is useful to regard equation {eq}`lteeqs102` as a generalization of equation {eq}`rnapex`\n", + "\n", + "* In equation {eq}`rnapex`, the stochastic discount factor $m_{t+1} = \\beta$, a constant.\n", + "* In equation {eq}`rnapex`, the covariance term ${\\rm cov}_t (m_{t+1}, d_{t+1}+ p_{t+1})$ is zero because $m_{t+1} = \\beta$.\n", + "* In equation {eq}`rnapex`, ${\\mathbb E}_t m_{t+1}$ can be interpreted as the reciprocal of the one-period risk-free gross interest rate.\n", + "* When $m_{t+1}$ covaries more negatively with the payout $p_{t+1} + d_{t+1}$, the price of the asset is lower.\n", + "\n", + "Equation {eq}`lteeqs102` asserts that the covariance of the stochastic discount factor with the one period payout $d_{t+1} + p_{t+1}$ is an important determinant of the price $p_t$.\n", + "\n", + "We give examples of some models of stochastic discount factors that have been proposed later in this lecture and also in a {doc}`later lecture`.\n", + "\n", + "### The price-dividend ratio\n", + "\n", + "Aside from prices, another quantity of interest is the **price-dividend ratio** $v_t := p_t / d_t$.\n", + "\n", + "Let's write down an expression that this ratio should satisfy.\n", + "\n", + "We can divide both sides of {eq}`lteeqs0` by $d_t$ to get\n", + "\n", + "```{math}\n", + ":label: pdex\n", + "\n", + "v_t = {\\mathbb E}_t \\left[ m_{t+1} \\frac{d_{t+1}}{d_t} (1 + v_{t+1}) \\right]\n", + "```\n", + "\n", + "Below we'll discuss the implication of this equation.\n", + "\n", + "## Prices in the risk-neutral case\n", + "\n", + "What can we say about price dynamics on the basis of the models described above?\n", + "\n", + "The answer to this question depends on\n", + "\n", + "1. the process we specify for dividends\n", + "1. the stochastic discount factor and how it correlates with dividends\n", + "\n", + "For now we'll study the risk-neutral case in which the stochastic discount factor is constant.\n", + "\n", + "We'll focus on how an asset price depends on a dividend process.\n", + "\n", + "### Example 1: constant dividends\n", + "\n", + "The simplest case is risk-neutral price of a constant, non-random dividend stream $d_t = d > 0$.\n", + "\n", + "Removing the expectation from {eq}`rnapex` and iterating forward gives\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + " p_t & = \\beta (d + p_{t+1})\n", + " \\\\\n", + " & = \\beta (d + \\beta(d + p_{t+2}))\n", + " \\\\\n", + " & \\quad \\vdots\n", + " \\\\\n", + " & = \\beta (d + \\beta d + \\beta^2 d + \\cdots + \\beta^{k-2} d + \\beta^{k-1} p_{t+k})\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "If $\\lim_{k \\rightarrow + \\infty} \\beta^{k-1} p_{t+k} = 0$, this sequence converges to\n", + "\n", + "```{math}\n", + ":label: ddet\n", + "\n", + "\\bar p := \\frac{\\beta d}{1-\\beta}\n", + "```\n", + "\n", + "This is the equilibrium price in the constant dividend case.\n", + "\n", + "Indeed, simple algebra shows that setting $p_t = \\bar p$ for all $t$\n", + "satisfies the difference equation $p_t = \\beta (d + p_{t+1})$.\n", + "\n", + "### Example 2: dividends with deterministic growth paths\n", + "\n", + "Consider a growing, non-random dividend process $d_{t+1} = g d_t$\n", + "where $0 < g \\beta < 1$.\n", + "\n", + "While prices are not usually constant when dividends grow over time, a price\n", + "dividend-ratio can be.\n", + "\n", + "If we guess this, substituting $v_t = v$ into {eq}`pdex` as well as our\n", + "other assumptions, we get $v = \\beta g (1 + v)$.\n", + "\n", + "Since $\\beta g < 1$, we have a unique positive solution:\n", + "\n", + "$$\n", + "v = \\frac{\\beta g}{1 - \\beta g }\n", + "$$\n", + "\n", + "The price is then\n", + "\n", + "$$\n", + "p_t = \\frac{\\beta g}{1 - \\beta g } d_t\n", + "$$\n", + "\n", + "If, in this example, we take $g = 1+\\kappa$ and let\n", + "$\\rho := 1/\\beta - 1$, then the price becomes\n", + "\n", + "$$\n", + "p_t = \\frac{1 + \\kappa}{ \\rho - \\kappa} d_t\n", + "$$\n", + "\n", + "This is called the *Gordon formula*.\n", + "\n", + "(mass_mg)=\n", + "### Example 3: Markov growth, risk-neutral pricing\n", + "\n", + "Next, we consider a dividend process\n", + "\n", + "```{math}\n", + ":label: mass_fmce\n", + "\n", + "d_{t+1} = g_{t+1} d_t\n", + "```\n", + "\n", + "The stochastic growth factor $\\{g_t\\}$ is given by\n", + "\n", + "$$\n", + "g_t = g(X_t), \\quad t = 1, 2, \\ldots\n", + "$$\n", + "\n", + "where\n", + "\n", + "1. $\\{X_t\\}$ is a finite Markov chain with state space $S$ and\n", + " transition probabilities\n", + "\n", + " $$\n", + " P(x, y) := \\mathbb P \\{ X_{t+1} = y \\,|\\, X_t = x \\}\n", + " \\qquad (x, y \\in S)\n", + " $$\n", + "\n", + "1. $g$ is a given function on $S$ taking nonnegative values\n", + "\n", + "You can think of\n", + "\n", + "* $S$ as $n$ possible \"states of the world\" and $X_t$ as the\n", + " current state.\n", + "* $g$ as a function that maps a given state $X_t$ into a growth of dividends\n", + " factor $g_t = g(X_t)$.\n", + "* $\\ln g_t = \\ln (d_{t+1} / d_t)$ is the growth rate of dividends.\n", + "\n", + "(For a refresher on notation and theory for finite Markov chains see {doc}`this lecture `)\n", + "\n", + "The next figure shows a simulation, where\n", + "\n", + "* $\\{X_t\\}$ evolves as a discretized AR1 process produced using {ref}`Tauchen's method `.\n", + "* $g_t = \\exp(X_t)$, so that $\\ln g_t = X_t$ is the growth rate." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "75117970", + "metadata": { + "mystnb": { + "figure": { + "caption": "State, growth, and dividend simulation\n", + "name": "fig_markov_sim" + } + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n = 7\n", + "mc = qe.tauchen(n, 0.96, 0.25)\n", + "sim_length = 80\n", + "\n", + "x_series = mc.simulate(sim_length, init=jnp.median(mc.state_values))\n", + "g_series = jnp.exp(x_series)\n", + "d_series = jnp.cumprod(g_series) # Assumes d_0 = 1\n", + "\n", + "series = [x_series, g_series, d_series, jnp.log(d_series)]\n", + "labels = ['$X_t$', '$g_t$', '$d_t$', r'$\\log \\, d_t$']\n", + "\n", + "fig, axes = plt.subplots(2, 2)\n", + "for ax, s, label in zip(axes.flatten(), series, labels):\n", + " ax.plot(s, 'b-', lw=2, label=label)\n", + " ax.legend(loc='upper left', frameon=False)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5698f7fc", + "metadata": {}, + "source": [ + "#### Pricing formula\n", + "\n", + "To obtain asset prices in this setting, let's adapt our analysis from the case of deterministic growth.\n", + "\n", + "In that case, we found that $v$ is constant.\n", + "\n", + "This encourages us to guess that, in the current case, $v_t$ is a fixed function of the state $X_t$.\n", + "\n", + "We seek a function $v$ such that the price-dividend ratio satisfies $v_t = v(X_t)$.\n", + "\n", + "We can substitute this guess into {eq}`pdex` to get\n", + "\n", + "$$\n", + "v(X_t) = \\beta {\\mathbb E}_t [ g(X_{t+1}) (1 + v(X_{t+1})) ]\n", + "$$\n", + "\n", + "If we condition on $X_t = x$, this becomes\n", + "\n", + "$$\n", + "v(x) = \\beta \\sum_{y \\in S} g(y) (1 + v(y)) P(x, y)\n", + "$$\n", + "\n", + "or\n", + "\n", + "```{math}\n", + ":label: pstack\n", + "\n", + "v(x) = \\beta \\sum_{y \\in S} K(x, y) (1 + v(y))\n", + "\\quad \\text{where} \\quad\n", + "K(x, y) := g(y) P(x, y)\n", + "```\n", + "\n", + "Suppose that there are $n$ possible states $x_1, \\ldots, x_n$.\n", + "\n", + "We can then think of {eq}`pstack` as $n$ stacked equations, one for each state, and write it in matrix form as\n", + "\n", + "```{math}\n", + ":label: vcumrn\n", + "\n", + "v = \\beta K (\\mathbb 1 + v)\n", + "```\n", + "\n", + "Here\n", + "\n", + "* $v$ is understood to be the column vector $(v(x_1), \\ldots, v(x_n))'$.\n", + "* $K$ is the matrix $(K(x_i, x_j))_{1 \\leq i, j \\leq n}$.\n", + "* ${\\mathbb 1}$ is a column vector of ones.\n", + "\n", + "When does equation {eq}`vcumrn` have a unique solution?\n", + "\n", + "From the {ref}`Neumann series lemma ` and Gelfand's formula, equation {eq}`vcumrn` has a unique solution when $\\beta K$ has spectral radius strictly less than one.\n", + "\n", + "Thus, we require that the eigenvalues of $K$ be strictly less than $\\beta^{-1}$ in modulus.\n", + "\n", + "The solution is then\n", + "\n", + "```{math}\n", + ":label: rned\n", + "\n", + "v = (I - \\beta K)^{-1} \\beta K{\\mathbb 1}\n", + "```\n", + "\n", + "### Code\n", + "\n", + "Let's calculate and plot the price-dividend ratio at some parameters.\n", + "\n", + "As before, we'll generate $\\{X_t\\}$ as a {ref}`discretized AR1 process ` and set $g_t = \\exp(X_t)$.\n", + "\n", + "Here's the code, including a test of the spectral radius condition" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6c41daf4", + "metadata": { + "mystnb": { + "figure": { + "caption": "Price-dividend ratio risk-neutral case\n", + "name": "fig_pdv_neutral" + } + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n = 25 # Size of state space\n", + "β = 0.9\n", + "mc = qe.tauchen(n, 0.96, 0.02)\n", + "\n", + "K = mc.P * jnp.exp(mc.state_values)\n", + "\n", + "warning_message = \"Spectral radius condition fails\"\n", + "assert jnp.max(jnp.abs(eigvals(K))) < 1 / β, warning_message\n", + "\n", + "I = jnp.identity(n)\n", + "v = solve(I - β * K, β * K @ jnp.ones(n))\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(mc.state_values, v, 'g-o', lw=2, alpha=0.7, label='$v$')\n", + "ax.set_ylabel(\"price-dividend ratio\")\n", + "ax.set_xlabel(\"state\")\n", + "ax.legend(loc='upper left')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ded89da8", + "metadata": {}, + "source": [ + "Why does the price-dividend ratio increase with the state?\n", + "\n", + "The reason is that this Markov process is positively correlated, so high\n", + "current states suggest high future states.\n", + "\n", + "Moreover, dividend growth is increasing in the state.\n", + "\n", + "The anticipation of high future dividend growth leads to a high price-dividend ratio.\n", + "\n", + "## Risk Aversion and Asset Prices\n", + "\n", + "Now let's turn to the case where agents are risk averse.\n", + "\n", + "We'll price several distinct assets, including\n", + "\n", + "* An endowment stream\n", + "* A consol (a type of bond issued by the UK government in the 19th century)\n", + "* Call options on a consol\n", + "\n", + "### Pricing a Lucas tree\n", + "\n", + "```{index} single: Finite Markov Asset Pricing; Lucas Tree\n", + "```\n", + "\n", + "Let's start with a version of the celebrated asset pricing model of Robert E. Lucas, Jr. {cite}`Lucas1978`.\n", + "\n", + "Lucas considered an abstract pure exchange economy with these features:\n", + "\n", + "* a single non-storable consumption good\n", + "* a Markov process that governs the total amount of the consumption good available each period\n", + "* a single *tree* that each period yields *fruit* that equals the total amount of consumption available to the economy\n", + "* a competitive market in *shares* in the tree that entitles their owners to corresponding shares of the *dividend* stream, i.e., the *fruit* stream, yielded by the tree\n", + "\n", + "* a representative consumer who in a competitive equilibrium\n", + "\n", + " * consumes the economy's entire endowment each period\n", + " * owns 100 percent of the shares in the tree\n", + "\n", + "As in {cite}`Lucas1978`, we suppose that the stochastic discount factor takes the form\n", + "\n", + "```{math}\n", + ":label: lucsdf\n", + "\n", + "m_{t+1} = \\beta \\frac{u'(c_{t+1})}{u'(c_t)}\n", + "```\n", + "\n", + "where $u$ is a concave utility function and $c_t$ is time $t$ consumption of a representative consumer.\n", + "\n", + "(A derivation of this expression is given in a {doc}`later lecture`)\n", + "\n", + "Assume the existence of an endowment that follows growth process {eq}`mass_fmce`.\n", + "\n", + "The asset being priced is a claim on the endowment process, i.e., the *Lucas tree* described above.\n", + "\n", + "Following {cite}`Lucas1978`, we suppose that in equilibrium the representative consumer's consumption equals the aggregate endowment, so that $d_t = c_t$ for all $t$.\n", + "\n", + "For utility, we'll assume the **constant relative risk aversion** (CRRA)\n", + "specification\n", + "\n", + "```{math}\n", + ":label: eqCRRA\n", + "\n", + "u(c) = \\frac{c^{1-\\gamma}}{1 - \\gamma} \\ {\\rm with} \\ \\gamma > 0\n", + "```\n", + "\n", + "When $\\gamma =1$ we let $u(c) = \\ln c$.\n", + "\n", + "Inserting the CRRA specification into {eq}`lucsdf` and using $c_t = d_t$ gives\n", + "\n", + "```{math}\n", + ":label: lucsdf2\n", + "\n", + "m_{t+1}\n", + "= \\beta \\left(\\frac{c_{t+1}}{c_t}\\right)^{-\\gamma}\n", + "= \\beta g_{t+1}^{-\\gamma}\n", + "```\n", + "\n", + "Substituting this into {eq}`pdex` gives the price-dividend ratio\n", + "formula\n", + "\n", + "$$\n", + "v(X_t)\n", + "= \\beta {\\mathbb E}_t\n", + "\\left[\n", + " g(X_{t+1})^{1-\\gamma} (1 + v(X_{t+1}) )\n", + "\\right]\n", + "$$ (eq:neweqn101)\n", + "\n", + "Conditioning on $X_t = x$, we can write this as\n", + "\n", + "$$\n", + "v(x)\n", + "= \\beta \\sum_{y \\in S} g(y)^{1-\\gamma} (1 + v(y) ) P(x, y)\n", + "$$\n", + "\n", + "If we let\n", + "\n", + "$$\n", + "J(x, y) := g(y)^{1-\\gamma} P(x, y)\n", + "$$\n", + "\n", + "then we can rewrite equation {eq}`eq:neweqn101` in vector form as\n", + "\n", + "$$\n", + "v = \\beta J ({\\mathbb 1} + v )\n", + "$$\n", + "\n", + "Assuming that the spectral radius of $J$ is strictly less than $\\beta^{-1}$, this equation has the unique solution\n", + "\n", + "```{math}\n", + ":label: resolvent2\n", + "\n", + "v = (I - \\beta J)^{-1} \\beta J {\\mathbb 1}\n", + "```\n", + "\n", + "We will define a function `tree_price` to compute $v$ given parameters stored in\n", + "the class `AssetPriceModel`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b7bcf31f", + "metadata": {}, + "outputs": [], + "source": [ + "class MarkovChain(NamedTuple):\n", + " \"\"\"\n", + " A class that stores the primitives of a Markov chain.\n", + " Parameters\n", + " ----------\n", + " P : jnp.ndarray\n", + " Transition matrix\n", + " state_values : jnp.ndarray\n", + " The values associated with each state\n", + " \"\"\"\n", + " P: jax.Array\n", + " state_values: jax.Array\n", + "\n", + "\n", + "class AssetPriceModel(NamedTuple):\n", + " \"\"\"\n", + " A class that stores the primitives of the asset pricing model.\n", + "\n", + " Parameters\n", + " ----------\n", + " mc : MarkovChain\n", + " Contains the transition matrix and set of state values\n", + " G : jax.Array\n", + " The vector form of the function mapping states to growth rates\n", + " β : float\n", + " Discount factor\n", + " γ : float\n", + " Coefficient of risk aversion\n", + " \"\"\"\n", + " mc: MarkovChain\n", + " G: jax.Array\n", + " β: float\n", + " γ: float\n", + " \n", + "\n", + "def create_ap_model(g=jnp.exp, β=0.96, γ=2.0):\n", + " \"\"\"Create an AssetPriceModel class using standard Markov chain.\"\"\"\n", + " n, ρ, σ = 25, 0.9, 0.02\n", + " qe_mc = qe.tauchen(n, ρ, σ)\n", + " P = jnp.array(qe_mc.P)\n", + " state_values = jnp.array(qe_mc.state_values)\n", + " G = g(state_values)\n", + " mc = MarkovChain(P=P, state_values=state_values)\n", + "\n", + " return AssetPriceModel(mc=mc, G=G, β=β, γ=γ)\n", + "\n", + "\n", + "def create_customized_ap_model(mc: MarkovChain, g=jnp.exp, β=0.96, γ=2.0):\n", + " \"\"\"Create an AssetPriceModel class using a customized Markov chain.\"\"\"\n", + " G = g(mc.state_values)\n", + " return AssetPriceModel(mc=mc, G=G, β=β, γ=γ)\n", + "\n", + "\n", + "def test_stability(Q, β):\n", + " \"\"\"Stability test for a given matrix Q.\"\"\"\n", + " sr = jnp.max(jnp.abs(eigvals(Q)))\n", + " checkify.check(\n", + " sr < 1 / β, \n", + " \"Spectral radius condition failed with radius = {sr}\", sr=sr\n", + " )\n", + " return sr\n", + "\n", + "\n", + "def tree_price(ap):\n", + " \"\"\"\n", + " Computes the price-dividend ratio of the Lucas tree.\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + "\n", + " Returns\n", + " -------\n", + " v : array_like(float)\n", + " Lucas tree price-dividend ratio\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", + " J = P * G**(1 - γ)\n", + "\n", + " # Make sure that a unique solution exists\n", + " test_stability(J, β)\n", + "\n", + " # Compute v\n", + " n = J.shape[0]\n", + " I = jnp.identity(n)\n", + " Ones = jnp.ones(n)\n", + " v = solve(I - β * J, β * J @ Ones)\n", + "\n", + " return v\n", + "\n", + "# Wrap the function to be safely jitted\n", + "tree_price_jit = jax.jit(checkify.checkify(tree_price))" + ] + }, + { + "cell_type": "markdown", + "id": "265ecf44", + "metadata": {}, + "source": [ + "Here's a plot of $v$ as a function of the state for several values of $\\gamma$,\n", + "with a positively correlated Markov process and $g(x) = \\exp(x)$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "959364d2", + "metadata": { + "mystnb": { + "figure": { + "caption": "Lucas tree prices for varying risk aversion\n", + "name": "fig_lucas_gamma" + } + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute price-dividend ratio of Lucas tree:: 0.37 ms elapsed\n", + "Compute price-dividend ratio of Lucas tree:: 0.08 ms elapsed\n", + "Compute price-dividend ratio of Lucas tree:: 0.04 ms elapsed\n", + "Compute price-dividend ratio of Lucas tree:: 0.05 ms elapsed\n", + "Compute price-dividend ratio of Lucas tree:: 0.05 ms elapsed\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "γs = [1.2, 1.4, 1.6, 1.8, 2.0]\n", + "ap = create_ap_model()\n", + "states = ap.mc.state_values\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "for γ in γs:\n", + " tem_ap = create_customized_ap_model(ap.mc, γ=γ)\n", + " # checkify returns a tuple\n", + " # err indicates whether errors happened\n", + " err, v = tree_price_jit(tem_ap)\n", + " # Stop if errors raised\n", + " err.throw()\n", + " ax.plot(states, v, lw=2, alpha=0.6, label=rf\"$\\gamma = {γ}$\")\n", + "\n", + "ax.set_ylabel(\"price-dividend ratio\")\n", + "ax.set_xlabel(\"state\")\n", + "ax.legend(loc='upper right')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b6c03815", + "metadata": {}, + "source": [ + "Notice that $v$ is decreasing in each case.\n", + "\n", + "This is because, with a positively correlated state process, higher states indicate higher future consumption growth.\n", + "\n", + "With the stochastic discount factor {eq}`lucsdf2`, higher growth decreases the\n", + "discount factor, lowering the weight placed on future dividends.\n", + "\n", + "#### Special Cases\n", + "\n", + "In the special case $\\gamma =1$, we have $J = P$.\n", + "\n", + "Recalling that $P^i {\\mathbb 1} = {\\mathbb 1}$ for all $i$ and applying {ref}`Neumann's geometric series lemma `, we are led to\n", + "\n", + "$$\n", + "v = \\beta(I-\\beta P)^{-1} {\\mathbb 1}\n", + "= \\beta \\sum_{i=0}^{\\infty} \\beta^i P^i {\\mathbb 1}\n", + "= \\beta \\frac{1}{1 - \\beta} {\\mathbb 1}\n", + "$$\n", + "\n", + "Thus, with log preferences, the price-dividend ratio for a Lucas tree is constant.\n", + "\n", + "Alternatively, if $\\gamma = 0$, then $J = K$ and we recover the\n", + "risk-neutral solution {eq}`rned`.\n", + "\n", + "This is as expected, since $\\gamma = 0$ implies $u(c) = c$ (and hence agents are risk-neutral).\n", + "\n", + "### A Risk-Free Consol\n", + "\n", + "Consider the same pure exchange representative agent economy.\n", + "\n", + "A risk-free consol promises to pay a constant amount $\\zeta> 0$ each period.\n", + "\n", + "Recycling notation, let $p_t$ now be the price of an ex-coupon claim to the consol.\n", + "\n", + "An ex-coupon claim to the consol entitles an owner at the end of period $t$ to\n", + "\n", + "* $\\zeta$ in period $t+1$, plus\n", + "* the right to sell the claim for $p_{t+1}$ next period\n", + "\n", + "The price satisfies {eq}`lteeqs0` with $d_t = \\zeta$, or\n", + "\n", + "$$\n", + "p_t = {\\mathbb E}_t \\left[ m_{t+1} ( \\zeta + p_{t+1} ) \\right]\n", + "$$\n", + "\n", + "With the stochastic discount factor {eq}`lucsdf2`, this becomes\n", + "\n", + "```{math}\n", + ":label: consolguess1\n", + "\n", + "p_t\n", + "= {\\mathbb E}_t \\left[ \\beta g_{t+1}^{-\\gamma} ( \\zeta + p_{t+1} ) \\right]\n", + "```\n", + "\n", + "Guessing a solution of the form $p_t = p(X_t)$ and conditioning on\n", + "$X_t = x$, we get\n", + "\n", + "$$\n", + "p(x)\n", + "= \\beta \\sum_{y \\in S} g(y)^{-\\gamma} (\\zeta + p(y)) P(x, y)\n", + "$$\n", + "\n", + "Letting $M(x, y) = P(x, y) g(y)^{-\\gamma}$ and rewriting in vector notation\n", + "yields the solution\n", + "\n", + "```{math}\n", + ":label: consol_price\n", + "\n", + "p = (I - \\beta M)^{-1} \\beta M \\zeta {\\mathbb 1}\n", + "```\n", + "\n", + "The above is implemented in the function `consol_price`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "29a2f7a6", + "metadata": {}, + "outputs": [], + "source": [ + "def consol_price(ap, ζ):\n", + " \"\"\"\n", + " Computes price of a consol bond with payoff ζ\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + " \n", + " ζ : scalar(float)\n", + " Coupon of the console\n", + "\n", + " Returns\n", + " -------\n", + " p : array_like(float)\n", + " Console bond prices\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", + " M = P * G**(- γ)\n", + "\n", + " # Make sure that a unique solution exists\n", + " test_stability(M, β)\n", + "\n", + " # Compute price\n", + " n = M.shape[0]\n", + " I = jnp.identity(n)\n", + " Ones = jnp.ones(n)\n", + " p = solve(I - β * M, β * ζ * M @ Ones)\n", + "\n", + " return p\n", + "\n", + "# Wrap the function to be safely jitted\n", + "consol_price_jit = jax.jit(checkify.checkify(consol_price))" + ] + }, + { + "cell_type": "markdown", + "id": "b6022349", + "metadata": {}, + "source": [ + "### Pricing an Option to Purchase the Consol\n", + "\n", + "Let's now price options of various maturities.\n", + "\n", + "We'll study an option that gives the owner the right to purchase a consol at a price $p_S$.\n", + "\n", + "#### An Infinite Horizon Call Option\n", + "\n", + "We want to price an *infinite horizon* option to purchase a consol at a price $p_S$.\n", + "\n", + "The option entitles the owner at the beginning of a period either\n", + "\n", + "1. to purchase the bond at price $p_S$ now, or\n", + "1. not to exercise the option to purchase the asset now but to retain the right to exercise it later\n", + "\n", + "Thus, the owner either *exercises* the option now or chooses *not to exercise* and wait until next period.\n", + "\n", + "This is termed an infinite-horizon *call option* with *strike price* $p_S$.\n", + "\n", + "The owner of the option is entitled to purchase the consol at price $p_S$ at the beginning of any period, after the coupon has been paid to the previous owner of the bond.\n", + "\n", + "The fundamentals of the economy are identical with the one above, including the stochastic discount factor and the process for consumption.\n", + "\n", + "Let $w(X_t, p_S)$ be the value of the option when the time $t$ growth state is known to be $X_t$ but *before* the owner has decided whether to exercise the option\n", + "at time $t$ (i.e., today).\n", + "\n", + "Recalling that $p(X_t)$ is the value of the consol when the initial growth state is $X_t$, the value of the option satisfies\n", + "\n", + "$$\n", + "w(X_t, p_S)\n", + "= \\max \\left\\{\n", + " \\beta \\, {\\mathbb E}_t \\frac{u'(c_{t+1})}{u'(c_t)} w(X_{t+1}, p_S), \\;\n", + " p(X_t) - p_S\n", + "\\right\\}\n", + "$$\n", + "\n", + "The first term on the right is the value of waiting, while the second is the value of exercising now.\n", + "\n", + "We can also write this as\n", + "\n", + "```{math}\n", + ":label: FEoption0\n", + "\n", + "w(x, p_S)\n", + "= \\max \\left\\{\n", + " \\beta \\sum_{y \\in S} P(x, y) g(y)^{-\\gamma}\n", + " w (y, p_S), \\;\n", + " p(x) - p_S\n", + "\\right\\}\n", + "```\n", + "\n", + "With $M(x, y) = P(x, y) g(y)^{-\\gamma}$ and $w$ as the vector of\n", + "values $(w(x_i), p_S)_{i = 1}^n$, we can express {eq}`FEoption0` as the nonlinear vector equation\n", + "\n", + "```{math}\n", + ":label: FEoption\n", + "\n", + "w = \\max \\{ \\beta M w, \\; p - p_S {\\mathbb 1} \\}\n", + "```\n", + "\n", + "To solve {eq}`FEoption`, form an operator $T$ that maps vector $w$\n", + "into vector $Tw$ via\n", + "\n", + "$$\n", + "T w\n", + "= \\max \\{ \\beta M w,\\; p - p_S {\\mathbb 1} \\}\n", + "$$\n", + "\n", + "Start at some initial $w$ and iterate with $T$ to convergence.\n", + "\n", + "We can find the solution with the following function `call_option`" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8cfa0f41", + "metadata": {}, + "outputs": [], + "source": [ + "def call_option(ap, ζ, p_s, ϵ=1e-7):\n", + " \"\"\"\n", + " Computes price of a call option on a consol bond.\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + "\n", + " ζ : scalar(float)\n", + " Coupon of the console\n", + "\n", + " p_s : scalar(float)\n", + " Strike price\n", + "\n", + " ϵ : scalar(float), optional(default=1e-7)\n", + " Tolerance for infinite horizon problem\n", + "\n", + " Returns\n", + " -------\n", + " w : array_like(float)\n", + " Infinite horizon call option prices\n", + "\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", + " M = P * G**(- γ)\n", + "\n", + " # Make sure that a unique consol price exists\n", + " test_stability(M, β)\n", + "\n", + " # Compute option price\n", + " p = consol_price(ap, ζ)\n", + " err.throw()\n", + " n = M.shape[0]\n", + " w = jnp.zeros(n)\n", + " error = ϵ + 1\n", + "\n", + " def step(state):\n", + " w, _ = state\n", + " # Maximize across columns\n", + " w_new = jnp.maximum(β * M @ w, p - p_s)\n", + " # Find maximal difference of each component and update\n", + " error_new = jnp.amax(jnp.abs(w - w_new))\n", + " return (w_new, error_new)\n", + "\n", + " # Check whether converged\n", + " def cond(state):\n", + " _, error = state\n", + " return error > ϵ\n", + "\n", + " final_w, _ = jax.lax.while_loop(cond, step, (w, error))\n", + "\n", + " return final_w\n", + "\n", + "call_option_jit = jax.jit(checkify.checkify(call_option))" + ] + }, + { + "cell_type": "markdown", + "id": "21192c28", + "metadata": {}, + "source": [ + "Here's a plot of $w$ compared to the consol price when $P_S = 40$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7179ea30", + "metadata": { + "mystnb": { + "figure": { + "caption": "Consol price and call option value\n", + "name": "fig_consol_call" + } + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute consol price Jit: 0.20 ms elapsed\n", + "Compute call option price: 0.21 ms elapsed\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ap = create_ap_model(β=0.9)\n", + "ζ = 1.0\n", + "strike_price = 40\n", + "\n", + "x = ap.mc.state_values\n", + "err, p = consol_price_jit(ap, ζ)\n", + "err.throw()\n", + "err, w = call_option_jit(ap, ζ, strike_price)\n", + "err.throw()\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(x, p, 'b-', lw=2, label='consol price')\n", + "ax.plot(x, w, 'g-', lw=2, label='value of call option')\n", + "ax.set_xlabel(\"state\")\n", + "ax.legend(loc='upper right')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fea37311", + "metadata": {}, + "source": [ + "In high values of the Markov growth state, the value of the option is close to zero.\n", + "\n", + "This is despite the facts that the Markov chain is irreducible and that low states ---\n", + "where the consol prices are high --- will be visited recurrently.\n", + "\n", + "The reason for low valuations in high Markov growth states is that $\\beta=0.9$, so future payoffs are discounted substantially.\n", + "\n", + "### Risk-Free Rates\n", + "\n", + "Let's look at risk-free interest rates over different periods.\n", + "\n", + "#### The One-period Risk-free Interest Rate\n", + "\n", + "As before, the stochastic discount factor is $m_{t+1} = \\beta g_{t+1}^{-\\gamma}$.\n", + "\n", + "It follows that the reciprocal $R_t^{-1}$ of the gross risk-free interest rate $R_t$ in state $x$ is\n", + "\n", + "$$\n", + "{\\mathbb E}_t m_{t+1} = \\beta \\sum_{y \\in S} P(x, y) g(y)^{-\\gamma}\n", + "$$\n", + "\n", + "We can write this as\n", + "\n", + "$$\n", + "m_1 = \\beta M {\\mathbb 1}\n", + "$$\n", + "\n", + "where the $i$-th element of $m_1$ is the reciprocal of the one-period gross risk-free interest rate in state $x_i$.\n", + "\n", + "#### Other Terms\n", + "\n", + "Let $m_j$ be an $n \\times 1$ vector whose $i$ th component is the reciprocal of the $j$ -period gross risk-free interest rate in state $x_i$.\n", + "\n", + "Then $m_1 = \\beta M$, and $m_{j+1} = M m_j$ for $j \\geq 1$.\n", + "\n", + "## Exercises\n", + "\n", + "```{exercise}\n", + ":label: ma_ex1\n", + "\n", + "In the lecture, we considered **ex-dividend assets**.\n", + "\n", + "A **cum-dividend** asset is a claim to the stream $d_t, d_{t+1}, \\ldots$.\n", + "\n", + "Following {eq}`rnapex`, find the risk-neutral asset pricing equation for\n", + "one unit of a cum-dividend asset.\n", + "\n", + "With a constant, non-random dividend stream $d_t = d > 0$, what is the equilibrium\n", + "price of a cum-dividend asset?\n", + "\n", + "With a growing, non-random dividend process $d_t = g d_t$ where $0 < g \\beta < 1$,\n", + "what is the equilibrium price of a cum-dividend asset?\n", + "```\n", + "\n", + "```{solution} ma_ex1\n", + ":class: dropdown\n", + "\n", + "For a cum-dividend asset, the basic risk-neutral asset pricing equation is\n", + "\n", + "$$\n", + "p_t = d_t + \\beta {\\mathbb E}_t [ p_{t+1} ]\n", + "$$\n", + "\n", + "(mass_ex1)=\n", + "With constant dividends, the equilibrium price is\n", + "\n", + "$$\n", + "p_t = \\frac{1}{1-\\beta} d_t\n", + "$$\n", + "\n", + "With a growing, non-random dividend process, the equilibrium price is\n", + "\n", + "$$\n", + "p_t = \\frac{1}{1 - \\beta g} d_t\n", + "$$\n", + "```\n", + "\n", + "```{exercise-start}\n", + ":label: ma_ex2\n", + "```\n", + "\n", + "Consider the following primitives" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "391b7ed0", + "metadata": {}, + "outputs": [], + "source": [ + "n = 5 # Size of State Space\n", + "P = jnp.full((n, n), 0.0125)\n", + "P = P.at[jnp.arange(n), jnp.arange(n)].set(\n", + " P[jnp.arange(n), jnp.arange(n)] + 1 - P.sum(1)\n", + " )\n", + "# State values of the Markov chain\n", + "s = jnp.array([0.95, 0.975, 1.0, 1.025, 1.05])\n", + "γ = 2.0\n", + "β = 0.94" + ] + }, + { + "cell_type": "markdown", + "id": "3788996d", + "metadata": {}, + "source": [ + "Let $g$ be defined by $g(x) = x$ (that is, $g$ is the identity map).\n", + "\n", + "Compute the price of the Lucas tree.\n", + "\n", + "Do the same for\n", + "\n", + "* the price of the risk-free consol when $\\zeta = 1$\n", + "* the call option on the consol when $\\zeta = 1$ and $p_S = 150.0$\n", + "\n", + "```{exercise-end}\n", + "```\n", + "\n", + "```{solution-start} ma_ex2\n", + ":class: dropdown\n", + "```\n", + "\n", + "First, let's enter the parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "470d5128", + "metadata": {}, + "outputs": [], + "source": [ + "n = 5\n", + "P = jnp.full((n, n), 0.0125)\n", + "P = P.at[jnp.arange(n), jnp.arange(n)].set(\n", + " P[jnp.arange(n), jnp.arange(n)] + 1 - P.sum(1)\n", + " )\n", + "s = jnp.array([0.95, 0.975, 1.0, 1.025, 1.05]) # State values\n", + "mc = MarkovChain(P=P, state_values=s)\n", + "\n", + "γ = 2.0\n", + "β = 0.94\n", + "ζ = 1.0\n", + "p_s = 150.0" + ] + }, + { + "cell_type": "markdown", + "id": "106db117", + "metadata": {}, + "source": [ + "Next, we'll create an instance of `AssetPriceModel` to feed into the\n", + "functions" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1d7266b9", + "metadata": {}, + "outputs": [], + "source": [ + "apm = create_customized_ap_model(mc=mc, g=lambda x: x, β=β, γ=γ)" + ] + }, + { + "cell_type": "markdown", + "id": "32fa55d6", + "metadata": {}, + "source": [ + "Now we just need to call the relevant functions on the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fe25d419", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[29.474087 21.935726 17.571445 14.72517 12.72224 ]\n" + ] + } + ], + "source": [ + "err, v = tree_price_jit(apm)\n", + "err.throw()\n", + "print(v)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c01b2432", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[753.92316 242.56683 148.68501 109.25806 87.57421]\n" + ] + } + ], + "source": [ + "err, p = consol_price_jit(apm, ζ)\n", + "err.throw()\n", + "print(p)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "557f6eec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[603.92316 176.8546 108.686775 80.05874 64.31402 ]\n" + ] + } + ], + "source": [ + "err, w = call_option_jit(apm, ζ, p_s)\n", + "err.throw()\n", + "print(w)" + ] + }, + { + "cell_type": "markdown", + "id": "6fdff8eb", + "metadata": {}, + "source": [ + "Let's show the last two functions as a plot" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6f1015e7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXWlJREFUeJzt3Xl4VNX9x/H3ZJJM9kBCVkggQEBWQVCWgKBstqVqtUULWlBcWtdYqEv9oagVBOvWoraiFUUBW5VWLVUBkR2EIAqCrIGwJIQlZCHLJJn7++PChEBYksyW5PN6nvt4M/fmnDMTJB/OPfd7LYZhGIiIiIj4ED9vD0BERETkTAooIiIi4nMUUERERMTnKKCIiIiIz1FAEREREZ+jgCIiIiI+RwFFREREfI4CioiIiPgcf28PoC4cDgcHDx4kPDwci8Xi7eGIiIjIRTAMg8LCQhITE/HzO/8cSYMMKAcPHiQpKcnbwxAREZE62LdvH61atTrvOQ0yoISHhwPmG4yIiPDyaERERORiFBQUkJSU5Pw9fj4NMqCcuqwTERGhgCIiItLAXMzyDC2SFREREZ+jgCIiIiI+RwFFREREfE6DXIMiIiINl2EYVFRUUFlZ6e2hiBsEBARgtVrr3Y4CioiIeIzdbic7O5vi4mJvD0XcxGKx0KpVK8LCwurVjgKKiIh4hMPhIDMzE6vVSmJiIoGBgSq22cgYhsHhw4fZv38/qamp9ZpJUUARERGPsNvtOBwOkpKSCAkJ8fZwxE1iYmLYs2cP5eXl9QooWiQrIiIedaES59KwuWpWTH9KRERExOcooIiIiIjPUUARERFpwL7++mssFgvHjx/39lBcSgFFREREfI7u4jnNsRN2Zq/ei72ykj+MuMTbwxEREWmyNINymh2HCnlp0XbeXJ7JkaIybw9HRKTRMwyDYnuFxzfDMGo1TofDwbRp02jfvj02m43k5GSeffZZADZt2sTVV19NcHAw0dHR3HXXXRQVFTm/d9y4cVx//fX8+c9/JiEhgejoaO69917Ky8ud57z22mukpqYSFBREXFwcv/zlL53HysrKeOCBB4iNjSUoKIgBAwawbt26en7yvk8zKKe5IiWKS1tF8t3+fGav3stDwzp4e0giIo1aSXklnZ/4wuP9bnl6BCGBF/8r8LHHHmPmzJm89NJLDBgwgOzsbH788UeKi4u55ppr6Nu3L+vWrSM3N5c77riD++67j1mzZjm/f8mSJSQkJLBkyRJ27tzJTTfdRI8ePbjzzjtZv349DzzwALNnz6Z///4cO3aM5cuXO7/34Ycf5qOPPuKdd96hdevWTJ8+nREjRrBz506ioqJc+bH4FM2gnMZisXDnlW0BmL1mL6Xlek6EiEhTV1hYyCuvvML06dMZO3Ys7dq1Y8CAAdxxxx28//77lJSU8O6779K1a1euvvpqZsyYwezZszl06JCzjebNmzNjxgwuueQSRo4cyc9+9jMWL14MQFZWFqGhoYwcOZLWrVvTs2dPHnjgAQBOnDjB66+/zvPPP89PfvITOnfuzMyZMwkODuatt97yyufhKZpBOcM1XeJp1TyY/XklfLRhP2P6tPb2kEREGq3gACtbnh7hlX4v1tatWykrK2PIkCE1Hrv00ksJDQ11vpaWlobD4WDbtm3ExcUB0KVLl2pVVRMSEti0aRMAw4YNo3Xr1rRt25ZrrrmGa665hl/84heEhISwa9cuysvLSUtLc35vQEAAV1xxBVu3bq31+25ININyBn+rH+MHpADw5vJMHI7aXacUEZGLZ7FYCAn09/hWm2qnwcHB5zxmGMY52zr99YCAgLOOORwOAMLDw9mwYQNz584lISGBJ554gksvvZTjx48718qc2cf5+m0sFFBqMKp3EhFB/mQeOcGirYcu/A0iItJopaamEhwc7Lwkc7rOnTuzceNGTpw44Xxt5cqV+Pn50aHDxa9j9Pf3Z+jQoUyfPp3vv/+ePXv28NVXX9G+fXsCAwNZsWKF89zy8nLWr19Pp06d6vfGfJwu8dQg1ObPmL6tef3rXcxcvpvhXeK9PSQREfGSoKAgHnnkER5++GECAwNJS0vj8OHD/PDDD4wZM4Ynn3ySsWPHMnnyZA4fPsz999/Prbfe6ry8cyGfffYZu3fv5sorr6R58+YsWLAAh8NBx44dCQ0N5Xe/+x1/+MMfiIqKIjk5menTp1NcXMz48ePd/M69SwHlHMb1b8Oby3ezbk8eG7LyuCy5ubeHJCIiXjJp0iT8/f154oknOHjwIAkJCfz2t78lJCSEL774ggcffJDLL7+ckJAQbrzxRl588cWLbrtZs2Z8/PHHTJ48mdLSUlJTU5k7dy5dunQB4LnnnsPhcHDrrbdSWFhI7969+eKLL2jevHH/XrIYtb0Z3AcUFBQQGRlJfn4+ERERbutn4r++48OM/fy0Wzyvjenltn5ERJqC0tJSMjMzSUlJISgoyNvDETc538+5Nr+/tQblPO4caN5y/PnmHLKOFnt5NCIiIk2HAsp5dIwPZ1CHGBwG/GNlpreHIyIi0mQooFzAqVmUD9bt43ix3cujERERaRoUUC4grX00nRIiKCmv5P21Wd4ejoiISJOggHIBFouFu640C7e9vXIPZRUqfy8iIuJuCigXYWT3ROIjgjhSVMZ/vj3o7eGIiIg0egooFyHA6sftA9oAMHP57lo/pltERERqRwHlIt18RTJhNn925Bbx9fbD3h6OiIhIo6aAcpEiggK4+fIkAGYu2+3l0YiISEMxefJkevTo4fx63LhxXH/99T4xFl+mgFILtw1IwepnYdWuo2w+kO/t4YiIiJyTxWLh3//+d7XXJk6cWONDD32RAkottGwWzMjuCYC5FkVERKQhCQsLIzo62tvDuCgKKLV0qnDbZ99nc+B4iZdHIyIi7uZwOJg2bRrt27fHZrORnJzMs88+6zz+yCOP0KFDB0JCQmjbti2TJk2ivLy8Xn1+9NFHdOnSBZvNRps2bXjhhReqHW/Tpg3PPPMMo0ePJiwsjMTERP76179WOw7wi1/8AovF4vz6zEs8DoeDp59+mlatWmGz2ejRoweff/658/iePXuwWCx8/PHHXHXVVYSEhHDppZeyevXqer2/i6GAUktdW0bSv100lQ6DWSp/LyJSP4YB9hOe32pxN+Zjjz3GtGnTmDRpElu2bGHOnDnExcU5j4eHhzNr1iy2bNnCK6+8wsyZM3nppZfq/JFkZGQwatQobr75ZjZt2sTkyZOZNGkSs2bNqnbe888/T/fu3dmwYQOPPfYYDz30EAsXLgRg3bp1ALz99ttkZ2c7vz7TK6+8wgsvvMCf//xnvv/+e0aMGMG1117Ljh07qp33+OOPM3HiRDZu3EiHDh349a9/TUVFRZ3f48Xwd2vrjdSdA9uyatdR5n6zj/uHpBIRFODtIYmINEzlxTAl0fP9/vEgBIZe8LTCwkJeeeUVZsyYwdixYwFo164dAwYMcJ7zf//3f879Nm3aMGHCBD744AMefvjhOg3txRdfZMiQIUyaNAmADh06sGXLFp5//nnGjRvnPC8tLY1HH33Uec7KlSt56aWXGDZsGDExMQA0a9aM+Pj4c/b15z//mUceeYSbb74ZgGnTprFkyRJefvllXn31Ved5EydO5Gc/+xkATz31FF26dGHnzp1ccskldXqPF6NWMyht2rTBYrGctd17770AGIbB5MmTSUxMJDg4mMGDB/PDDz9Ua6OsrIz777+fFi1aEBoayrXXXsv+/ftd9448YFCHGFJjwygqq2DeNyp/LyLSWG3dupWysjKGDBlyznM+/PBDBgwYQHx8PGFhYUyaNImsrLr/bti6dStpaWnVXktLS2PHjh1UVlZVM+/Xr1+1c/r168fWrVsvup+CggIOHjxYY19nttO9e3fnfkKCuRYzNzf3ovuqi1rNoKxbt67ah7N582aGDRvGr371KwCmT5/Oiy++yKxZs+jQoQN/+tOfGDZsGNu2bSM8PByA9PR0Pv30U+bNm0d0dDQTJkxg5MiRZGRkYLVaXfjW3MfPz8KdA9vy8Eff848VexjXP4VAf10tExGptYAQczbDG/1ehODg4PMeX7NmDTfffDNPPfUUI0aMIDIyknnz5p21ZqQ2DMPAYrGc9drFOPP76vI9NfUfEBBw1vkOh6PWfdVGrX6rxsTEEB8f79w+++wz2rVrx6BBgzAMg5dffpnHH3+cG264ga5du/LOO+9QXFzMnDlzAMjPz+ett97ihRdeYOjQofTs2ZP33nuPTZs2sWjRIre8QXe5rmciLcJs5BSU8t9NKn8vIlInFot5qcXT20X+Ik9NTSU4OPict+auXLmS1q1b8/jjj9O7d29SU1PZu3dvvT6Szp07s2LFimqvrVq1ig4dOlT7h/yaNWuqnbNmzZpql1wCAgKqTSqcKSIigsTExBr76tSpU33egkvU+Z/9drud9957j9tvvx2LxUJmZiY5OTkMHz7ceY7NZmPQoEGsWrUKMBf+lJeXVzsnMTGRrl27Os+pSVlZGQUFBdU2b7P5W7ktrQ0AM5dlqvy9iEgjFBQUxCOPPMLDDz/Mu+++y65du1izZg1vvfUWAO3btycrK4t58+axa9cu/vKXvzB//vx69TlhwgQWL17MM888w/bt23nnnXeYMWMGEydOrHbeypUrmT59Otu3b+fVV1/lX//6Fw8++KDzeJs2bVi8eDE5OTnk5eXV2Ncf/vAHpk2bxgcffMC2bdt49NFH2bhxY7V2vKXOAeXf//43x48fdy7YycnJAai2svnU16eO5eTkEBgYSPPmzc95Tk2mTp1KZGSkc0tKSqrrsF1qTJ9kggOsbMkuYNWuo94ejoiIuMGkSZOYMGECTzzxBJ06deKmm25yrr+47rrreOihh7jvvvvo0aMHq1atci5uravLLruMf/7zn8ybN4+uXbvyxBNP8PTTT1dbIAtmkMnIyKBnz54888wzvPDCC4wYMcJ5/IUXXmDhwoUkJSXRs2fPGvt64IEHmDBhAhMmTKBbt258/vnnfPLJJ6SmptbrPbiCxajjP/1HjBhBYGAgn376KWBOCaWlpXHw4EHnAhqAO++8k3379vH5558zZ84cbrvtNsrKyqq1NWzYMNq1a8ff/va3GvsqKyur9j0FBQUkJSWRn59PREREXYbvMk/+ZzPvrN7LoA4xvHP7FV4di4iILystLSUzM5OUlBSCgoK8PZwGrU2bNqSnp5Oenu7toZzlfD/ngoICIiMjL+r3d51mUPbu3cuiRYu44447nK+duo3pzJmQ3Nxc56xKfHw8drv9rKmm08+pic1mIyIiotrmK24fkIKfBZZuP8y2nEJvD0dERKRRqFNAefvtt4mNjXXeEw2QkpJCfHy8s0gMmOtUli5dSv/+/QHo1asXAQEB1c7Jzs5m8+bNznMamtbRoVzT1QxnKn8vIiLiGrUu1OZwOHj77bcZO3Ys/v5V326xWEhPT2fKlCmkpqaSmprKlClTCAkJYfTo0QBERkYyfvx4JkyYQHR0NFFRUUycOJFu3boxdOhQ170rD7tzYFsWbMrhPxsP8IcRHYmL0NSliIi4z549e7w9BLerdUBZtGgRWVlZ3H777Wcde/jhhykpKeGee+4hLy+PPn368OWXXzproAC89NJL+Pv7M2rUKEpKShgyZAizZs1qMDVQatIzuTmXt2nOuj15vLNqDw9f477KeiIiIk1BnRfJelNtFtl4ypc/5HDX7AwigvxZ/dgQQm16ioCIyOm0SLZp8OoiWTnb0E5xpLQIpaC0gn+u3+ft4YiI+KwG+O9iqQVX/XwVUFzEz8/C+AEpALy1IpOKSveWABYRaWhOlUsvLi728kjEnex2O0C9l27oOoQL3XhZK15cuJ39eSV8/kMOI7t74QmdIiI+ymq10qxZM2eRs5CQkDo9O0Z8l8Ph4PDhw4SEhFS7kaYuFFBcKDjQyq19W/PK4h3MXLabn3VL0P98IiKnOVUzy91PwhXv8fPzIzk5ud6//xRQXOzWfq3529JdfLc/n3V78rgiJcrbQxIR8RkWi4WEhARiY2MpLy/39nDEDQIDA/Hzq/8KEgUUF2sRZuPGXq2YszaLN5btVkAREamB1Wpt0OUlxP20SNYNTi2WXbT1ELsOF3l5NCIiIg2PAoobtIsJY2gn89lCby7P9PJoREREGh4FFDe568q2AHy0YT9HisoucLaIiIicTgHFTS5v05xLk5phr3Awe/Vebw9HRESkQVFAcROLxcJdA81ZlNlr9lJir/TyiERERBoOBRQ3GtEljqSoYI6dsPPRhv3eHo6IiEiDoYDiRv5WP25Pqyp/X+nQ8ydEREQuhgKKm43qnUREkD+ZR06waOshbw9HRESkQVBAcbNQmz+39G0NwMxlu708GhERkYZBAcUDxvVvQ4DVwvq9eWzIyvP2cERERHyeAooHxEYEcX2PlgC8uVyzKCIiIheigOIhd5y85fjzzTnsPXrCy6MRERHxbQooHtIxPpxBHWJwGPCPFSp/LyIicj4KKB50qvz9P9fvJ++E3cujERER8V0KKB7Uv100nRMiKCmv5P21Kn8vIiJyLgooHmSxWJyzKLNW7aWsQuXvRUREaqKA4mE/655AQmQQR4rK+M+3B709HBEREZ+kgOJhAVY/bktrA8Aby3fjUPl7ERGRsyigeMHNVyQTZvNnZ24RS7cf9vZwREREfI4CihdEBAXw6yuSAHhD5e9FRETOooDiJbelpeDvZ2H17qNsPpDv7eGIiIj4FAUUL0lsFszI7gkAzFT5exERkWoUULzoVPn7z77P5sDxEi+PRkRExHcooHhR15aR9G8XTaXD4G2VvxcREXFSQPGyO08Wbpv7TRb5JeVeHo2IiIhvUEDxssEdYkiNDeOEvZJ532R5ezgiIiI+QQHFyywWi3MW5e2Ve7BXOLw8IhEREe9TQPEB1/VIJCbcRk5BKf/dpPL3IiIiCig+wOZvZVz/NgC8sSwTw1D5exERadoUUHzEmD7JBAdY2ZpdwMqdR709HBEREa9SQPERzUICuenyk+XvVbhNRESauFoHlAMHDnDLLbcQHR1NSEgIPXr0ICMjw3ncMAwmT55MYmIiwcHBDB48mB9++KFaG2VlZdx///20aNGC0NBQrr32Wvbv31//d9PA3Z6Wgp8Flm0/zI85Bd4ejoiIiNfUKqDk5eWRlpZGQEAA//vf/9iyZQsvvPACzZo1c54zffp0XnzxRWbMmMG6deuIj49n2LBhFBYWOs9JT09n/vz5zJs3jxUrVlBUVMTIkSOprKx02Rurk8pyWPcmrHndK90nR4fwk65m+fs3l6twm4iINF0WoxYrMh999FFWrlzJ8uXLazxuGAaJiYmkp6fzyCOPAOZsSVxcHNOmTePuu+8mPz+fmJgYZs+ezU033QTAwYMHSUpKYsGCBYwYMeKC4ygoKCAyMpL8/HwiIiIudvgX9uMCmPdrCAiFB76F8DjXtX2Rvs3K4xevrSLAamHFI1cTFxHk8TGIiIi4Q21+f9dqBuWTTz6hd+/e/OpXvyI2NpaePXsyc+ZM5/HMzExycnIYPny48zWbzcagQYNYtWoVABkZGZSXl1c7JzExka5duzrPOVNZWRkFBQXVNrfo+BNo2QvKT8Cy6e7p4wJ6Jjfn8jbNKa80mLVqj1fGICIi4m21Cii7d+/m9ddfJzU1lS+++ILf/va3PPDAA7z77rsA5OTkABAXV33mIS4uznksJyeHwMBAmjdvfs5zzjR16lQiIyOdW1JSUm2GffEsFhj2tLmfMQuO7nJPPxdw58mHCL6/Zi9FZRVeGYOIiIg31SqgOBwOLrvsMqZMmULPnj25++67ufPOO3n99eprNiwWS7WvDcM467Uzne+cxx57jPz8fOe2b9++2gy7dtoMgNQR4KiAxU+5r5/zGNopjpQWoRSUVvDPdW58ryIiIj6qVgElISGBzp07V3utU6dOZGWZz5CJj48HOGsmJDc31zmrEh8fj91uJy8v75znnMlmsxEREVFtc6uhTwIW2PIf2L/evX3VwM/Pwh0DUwD4x8pMKipV/l5ERJqWWgWUtLQ0tm3bVu217du307p1awBSUlKIj49n4cKFzuN2u52lS5fSv39/AHr16kVAQEC1c7Kzs9m8ebPzHK+L6wI9Rpv7C58EL1R2vfGyVkSFBrI/r4TPf6j50peIiEhjVauA8tBDD7FmzRqmTJnCzp07mTNnDm+88Qb33nsvYF7aSU9PZ8qUKcyfP5/Nmzczbtw4QkJCGD3a/IUfGRnJ+PHjmTBhAosXL+bbb7/llltuoVu3bgwdOtT177CurvojWG2wdwXs+NLj3QcFWPlNPzP4zVy2W+XvRUSkSalVQLn88suZP38+c+fOpWvXrjzzzDO8/PLLjBkzxnnOww8/THp6Ovfccw+9e/fmwIEDfPnll4SHhzvPeemll7j++usZNWoUaWlphISE8Omnn2K1Wl33zuorshX0udvcXzQZHJ6v0XJr39bY/P34bn8+32Qe83j/IiIi3lKrOii+wm11UM5Ukgev9IDS43Dda9BzzIW+w+X+OH8Tc9ZmMbRTLG+Ovdzj/YuIiLiK2+qgNDnBzWHgBHN/ybNQXuLxIYwfkILFAou25rIzt8jj/YuIiHiDAsqFXHEXRLSCggOw9u8e775dTBhDO5l3N721QuXvRUSkaVBAuZCAILj6cXN/xYtQ7Pm1IHddaRZu+2jDfo4UlXm8fxEREU9TQLkY3W+C2C5Qmm+GFA/r3bo5PZKaYa9w8O7qvR7vX0RExNMUUC6GnxWGTjb3174Bxz1b3dVisTjL389evYcSu5ef+iwiIuJmCigXK3UYtBkIlWWwZIrHux/RJY6kqGDyisv5cMN+j/cvIiLiSQooF8tigWEnn83z3VzI2ezR7v2tfoxPM8vfv7V8N5WOBnd3uIiIyEVTQKmNlr2g8/WAYRZv87Bf9U4iMjiAPUeLWbT1kMf7FxER8RQFlNoa8gT4+cPOhZC5zKNdh9r8uaVvMmCWvxcREWmsFFBqK7od9LrN3PfCgwTH9mtDoNWP9XvzyNibd+FvEBERaYAUUOpi0CMQGAYHN8AP8z3adWxEENf1SATgzeWaRRERkcZJAaUuwmKg//3m/uKnobLco93febJw2+c/5LD36AmP9i0iIuIJCih11e8+CI2FvEzImOXRrjvEhTO4YwyGofL3IiLSOCmg1JUtDAY/Yu5//RyUFXq0+7tOFm771/r95J2we7RvERERd1NAqY/LxkJUOyg+Aqv+6tGu+7WLpktiBCXllby/VuXvRUSkcVFAqQ9rgHnbMcCqGVDoudokp5e/n7VqL6XlKn8vIiKNhwJKfXW+zizgVn4Clk7zaNc/655AQmQQR4rK+M/GAx7tW0RExJ0UUOrLYoFhT5v7GbPgyE6PdR1g9eP2k+XvZy7PxKHy9yIi0kgooLhCmwGQOgKMSvjqaY92ffMVSYTb/NmZW8TS7Yc92reIiIi7KKC4ytDJgAW2/Af2r/dYt+FBAfy6j1n+/g2VvxcRkUZCAcVV4jpDj9Hm/sInPFoCf1z/Nvj7WVi9+yib9ud7rF8RERF3UUBxpav+CP5BsHcl7PjSY90mNgtmZPcEAGaq/L2IiDQCCiiuFNkK+txt7i+aDA7P3fp7x8lbjv+7KZv9ecUe61dERMQdFFBcbcBDENQMcrfAd3M91m3XlpGktY+m0mHw9so9HutXRETEHRRQXC24OQycYO4vmQLlJR7r+lThtnnfZJFf4tkHGIqIiLiSAoo7XHEXRLSCggOw9u8e63ZQhxg6xoVzwl7JvG+yPNaviIiIqymguENAEFz9uLm/4kUoPuaRbi0WC3cMNAu3vb1yD/YKh0f6FRERcTUFFHfpfhPEdoHSfDOkeMi1PRKJCbeRU1DKZ98f9Fi/IiIirqSA4i5+Vhj2lLm/9g04vs8j3dr8rYzr3wYwC7cZHqzHIiIi4ioKKO7Ufii0GQiVZbDkWY91O6ZPMiGBVn7MKWTFziMe61dERMRVFFDcyWKpmkX5bh7kbPJIt81CAhnVOwkwHyIoIiLS0CiguFvLXtDlF4ABi57yWLfjB6TgZ4Fl2w+zNbvAY/2KiIi4ggKKJ1w9Cfz8YedCyFzmkS6TokL4STez/P2bmkUREZEGRgHFE6LbQa/bzP2FT4DDM7f/nirc9sl3B8jJL/VInyIiIq6ggOIpgx6BwDA4+C1s+bdHuuyR1Iwr2kRRXmkwa9Uej/QpIiLiCgoonhIWA/0fMPcXPw0Vdo90e+eV5izKnLV7KSqr8EifIiIi9aWA4kn97oXQWMjLhIxZHulyyCWxtG0RSkFpBf9c55laLCIiIvWlgOJJtjAY/Ii5v3QalBW6vUs/Pwt3nFyL8taKTCoqVf5eRER8X60CyuTJk7FYLNW2+Ph453HDMJg8eTKJiYkEBwczePBgfvjhh2ptlJWVcf/999OiRQtCQ0O59tpr2b9/v2veTUNw2ViIagfFR2DVXz3S5Q2XtSQ6NJADx0v43+Ycj/QpIiJSH7WeQenSpQvZ2dnObdOmquJj06dP58UXX2TGjBmsW7eO+Ph4hg0bRmFh1UxBeno68+fPZ968eaxYsYKioiJGjhxJZWWla96Rr7MGwJAnzP1VM6DwkNu7DAqwcmu/1oDK34uISMNQ64Di7+9PfHy8c4uJiQHM2ZOXX36Zxx9/nBtuuIGuXbvyzjvvUFxczJw5cwDIz8/nrbfe4oUXXmDo0KH07NmT9957j02bNrFo0SLXvjNf1vk6aNkbyk+Yl3o84Na+rbH5+7HpQD5rMz3zdGUREZG6qnVA2bFjB4mJiaSkpHDzzTeze/duADIzM8nJyWH48OHOc202G4MGDWLVqlUAZGRkUF5eXu2cxMREunbt6jynJmVlZRQUFFTbGrTTS+BnzIIjO93eZXSYjV/2agXAm8t3u70/ERGR+qhVQOnTpw/vvvsuX3zxBTNnziQnJ4f+/ftz9OhRcnLMtQ1xcXHVvicuLs55LCcnh8DAQJo3b37Oc2oydepUIiMjnVtSUlJthu2b2gyA1BFgVMJiz5TAHz8gBYsFFm3NZWdukUf6FBERqYtaBZSf/OQn3HjjjXTr1o2hQ4fy3//+F4B33nnHeY7FYqn2PYZhnPXamS50zmOPPUZ+fr5z27evkdwuO3QyWPxg6yewb53bu2sbE8awTmaAfGuFZlFERMR31es249DQULp168aOHTucd/OcOROSm5vrnFWJj4/HbreTl5d3znNqYrPZiIiIqLY1CnGd4dLR5v6iJ8EDi1dPFW77aMMBDheWub0/ERGRuqhXQCkrK2Pr1q0kJCSQkpJCfHw8CxcudB632+0sXbqU/v37A9CrVy8CAgKqnZOdnc3mzZud5zQ5Vz0G/kGwdyVs/8Lt3fVu3ZweSc2wVziYvXqP2/sTERGpi1oFlIkTJ7J06VIyMzNZu3Ytv/zlLykoKGDs2LFYLBbS09OZMmUK8+fPZ/PmzYwbN46QkBBGjzZnCSIjIxk/fjwTJkxg8eLFfPvtt9xyyy3OS0ZNUmQr6HO3ub9oMjjce7u1xWLhrpOzKLPX7KXE3kRu7xYRkQbFvzYn79+/n1//+tccOXKEmJgY+vbty5o1a2jd2qyx8fDDD1NSUsI999xDXl4effr04csvvyQ8PNzZxksvvYS/vz+jRo2ipKSEIUOGMGvWLKxWq2vfWUMy4CHIeAcOb4Xv5kLPW9za3Ygu8SRFBbPvWAkfbtjPrX1bu7U/ERGR2rIYDbBqV0FBAZGRkeTn5zee9Sir/gpf/h9EtIT7MyAg2K3dvbNqD09+8gNtokNYPGEwVr/zL2QWERGpr9r8/tazeHzF5XdCZBIUHIC1f3N7d7/q3YrI4AD2HC1m4Rb3V7MVERGpDQUUXxEQBFc9bu4vfwmK3VvtNSTQn1v6JgMwU4XbRETExyig+JLuoyCuK5Tlw/IX3N7d2H5tCLT6kbE3j4y9eRf+BhEREQ9RQPElflazeBvAN2/A8Sy3dhcbEcT1PRMBlb8XERHfooDia9oPhTYDodIOS6a4vbs7Bpq3HH/+Qw57j55we38iIiIXQwHF15z+IMHv5kHOJrd21yEunKs6xmAY8NaKTLf2JSIicrEUUHxRy17Q5ReAYRZvc7NT5e//uX4feSfsbu9PRETkQhRQfNXVk8DPH3Yugt1L3dpVv7bRdEmMoLTcwXtr9rq1LxERkYuhgOKrottB79vN/UVPgsPhtq5OL3//zuo9lJar/L2IiHiXAoovu/JhCAyDg9/Clvlu7eqn3RJIjAziSJGd/2w84Na+RERELkQBxZeFxUD/B8z9xc9AhfvWhwRY/bh9QAoAM5dn4nA0uCcgiIhII6KA4uv63QuhsZCXCRmz3NrVTZcnEW7zZ2duEV9vz3VrXyIiIuejgOLrbGEw+FFzf+k0KC1wW1fhQQGM7mOWv39jmQq3iYiI9yigNASX/Qai20PxEfOpx240Lq0N/n4W1uw+xvf7j7u1LxERkXNRQGkIrAEw5Alzf/UMKHTf04cTIoP5+aVm+fuZy1W4TUREvEMBpaHodC207A3lxbD0Obd2dcdAc7Hsgk3Z7M8rdmtfIiIiNVFAaSgsFhj2tLmf8Q4c2eG2rrokRjKgfQsqHQZvr9zjtn5ERETORQGlIWmTBh2uAaMSFj/t1q5Olb+f900W+SXlbu1LRETkTAooDc2QJ8HiB1s/gX3r3NbNlakt6BgXzgl7JXO/yXJbPyIiIjVRQGlo4jrDpaPN/YVPgOGegmoWi8W5FuXtlZnYK9xXal9ERORMCigN0VV/BP8gyFoF279wWzfX9kgkNtzGoYIyPv3uoNv6EREROZMCSkMU2RL6/NbcXzQZHO55uJ/N38q4tDYAzFy+G8NNszUiIiJnUkBpqAakQ1AzOLwVNs5xWzdjrmhNSKCVH3MKWbHziNv6EREROZ0CSkMV3ByunGjuL5kC5SVu6SYyJICbLk8CVP5eREQ8RwGlIbv8TohMgsKDsPZvbuvm9rQU/CywfMcRtma771lAIiIipyigNGQBQXDV4+b+8peg+JhbukmKCuEn3RIAcy2KiIiIuymgNHTdR0FcVyjLh+UvuK2buwaahds+/e4gOfmlbutHREQEFFAaPj8rDH3K3P/mDTjunqJqlyY144qUKMorDWat2uOWPkRERE5RQGkM2g+BlCuh0g5fPeu2bk7Nory/di9FZRVu60dEREQBpTGwWKpmUb7/AHI2uaWbqy+JpW1MKIWlFXywbp9b+hAREQEFlMaj5WXQ5QbAMIu3uYGfn4U7BpizKP9YkUlFpcrfi4iIeyigNCZDJoGfP+xcBLuXuqWLGy5rSXRoIAeOl7Bgc45b+hAREVFAaUyi2kLv2839hU+Aw/UzHEEBVn7Trw0AM5ep/L2IiLiHAkpjc+XDEBgG2Rthy3y3dHFrv9bY/P3YdCCftZnuqb0iIiJNmwJKYxMWA2kPmvuLn4YKu8u7iAoN5Fe9WwHmLIqIiIirKaA0Rn3vgdBYyNsDGW+7pYvxA9piscDiH3PZmVvolj5ERKTpUkBpjGxhMPhRc3/pNCh1/fNzUlqEMqxTHABvLs90efsiItK0KaA0Vpf9BqLbQ/FRWPVXt3Rx15XmLccfbzjA4cIyt/QhIiJNU70CytSpU7FYLKSnpztfMwyDyZMnk5iYSHBwMIMHD+aHH36o9n1lZWXcf//9tGjRgtDQUK699lr2799fn6HImawBMOQJc3/1DCh0/S3BvVo3p2dyM+yVDmav3uPy9kVEpOmqc0BZt24db7zxBt27d6/2+vTp03nxxReZMWMG69atIz4+nmHDhlFYWLVOIT09nfnz5zNv3jxWrFhBUVERI0eOpLKysu7vRM7W6VpodTmUF5uXelzMYrE4y9+/u2YvJXb9/ERExDXqFFCKiooYM2YMM2fOpHnz5s7XDcPg5Zdf5vHHH+eGG26ga9euvPPOOxQXFzNnzhwA8vPzeeutt3jhhRcYOnQoPXv25L333mPTpk0sWrTINe9KTKeXwM94B47scHkXw7vEkxwVwvHicj7MUPl7ERFxjToFlHvvvZef/exnDB06tNrrmZmZ5OTkMHz4cOdrNpuNQYMGsWrVKgAyMjIoLy+vdk5iYiJdu3Z1nnOmsrIyCgoKqm1ykdqkQYdrwKiExU+5vHmrn4U7BqYA8OaKTCodKtwmIiL1V+uAMm/ePDZs2MDUqVPPOpaTY65ziIuLq/Z6XFyc81hOTg6BgYHVZl7OPOdMU6dOJTIy0rklJSXVdthN29DJYPGDrZ/CvnUub/6XvVoRGRzA3qPFLNyi8vciIlJ/tQoo+/bt48EHH+S9994jKCjonOdZLJZqXxuGcdZrZzrfOY899hj5+fnObd8+XUqoldhO0GO0ub/wCXBxefqQQH9u7dsagJm65VhERFygVgElIyOD3NxcevXqhb+/P/7+/ixdupS//OUv+Pv7O2dOzpwJyc3NdR6Lj4/HbreTl5d3znPOZLPZiIiIqLZJLQ3+I/gHQdYq2P65y5v/Tf/WBFr9yNibR8Zelb8XEZH6qVVAGTJkCJs2bWLjxo3OrXfv3owZM4aNGzfStm1b4uPjWbhwofN77HY7S5cupX///gD06tWLgICAaudkZ2ezefNm5zniBpEtoc9vzf1Fk6GywqXNx4YH8YueLQGYuUyzKCIiUj/+tTk5PDycrl27VnstNDSU6Oho5+vp6elMmTKF1NRUUlNTmTJlCiEhIYwebV5iiIyMZPz48UyYMIHo6GiioqKYOHEi3bp1O2vRrbjYgIdgwztw+Ef4bi5cdqtLm79jYAofrN/HF1ty2HPkBG1ahLq0fRERaTpcXkn24YcfJj09nXvuuYfevXtz4MABvvzyS8LDw53nvPTSS1x//fWMGjWKtLQ0QkJC+PTTT7Fara4ejpwuuBkMnGjuL5kC9mKXNp8aF85VHWMwDHhrhWZRRESk7iyG4eIVkx5QUFBAZGQk+fn5Wo9SW+WlMKM35O+DIU/CwN+7tPlVu44weuZaggL8WP3oEJqHBrq0fRERabhq8/tbz+JpagKC4Or/M/dXvAzFrl3Q2q9tNF1bRlBa7uC9NXtd2raIiDQdCihNUbdRENcNyvJh+QsubdpisXDnyfL376zeQ2m5yt+LiEjtKaA0RX5+ZvE2gG/egDzXznT8tFsCLZsFc6TIzr+/PeDStkVEpGlQQGmq2g+BlCuh0m4umHWhAKsft6W1AWDm8t04VP5eRERqSQGlqTr9QYLffwA5m1za/E2XJxFu82fX4RMs2Zbr0rZFRKTxU0BpylpeBl1uAAxY+KRLmw4PCmB0n2QA3li226Vti4hI46eA0tQNmQR+AbBrMez+2qVNj0trg7+fhbWZx/h+/3GXti0iIo2bAkpTF9UWet9u7i98EhwOlzWdEBnMtZcmAnqIoIiI1I4CisCVf4DAMMjeCD987NKm7zh5y/GCTdnsO+bayrUiItJ4KaAIhMVA2oPm/lfPQIXdZU13ToxgYGoLKh0Gb6/c47J2RUSkcVNAEVO/eyE0FvL2QMbbLm361CzKB+uyyC8pd2nbIiLSOCmgiCkwFAY/au4vnQalBS5r+srUFnSMC+eEvZK532S5rF0REWm8FFCkymW/gej2UHwUVv3FZc1aLBbuvNKcRXl7ZSb2CtctxBURkcZJAUWqWAPMJxwDrH4VCnNc1vS1lyYSF2HjUEEZn3530GXtiohI46SAItV1+jm0uhzKi+Hr51zWbKC/H+P6pwBm+XvDUPl7ERE5NwUUqc5igWFPm/sb3oUjO1zW9Og+yYQGWvkxp5DlO464rF0REWl8FFDkbK37Q4efgFEJi59yWbORwQGMujwJMGdRREREzkUBRWo29Emw+MHWT2HfNy5r9va0FPwssHzHEbZmu+5OIRERaVwUUKRmsZ2gx2hzf+ET4KI1I0lRIfy0WwKgWRQRETk3BRQ5t8F/BP8gyFoN2z93WbN3nbzl+JONB8nOL3FZuyIi0ngooMi5RbaEvr8z9xdNhsoKlzTbvVUz+qREUeEwmLVqj0vaFBGRxkUBRc4vLR2Cm8PhH+G7OS5r9s6T5e/nrMmisFTl70VEpDoFFDm/4GYwcKK5v2Qq2F3zROKrL4mlbUwohWUVfLBun0vaFBGRxkMBRS7sijshMhkKD8Lav7mkST8/i3MW5e2Ve6ioVPl7ERGpooAiF+Zvg6sfN/dXvAzFx1zS7C96tqRFWCAHjpewYLPryuqLiEjDp4AiF6fbKIjrBmX5sPwFlzQZFGDlN/3aAPDGsl0qfy8iIk4KKHJx/Pxg2GRz/5s3IG+vS5q9pW9rggL82HyggDW7XTMzIyIiDZ8Cily8dkMg5UqotMOSZ13SZFRoIL/s1QpQ4TYREamigCIX7/QHCX7/T8j+3iXNjh/QFosFvvoxl525hS5pU0REGjYFFKmdxJ7Q9UbAMIu3uUBKi1CGd44D4M3lmS5pU0REGjYFFKm9qyeBXwDsWgy7v3ZJk6fK33+84QC5haUuaVNERBouBRSpvagU6H27ub/wCXDUv4ZJr9ZRXJbcDHulg9mrXbMAV0REGi4FFKmbQQ9DYDhkfwc/fOySJk/Nosxes5diu2ue+yMiIg2TAorUTWgLSHvQ3P/qGaiw17vJYZ3jaR0dwvHicj7M2F/v9kREpOFSQJG663cPhMVB3h5Y/496N2f1szB+QAoAb63IpNKhwm0iIk2VAorUXWAoDH7U3F82HUoL6t3kL3u1ollIAHuPFrNwi8rfi4g0VQooUj89fwPR7aH4KKz6S72bCwn059a+rQF4Y5kKt4mINFW1Ciivv/463bt3JyIigoiICPr168f//vc/53HDMJg8eTKJiYkEBwczePBgfvjhh2ptlJWVcf/999OiRQtCQ0O59tpr2b9f6w0aLKs/DHnS3F/9KhTWf9bjN/3aEGj1Y0PWcTL2qvy9iEhTVKuA0qpVK5577jnWr1/P+vXrufrqq7nuuuucIWT69Om8+OKLzJgxg3Xr1hEfH8+wYcMoLKyqDpqens78+fOZN28eK1asoKioiJEjR1JZWenadyae0+nn0OoKKC+Gr5+rd3Mx4TZuuKwloFkUEZGmymLU8xGyUVFRPP/889x+++0kJiaSnp7OI488ApizJXFxcUybNo27776b/Px8YmJimD17NjfddBMABw8eJCkpiQULFjBixIiL6rOgoIDIyEjy8/OJiIioz/DFVfaugrd/AhYr3LsWWqTWq7mduYUMfXGZWQJ/wmBSWoS6aKAiIuIttfn9Xec1KJWVlcybN48TJ07Qr18/MjMzycnJYfjw4c5zbDYbgwYNYtWqVQBkZGRQXl5e7ZzExES6du3qPEcaqNb9ocNPwKh0SQn89rHhXH1JLIYB/1ih8vciIk1NrQPKpk2bCAsLw2az8dvf/pb58+fTuXNncnLMtQdxcXHVzo+Li3Mey8nJITAwkObNm5/znJqUlZVRUFBQbRMfNHQyWPzgx89g3zf1bu7OgWbhtn9l7OPYifrXWRERkYaj1gGlY8eObNy4kTVr1vC73/2OsWPHsmXLFudxi8VS7XzDMM567UwXOmfq1KlERkY6t6SkpNoOWzwh9hLoMcbcX/gE1O/qIX3bRtGtZSSl5Q7eW6Py9yIiTUmtA0pgYCDt27end+/eTJ06lUsvvZRXXnmF+Ph4gLNmQnJzc52zKvHx8djtdvLy8s55Tk0ee+wx8vPzndu+fftqO2zxlMGPgX8QZK2Gbf+78PnnYbFYuPNk+ft3Vu2htFwLqUVEmop610ExDIOysjJSUlKIj49n4cKFzmN2u52lS5fSv39/AHr16kVAQEC1c7Kzs9m8ebPznJrYbDbnrc2nNvFRkS2h7+/M/UWTobJ+z9T5add4WjYL5ugJO/O/PVD/8YmISINQq4Dyxz/+keXLl7Nnzx42bdrE448/ztdff82YMWOwWCykp6czZcoU5s+fz+bNmxk3bhwhISGMHj0agMjISMaPH8+ECRNYvHgx3377LbfccgvdunVj6NChbnmD4gVp6RDcHI5sg+/m1Kspf6sft6W1AWDm8t04VP5eRKRJ8K/NyYcOHeLWW28lOzubyMhIunfvzueff86wYcMAePjhhykpKeGee+4hLy+PPn368OWXXxIeHu5s46WXXsLf359Ro0ZRUlLCkCFDmDVrFlar1bXvTLwnuBlc+Qf44o+wZAp0/SUEhtS5uZuvSOaVxTvYffgES7blMqTTuS8HiohI41DvOijeoDooDUBFGfy1N+RnwZAnYOCEejU39X9b+fvS3fRJieKDu/u5aJAiIuJJHqmDInJe/ja4+v/M/RUvQ3H9Stbf1j8Ffz8LazOP8d2+4/UenoiI+DYFFHGfbr+CuG5QVgDL/lyvpuIjg7i2RyJgrkUREZHGTQFF3MfPD4ZNNvfXzYS8+tUyuWOAecvxgk3Z7DtWXM/BiYiIL1NAEfdqNwRSBkGlHZY8W6+mOidGMDC1BQ4D3l65xzXjExERn6SAIu5lscCwp8z97/8J2d/Xq7lT5e/nrcsiv7i8vqMTEREfpYAi7pfYE7reCBiw6Ml6NTUwtQWXxIdTbK9kzjdZrhmfiIj4HAUU8YyrJ4FfAOz6CnYtqXMzFovFOYvy9spM7BUOV41QRER8iAKKeEZUClw+3txf9CQ46h4sfn5pInERNnILy/jku4MuGqCIiPgSBRTxnCv/AIHhkP0d/PBxnZsJ9PdjXP8UAN5cvpsGWGtQREQuQAFFPCe0BaQ9aO4vfhoq7HVuanSfZEIDrfyYU8jyHUdcNEAREfEVCijiWf3ugbA4OL4X1v+jzs1EBgdw0+XJgAq3iYg0Rgoo4lmBoTD4UXN/2XQoLahzU7eltcHqZ2H5jiNsOVj3dkRExPcooIjn9fwNRKdC8VFY+Uqdm0mKCuGn3RIAcy2KiIg0Hgoo4nlWfxh6sh7K6lehMKfOTd050Fws+8l3B8nOL3HF6ERExAcooIh3XDISWl0BFSXw9dQ6N9O9VTP6pERR4TCYpfL3IiKNhgKKeIfFAsOeNvc3zIbD2+vc1F1XmoXb5qzNorBU5e9FRBoDBRTxntb9oONPwaiExU/VuZmrOsbSLiaUwrIKPli3z4UDFBERb1FAEe8a8iRY/ODHzyBrbZ2a8PM7vfz9HsorVf5eRKShU0AR74q9BHqMMfcXPgF1rAp7fc+WtAgL5MDxEhZsynbhAEVExBsUUMT7rvoj+AfDvjWw7X91aiIowMrYfm0As3Cbyt+LiDRsCijifRGJ0Pd35v6iyVBZUadmbunbmqAAPzYfKODr7YddNz4REfE4BRTxDWkPQnBzOLINNr5fpyaahwbyq15JANz29jrGvLmGBZuytSZFRKQBUkAR3xDczHzaMZh1UezFdWrm98M6MLRTHBYLrNx5lHve30D/577iz19sY39e3doUERHPsxgN8GJ9QUEBkZGR5OfnExER4e3hiKtUlMFfe0N+Fgx5AgZOqHNT+/OKmffNPuat28eRojLALL0yuEMMt/RtzeCOsVj9LK4auYiIXITa/P5WQBHf8t0HMP8usEXAAxshNLpezZVXOli45RBz1maxYucR5+uJkUHcfEUyN12eRFxEUD0HLSIiF0MBRRouhwPeuBJyNkHfe+GaKS5rOvPICeZ+k8W/1u8jr9isOGv1szCsUxxj+iaT1q4FfppVERFxGwUUadh2Lob3bgBrINy3Hpq3dmnzpeWVfL45h/fX7mXdnjzn662jQxh9RTK/7NWK6DCbS/sUEREFFGnoDAPevQ4yl0K3UXDjTLd1tS2nkDlr9/LxhgMUlpm3Nwda/bimazxj+iRzRUoUFotmVUREXEEBRRq+g9/CG4PN/buXQcKlbu2u2F7Bp98dZM7aLL7bn+98vX1sGGP6JHNDz1ZEhgS4dQwiIo2dAoo0Dh+Oh80fQrur4db5Hut20/585nyzl39/e5CS8koAggL8+Hn3REb3SaZHUjPNqoiI1IECijQOxzJhxuXgKIdb/w3trvJo9wWl5fzn2wO8vzaLH3MKna93TohgTN9kruvRkjCbv0fHJCLSkCmgSOPxv0dg7d8gvjvctRT8PF9b0DAMNmTl8f7aLD77Pht7hVmZNjTQyvU9WzKmT2s6J+rPoYjIhSigSONx4gi80gPshXDjW9Dtl14dTt4JOx9t2M+ctVnsPnLC+XrP5GaM6dOakd0TCAqwenGEIiK+SwFFGpdlz8NXf4JmreG+deDv/VuADcNg9e6jvL82iy8251DhMP83igjy55e9khjdJ5n2sWFeHqWIiG9RQJHGxX4C/nIZFOXANc9VPfnYRxwuLONfGfuYszaL/Xklztf7pEQxpm9rRnSJw+avWRUREQUUaXzWvw2fpUNwFDy4EYIivT2iszgcBst2HOb9tVks3nqIk5MqRIcG8qveSYy+Ipnk6BDvDlJExIsUUKTxqayA1/rC0R0wcCIMmeTtEZ1Xdn7JyYcVZnGooMz5+pUdYhjTJ5khl8Tib9XDxEWkaVFAkcZp66fwwS3gHwwPfAsRCd4e0QVVVDpY/GMu76/NYtn2w87X4yJs3HR5MjdfnkRis2AvjlBExHNq8/u7Vv+Emzp1Kpdffjnh4eHExsZy/fXXs23btmrnGIbB5MmTSUxMJDg4mMGDB/PDDz9UO6esrIz777+fFi1aEBoayrXXXsv+/ftrMxRpii4ZCUl9oKIElj7n7dFcFH+rHyO6xPPu7Vew7A9X8bvB7YgODeRQQRl/WbyDAdO+4o531rNkWy6Vjgb3bwUREbepVUBZunQp9957L2vWrGHhwoVUVFQwfPhwTpyout1y+vTpvPjii8yYMYN169YRHx/PsGHDKCysKnSVnp7O/PnzmTdvHitWrKCoqIiRI0dSWVnpuncmjY/FAkOfMvc3zIbD2707nlpKjg7hkWsuYdVjV/PXX/ekb9soHAYs2nqI295ex6Dnl/Dqkp0cLiy7cGMiIo1cvS7xHD58mNjYWJYuXcqVV16JYRgkJiaSnp7OI488ApizJXFxcUybNo27776b/Px8YmJimD17NjfddBMABw8eJCkpiQULFjBixIgL9qtLPE3c3F/DtgXmjMrN73t7NPWyM7eIOWuz+DBjHwWl5sMK/f0sjOhiPqywX7toldUXkUbDbZd4zpSfbz5ULSoqCoDMzExycnIYPny48xybzcagQYNYtWoVABkZGZSXl1c7JzExka5duzrPOVNZWRkFBQXVNmnChjwJFj/48TPIWuvt0dRL+9gwnvh5Z755fCh//tWlXJbcjAqHwX83ZTP6zbUMeWEpby7fTd4Ju7eHKiLiUXUOKIZh8Pvf/54BAwbQtWtXAHJycgCIi4urdm5cXJzzWE5ODoGBgTRv3vyc55xp6tSpREZGOrekpKS6Dlsag9hLoOct5v7CJ6DhrfM+S1CAlV/2asXH96Sx4IGB3NI3mdBAK7uPnOBP/91Kn6mL+f0HG8nYe4wGuK5dRKTW6hxQ7rvvPr7//nvmzp171rEzp6QNw7jgNPX5znnsscfIz893bvv27avrsKWxGPyYeTfPvjXm5Z5GpHNiBH+6vhtrHx/KlF90o0tiBPYKBx9/e4AbX1/NT15ZzuzVeygoLff2UEVE3KZOAeX+++/nk08+YcmSJbRq1cr5enx8PMBZMyG5ubnOWZX4+Hjsdjt5eXnnPOdMNpuNiIiIaps0cRGJVRVlF00266Q0MmE2f0b3Seaz+wfw73vTGNW7FUEBfvyYU8ik//xAn2cX8+hH37Npf763hyoi4nK1CiiGYXDffffx8ccf89VXX5GSklLteEpKCvHx8SxcuND5mt1uZ+nSpfTv3x+AXr16ERAQUO2c7OxsNm/e7DxH5KIMSDcryx7ZDhsb9mLZ87FYLPRIasb0X17K2j8OZfLPO5MaG0ZJeSXz1u3j5zNWcO2MFXywLotie+MLaiLSNNXqLp577rmHOXPm8J///IeOHTs6X4+MjCQ42Cw2NW3aNKZOncrbb79NamoqU6ZM4euvv2bbtm2Eh4cD8Lvf/Y7PPvuMWbNmERUVxcSJEzl69CgZGRlYrRd+Zonu4hGn1a/BF49BeALcvwECm0YpecMwWLcnj/fX7uV/m3KwVzoACLf5c8NlLRndpzUd48O9PEoRkercVkn2XGtE3n77bcaNGweYf3E+9dRT/P3vfycvL48+ffrw6quvOhfSApSWlvKHP/yBOXPmUFJSwpAhQ3jttdcuevGrAoo4VZTBjN5wPAuungRXTvT2iDzuaFEZH2bsZ843Wew9Wux8vXfr5ozpm8xPuiYQFKCHFYqI96nUvTQt3/8TPr4TbBHwwEYIjfb2iLzC4TBYuesIc9Zm8eWWQ87KtM1CAvhVr1aM7tOalBahXh6liDRlCijStDgc8MaVkLMJ+t4D10z19oi87lBBKf9ct4+532RxML/U+Xpa+2jG9GnNsM5xBOhhhSLiYQoo0vTsXAzv3QB+AXD/emjextsj8gmVDoOvt5kPK1yyLddZMiYm3MZNvZO4+YokWjVvGut2RMT7FFCkaXr3Otj9NXQbBTfO9PZofM7+vGI+WLePeev2OZ/3Y7HA4A4xjOnTmqsuicXqp7L6IuI+CijSNB3cCG8MMvdvnQ9trzJ/A0s15ZUOFm05xPtrs1ix84jz9cTIIG6+IpmbLk8iLiLIiyMUkcZKAUWarg/Hw+YPzf2IlpA6DDpcAylXQqAWiJ4p88gJ5n6Txb/W7yOv2KxMa/WzMKxTHKP7JDOgfQv8NKsiIi6igCJNV9Fh+O/vYcdCqCipet1qg5SBZlhJHQ7NW3tvjD6otLySL37I4f01WXyz55jz9eSoEEb3SeZXvVoRHWbz4ghFpDFQQBEpL4E9K2D757D9S8jPqn48phN0GG4GllZXgNXfO+P0QdsPFTJnbRYfbdhPYalZmTbQ6sc1XeMZ0yeZK1KiLvhsLRGRmiigiJzOMODwj1VhZd8aMBxVx4OaQfuh0GGE+d+QKK8N1ZcU2yv47Lts3l+7l+9Oe95P+9gwxvRJ5oaerYgMCfDiCEWkoVFAETmf4mOw6yvY/gXsXAglpz240uJnzqicml2J7ayFtsDmA/m8v3Yv/9l4kGJ7JQBBAX78vHsio/sk0yOpmWZVROSCFFBELlZlBRxYXzW7kvtD9eMRrcyZlQ4jzIW2AcHeGaePKCwt598bD/L+mr38mFPofL1zQgRj+iZzXY+WhNl0uUxEaqaAIlJXx/fBji/MsJK5FCqqqrDiHwQpg8zZldQR0Ozinh3VGBmGwYas47y/di+ffZ+NvcK8ZBYaaOX6ni0Z06c1nRP1/6aIVKeAIuIK9mLYs7xqdqVgf/XjsV2qZldaXQ5+TfOBfMeL7ebDCtdmsfvICefrPZObMfqKZEZ2TyQ4sGl+NiJSnQKKiKsZBuRuqQor+7+pvtA2OOq0hbZDILi598bqJYZhsGb3Md5fu5cvfsihvNL8qyUiyJ8be7ViTJ9k2seGe3mUIuJNCigi7lZ8DHYuMgPLzkVQWnWXCxYrJPWpml2JuaTJLbQ9XFjGvzL2MWdtFvvzqurR9EmJYkzf1ozoEofNX7MqIk2NAoqIJ1VWmDMqp2ZXDm+tfjwyuSqstBkIAU2njLzDYbBsx2HeX5vF4q2HcJz82yY6NJBf9U5i9BXJJEfrYYUiTYUCiog35e2FHV+atzFnLoPKsqpjASEnF9qOMCvaRrb03jg9LDu/xHxY4Tf7yCmoWnw8MLUFY/q0ZminWPytfl4coYi4mwKKiK+wnzBDyqnZlcKD1Y/HdzPvCOpwDbS8rEkstK2odPDVj7m8vzaLZTsOc+pvoLgIGzddnszNlyeR2Kxp384t0lgpoIj4IsOAnE1VtzHvXwec9r9fSDS0H2bOrrS7GoKbeWukHpN1tJi567L457p9HD1hB8DPAoM6xNAjqTkd48NIjQundVSIZldEGgEFFJGG4MSR0xbafgVlZyy0bd3fvAzUYQS06NCoF9raKxx8ucV8WOHq3UfPOh7o70f7mDA6xIXRIT6cjnHhdIgLp2WzYD1tWaQBUUARaWgqy2Hf2qpLQUe2VT/evM3JS0EjoM0A8G+8TxbemVvEkh9z2XaokB2HCtl+qIiS8soazw0JtJIaG0aHuHA6xoeTGmeGl7gIm0rvi/ggBRSRhu5Y5smFtp+bT2WutFcdCwiFdleZsyupwyEiwXvj9ACHw2B/XgnbDxU6Q8u2Q0Xsyi3CXumo8XsigvzpEBdOh/hwOsRWzbpEhzXeYCfSECigiDQmZUVm2f1TsytFOdWPJ1xatdA2sSf4NY21GhWVDvYeK2Z7zqngUsS2Q4VkHjlBpaPmv9aiQwNPm20Jo2OcOesSGaynMot4ggKKSGNlGJD9XdVtzAcyqLbQNjSmamal3dUQ1PT+/yirqCTzyAm25VSFlu2HCsk6Vsy5/raLjwg6a7alfWwYoXrwoYhLKaCINBVFh2HnQnN2ZdcSKCuoOubnf3Kh7cnZlRbtvTdOH1Bir2RnbtFpl4kK2Z5TyMH80nN+T1JUMB1iw52hJTUujHYxYQQFNP7bwUXcQQFFpCmqsMO+NebMyvYv4OiO6sej2ppBJXU4tE4D/0DvjNPHFJSWs+NQUVVoObkw93BhWY3n+1mgTYtQZ3DpcPJSUZsWoQToVmiR81JAERE4uuu0hbYrwVFedSwwHNoNNgNL+2EQHue1YfqqYyfsbD99tuVQEdtyCskvKa/x/ACrhbYtws66VJQUFYJVt0KLAAooInKmskLY/bUZVnYshKJD1Y8n9qyaXUno0WQW2taWYRgcLiwzw8rJS0Tbc83/nrDXfCu0zd+P1DjzVugOcVWXilo2C9at0NLkKKCIyLk5HJC9sWqh7cEN1Y+HxUHqMHPtSrurwBbulWE2JIZhcOB4SbVFudtP3llUVlHzrdBhNn8zuJy2xqVDXBgx4arhIo2XAoqIXLzCQ9UX2tqLqo75BUCbtKrZleh23htnA1TpMNh3rLha/ZbtOYXsPlJEeWXNf/U2Cwk4GVqqboPuGBdO81CtGZKGTwFFROqmogz2rqpau3Jsd/Xj0alVT2JO7qeFtnVUXulgz5ETzrUtpy4V7TlygnOUcCEm3GaW+j95qajDyRmX8CDVcJGGQwFFRFzjyM6T61a+MIOLo6LqmC3CvAR0aqFtWIz3xtlIlJZXsutwUdWlopPBZd+xknN+T2Jk0Gm3QVfVcAkO1K3Q4nsUUETE9UrzzUtAO740txOHTztogZa9zNmVDiMgvnujfrihp50oq2BHbpG5tiWnkO255qxLTkHNNVwsFkiOCnHOspyqnpvSIhSbv4KLeI8Cioi4l8MBB781Z1a2f25Wtz1deIK50LbDNZAyCGxh3hlnI5dfXM6O3Kqic9sPmSHm6Al7jedb/SyktAitCi0nZ13aRIfgrxou4gEKKCLiWQXZVTMru5ZA+YmqY9ZAaDOwau1KVIr3xtlEHCkqO2u2ZduhQgpLK2o8P9DqR7vYsGprXDrGhdOqeTB+quEiLqSAIiLeU1FmPoH51ELbvD3Vj7foWHUpKKkPWLXI0xMMw+BQQdlpsy0nb4XOLaL4HDVcggOszhoup+q3dIwPJz4iSLdCS50ooIiIbzAMOLLj5ELbLyFr9RkLbSOh/RAzrLQfBqHR3htrE+VwmDVctp1WdG7boSJ2HS7Cfo4aLuFB/tXuJOoYZ9ZyaRFm8/DopaFRQBER31RyHHZ9VXU5qPjoaQct0Opy6DAc2g+F6PYqEudFFZUO9h4rrra2ZfuhQnYfOUHlOe6FjgoNdF4mSmkRSky4jZgwm/nfcBthNn/NvDRxCigi4vsclXBgQ9VC25xNZ58T3ByaJUNkEjRrbe43Szr532QIivT8uJu4sopKMo+ccNZvOVWEbu+xYi702yQowO+s0BITFlS1f3JrERaou40aKbcGlGXLlvH888+TkZFBdnY28+fP5/rrr3ceNwyDp556ijfeeIO8vDz69OnDq6++SpcuXZznlJWVMXHiRObOnUtJSQlDhgzhtddeo1WrVi5/gyLSQOQfqJpZyVoNJXkX/h5bZFVYOT24RJ7cD26u2509pMRu1nDZdnJ9y/68Eg4XlnG4qIzDhWUUldW8QPdcIoMDzg4zNXwdFRKohbwNiFsDyv/+9z9WrlzJZZddxo033nhWQJk2bRrPPvsss2bNokOHDvzpT39i2bJlbNu2jfBwc7r2d7/7HZ9++imzZs0iOjqaCRMmcOzYMTIyMrBaL5yaFVBEmoCyQji+D45nQf4+OL7X3D/1WvGRC7cRGF5zcDm1hUQrwHhIsb2CI4V2DheVmsHl1FZUdtbX53oMQE2sfhaiQwPPGWB0icm3eOwSj8ViqRZQDMMgMTGR9PR0HnnkEcCcLYmLi2PatGncfffd5OfnExMTw+zZs7npppsAOHjwIElJSSxYsIARI0a49A2KSCNlPwH5+0+Glr1VweXUdiL3wm0EhNQQXE67nBQaowDjYYZhkF9Sft4Ac2r/WLH9gpeVTqdLTN5Xm9/f/q7sODMzk5ycHIYPH+58zWazMWjQIFatWsXdd99NRkYG5eXl1c5JTEyka9eurFq1qsaAUlZWRllZmfPrgoICVw5bRBqiwFCI6WhuNSkvORlgzggv+Sf3C7OhvBgO/2huNfEPOnd4iUwyn/zspwJnrmSxWGgWEkizkEBS486/SLq80sGxE/YLzsicusRUWu5g37GS8z464JSLvcTUPCQQqy4xuYVLA0pOTg4AcXFx1V6Pi4tj7969znMCAwNp3rz5Weec+v4zTZ06laeeesqVQxWRxi4gGFqkmltNKspOm4E5LbicuoxUcAAqSuHoDnOriTXwZIA5/TLSaZeQwuPBT/8Sd5cAqx9xEUHERQRd8NzaXmLKLyknv6ScnblF521Xl5jcx6UB5ZQzfwCGYVzwh3K+cx577DF+//vfO78uKCggKSmp/gMVkabL3wbR7cytJhV2M6ScGVxO7RccgEo7HNtlbjXx84fIVmcHl1OBJjwRrG75a1jOEBLoT3K0P8nRIec9zzAMCkoqOFxUSu55gsyRojKOnrBT6TDILSwjt7DsvO2CLjHVlkv/z4iPjwfMWZKEhATn67m5uc5Zlfj4eOx2O3l5edVmUXJzc+nfv3+N7dpsNmw2FQASEQ/yDzTL8p+rNH9lBRQePDu4HN9rhpr8/WZRurw9Z1fTPcVihYiW574TKbKVKu16mMViITIkgMiQANrHnv8SU8XJS0y557m0dOTk14W1vMQUEeR/WmgJOufMTFRo473E5NKAkpKSQnx8PAsXLqRnz54A2O12li5dyrRp0wDo1asXAQEBLFy4kFGjRgGQnZ3N5s2bmT59uiuHIyLiPlb/qjBRE0eluc6l2vqX0xbx5u83Z2DyT76+t4Y2LH7mLMu57kSKbGXOBIlX+Fv9iI0IIvYiLjGV2Cs5UlRWNStTQ6A5FWbslQ4KSisoKK1g1+ET523XzwLRYRdeKxMTbiO8gV1iqnVAKSoqYufOnc6vMzMz2bhxI1FRUSQnJ5Oens6UKVNITU0lNTWVKVOmEBISwujRowGIjIxk/PjxTJgwgejoaKKiopg4cSLdunVj6NChrntnIiLe5Gc1A0RkK2jd7+zjDgcUHTr3bdT5+8w1MAX7zS1rdQ2dWMx1Lue6EymylbkWR7wuONBKUlQISVGuvcTkMHC+Rvb5x2Dz97uotTItwmwEBXj/ElOtbzP++uuvueqqq856fezYscyaNctZqO3vf/97tUJtXbt2dZ5bWlrKH/7wB+bMmVOtUNvFrivRbcYi0ugZBpw4XPNt1KfWxZQXX7id0NgaLiGddidS4Pl/YYrvqu0lptqICPKnY3w4//ptzUsv6kql7kVEGjvDMJ9ldHrtlzPvRrKf/w4UAEJanB1enLMxSXoeUiNR20tMAJ0SIvjfgwNdOg6v1UEREREPsVggtIW5tbzs7OOGYT4u4Fy3UR/fC2UFZkXe4iNwcEPN/Zx6HtK57kTS85AahLpcYrJXeHf+QgFFRKQxslggJMrcEnvUfE7J8ZqDy6lAU5JXtWV/V3MbQZHnvoU6uJkZcIIiVQ+mgTj9LiZvU0AREWmqgpuZW3y3mo+XFpwMMPtOWwtz2mxM8VEozYfSTXCohqdRn84WCcGRENTMDC3O8NLsjP0zjtnC9biBJkoBRUREahYUAUFdIK5LzcftJ6qHl9NnY4pyzRkae6F5blm+uZFVuzFYrGZgudhgc/q+7mBq0BRQRESkbgJDIfYSczuXynJzlqUkzwwspcer9kvyqn995rHKMjAqzZma4qO1H59/0LnDy4VCjir8ep1+AiIi4j7WgKrFvLVVXlJzkHF+XcOxU68blWYdmaIcc6utwPCqS2AXDDmnHbNF6AGSLqKAIiIivikg2NwiEi587ukMA8oKLzxDc1bIOW7e2QTmpSl7oXnZqjYsfuai4ItZX3PmsYBgrbc5jQKKiIg0LhbLyfUzEUDr2n1vZcXJhb/Haz97U1EChqPqzqfasgZeeIbmXMca4TObFFBEREROsfpDaLS51VZ5ac2zMhcTchwV5rOZTuSaW20FhJ4RXiIvLuTYIn32kpQCioiIiCsEBEFAvPl8pNowDLPqb20XEZceN2d7AMpPmFvB/loO2lIVZs4ML5FJMPD3tWzPdRRQREREvMliMeu92MKBi3smnZOj8rRLUhdYX3Pm1+UnAONk0Dl+dtvRqQooIiIiUgd+1qqKwbVVYT//DE2Qd591p4AiIiLSFPkHQlisufkg31wZIyIiIk2aAoqIiIj4HAUUERER8TkKKCIiIuJzFFBERETE5yigiIiIiM9RQBERERGfo4AiIiIiPkcBRURERHyOAoqIiIj4HAUUERER8TkKKCIiIuJzFFBERETE5zTIpxkbhgFAQUGBl0ciIiIiF+vU7+1Tv8fPp0EGlMLCQgCSkpK8PBIRERGprcLCQiIjI897jsW4mBjjYxwOBwcPHiQ8PByLxeLt4XhdQUEBSUlJ7Nu3j4iICG8Pp9HS5+wZ+pw9R5+1Z+hzrmIYBoWFhSQmJuLnd/5VJg1yBsXPz49WrVp5exg+JyIiosn/4fcEfc6eoc/Zc/RZe4Y+Z9OFZk5O0SJZERER8TkKKCIiIuJzFFAaAZvNxpNPPonNZvP2UBo1fc6eoc/Zc/RZe4Y+57ppkItkRUREpHHTDIqIiIj4HAUUERER8TkKKCIiIuJzFFBERETE5yig+KDXXnuNlJQUgoKC6NWrF8uXLz/v+a+++iqdOnUiODiYjh078u677551zvHjx7n33ntJSEggKCiITp06sWDBAne9hQbDHZ/1yy+/TMeOHQkODiYpKYmHHnqI0tJSd70Fn7Zs2TJ+/vOfk5iYiMVi4d///vcFv2fp0qX06tWLoKAg2rZty9/+9rezzvnoo4/o3LkzNpuNzp07M3/+fDeMvmFxx2c9c+ZMBg4cSPPmzWnevDlDhw7lm2++cdM7aBjc9Wf6lHnz5mGxWLj++utdN+iGyhCfMm/ePCMgIMCYOXOmsWXLFuPBBx80QkNDjb1799Z4/muvvWaEh4cb8+bNM3bt2mXMnTvXCAsLMz755BPnOWVlZUbv3r2Nn/70p8aKFSuMPXv2GMuXLzc2btzoqbflk9zxWb/33nuGzWYz3n//fSMzM9P44osvjISEBCM9Pd1Tb8unLFiwwHj88ceNjz76yACM+fPnn/f83bt3GyEhIcaDDz5obNmyxZg5c6YREBBgfPjhh85zVq1aZVitVmPKlCnG1q1bjSlTphj+/v7GmjVr3PxufJs7PuvRo0cbr776qvHtt98aW7duNW677TYjMjLS2L9/v5vfje9yx+d8yp49e4yWLVsaAwcONK677jr3vIEGRAHFx1xxxRXGb3/722qvXXLJJcajjz5a4/n9+vUzJk6cWO21Bx980EhLS3N+/frrrxtt27Y17Ha76wfcgLnjs7733nuNq6++uto5v//9740BAwa4aNQN18X8Zf7www8bl1xySbXX7r77bqNv377Or0eNGmVcc8011c4ZMWKEcfPNN7tsrA2dqz7rM1VUVBjh4eHGO++844phNniu/JwrKiqMtLQ048033zTGjh2rgGIYhi7x+BC73U5GRgbDhw+v9vrw4cNZtWpVjd9TVlZGUFBQtdeCg4P55ptvKC8vB+CTTz6hX79+3HvvvcTFxdG1a1emTJlCZWWle95IA+Cuz3rAgAFkZGQ4p8F3797NggUL+NnPfuaGd9H4rF69+qyfyYgRI1i/fr3zMz7XOef6uUnNLuazPlNxcTHl5eVERUV5YoiNwsV+zk8//TQxMTGMHz/e00P0WQooPuTIkSNUVlYSFxdX7fW4uDhycnJq/J4RI0bw5ptvkpGRgWEYrF+/nn/84x+Ul5dz5MgRwPwl+eGHH1JZWcmCBQv4v//7P1544QWeffZZt78nX+Wuz/rmm2/mmWeeYcCAAQQEBNCuXTuuuuoqHn30Ube/p8YgJyenxp9JRUWF8zM+1znn+rlJzS7msz7To48+SsuWLRk6dKgnhtgoXMznvHLlSt566y1mzpzpjSH6rAb5NOPGzmKxVPvaMIyzXjtl0qRJ5OTk0LdvXwzDIC4ujnHjxjF9+nSsVisADoeD2NhY3njjDaxWK7169eLgwYM8//zzPPHEE25/P77M1Z/1119/zbPPPstrr71Gnz592LlzJw8++CAJCQlMmjTJ7e+nMajpZ3Lm67X5ucm5Xcxnfcr06dOZO3cuX3/99VkziXJ+5/ucCwsLueWWW5g5cyYtWrTwxvB8lmZQfEiLFi2wWq1n/UswNzf3rAR+SnBwMP/4xz8oLi5mz549ZGVl0aZNG8LDw51/2BMSEujQoYPzlyhAp06dyMnJwW63u+8N+TB3fdaTJk3i1ltv5Y477qBbt2784he/YMqUKUydOhWHw+H299XQxcfH1/gz8ff3Jzo6+rznnOvnJjW7mM/6lD//+c9MmTKFL7/8ku7du3tymA3ehT7nXbt2sWfPHn7+85/j7++Pv78/7777Lp988gn+/v7s2rXLSyP3PgUUHxIYGEivXr1YuHBhtdcXLlxI//79z/u9AQEBtGrVCqvVyrx58xg5ciR+fuaPNy0tjZ07d1b7Bbl9+3YSEhIIDAx0/RtpANz1WRcXFzv3T7FarRjmgnTXvolGqF+/fmf9TL788kt69+5NQEDAec+50M9NqruYzxrg+eef55lnnuHzzz+nd+/enh5mg3ehz/mSSy5h06ZNbNy40blde+21XHXVVWzcuJGkpCQvjdwHeGdtrpzLqVtf33rrLWPLli1Genq6ERoaauzZs8cwDMN49NFHjVtvvdV5/rZt24zZs2cb27dvN9auXWvcdNNNRlRUlJGZmek8JysrywgLCzPuu+8+Y9u2bcZnn31mxMbGGn/60588/fZ8ijs+6yeffNIIDw835s6da+zevdv48ssvjXbt2hmjRo3y9NvzCYWFhca3335rfPvttwZgvPjii8a3337rvJX7zM/41C2ZDz30kLFlyxbjrbfeOuuWzJUrVxpWq9V47rnnjK1btxrPPfecbjM23PNZT5s2zQgMDDQ+/PBDIzs727kVFhZ6/P35Cnd8zmfSXTwmBRQf9OqrrxqtW7c2AgMDjcsuu8xYunSp89jYsWONQYMGOb/esmWL0aNHDyM4ONiIiIgwrrvuOuPHH388q81Vq1YZffr0MWw2m9G2bVvj2WefNSoqKjzxdnyaqz/r8vJyY/LkyUa7du2MoKAgIykpybjnnnuMvLw8D70j37JkyRIDOGsbO3asYRhnf8aGYRhff/210bNnTyMwMNBo06aN8frrr5/V7r/+9S+jY8eORkBAgHHJJZcYH330kQfejW9zx2fdunXrGtt88sknPfOmfJC7/kyfTgHFZDEMzTuLiIiIb9EaFBEREfE5CigiIiLicxRQRERExOcooIiIiIjPUUARERERn6OAIiIiIj5HAUVERER8jgKKiIiI+BwFFBEREfE5CigiIiLicxRQRERExOcooIiIiIjP+X9UNqBsael0GQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(s, p, label='consol')\n", + "ax.plot(s, w, label='call option')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "19c72f7a", + "metadata": {}, + "source": [ + "```{solution-end}\n", + "```\n", + "\n", + "```{exercise}\n", + ":label: ma_ex3\n", + "\n", + "Let's consider finite horizon call options, which are more common than\n", + "infinite horizon ones.\n", + "\n", + "Finite horizon options obey functional equations closely related to {eq}`FEoption0`.\n", + "\n", + "A $k$ period option expires after $k$ periods.\n", + "\n", + "If we view today as date zero, a $k$ period option gives the owner the right to exercise the option to purchase the risk-free consol at the strike price $p_S$ at dates $0, 1, \\ldots , k-1$.\n", + "\n", + "The option expires at time $k$.\n", + "\n", + "Thus, for $k=1, 2, \\ldots$, let $w(x, k)$ be the value of a $k$-period option.\n", + "\n", + "It obeys\n", + "\n", + "$$\n", + "w(x, k)\n", + "= \\max \\left\\{\n", + " \\beta \\sum_{y \\in S} P(x, y) g(y)^{-\\gamma}\n", + " w (y, k-1), \\;\n", + " p(x) - p_S\n", + "\\right\\}\n", + "$$\n", + "\n", + "where $w(x, 0) = 0$ for all $x$.\n", + "\n", + "We can express this as a sequence of nonlinear vector equations\n", + "\n", + "$$\n", + "w_k = \\max \\{ \\beta M w_{k-1}, \\; p - p_S {\\mathbb 1} \\}\n", + " \\quad k =1, 2, \\ldots\n", + " \\quad \\text{with } w_0 = 0\n", + "$$\n", + "\n", + "Write a function that computes $w_k$ for any given $k$.\n", + "\n", + "Compute the value of the option with `k = 5` and `k = 25` using parameter values as in {ref}`ma_ex1`.\n", + "\n", + "Is one higher than the other? Can you give intuition?\n", + "```\n", + "\n", + "```{solution-start} ma_ex3\n", + ":class: dropdown\n", + "```\n", + "\n", + "Here's a suitable function:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "366ea0fd", + "metadata": {}, + "outputs": [], + "source": [ + "def finite_call_option(ap, ζ, p_s, k):\n", + " \"\"\"\n", + " Computes k period option value.\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", + " M = P * G**(- γ)\n", + "\n", + " # Make sure that a unique solution exists\n", + " test_stability(M, β)\n", + "\n", + " # Compute option price\n", + " p = consol_price(ap, ζ)\n", + " n = M.shape[0]\n", + " def step(i, w):\n", + " # Maximize across columns\n", + " w = jnp.maximum(β * M @ w, p - p_s)\n", + " return w\n", + " \n", + " w = jax.lax.fori_loop(0, k, step, jnp.zeros(n))\n", + "\n", + " return w\n", + "\n", + "finite_call_option_jit = jax.jit(\n", + " checkify.checkify(finite_call_option)\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "495b19dd", + "metadata": {}, + "source": [ + "Now let's compute the option values at `k=5` and `k=25`" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7844ffa8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "for k in [5, 25]:\n", + " err, w = finite_call_option_jit(apm, ζ, p_s, k)\n", + " err.throw()\n", + " ax.plot(s, w, label=rf'$k = {k}$')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f30664ff", + "metadata": {}, + "source": [ + "Not surprisingly, options with larger $k$ are worth more.\n", + "\n", + "This is because an owner has a longer horizon over which\n", + " the option can be exercised.\n", + "\n", + "```{solution-end}\n", + "```" + ] + } + ], + "metadata": { + "jupytext": { + "default_lexer": "ipython" + }, + "kernelspec": { + "display_name": "quantecon", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From f9d76bb5097df3faae82ecdc485cbb986b2c4c7e Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Fri, 6 Feb 2026 15:24:40 +0800 Subject: [PATCH 09/12] Save from Google Colab --- lectures/markov_asset.ipynb | 1859 ++++++----------------------------- 1 file changed, 287 insertions(+), 1572 deletions(-) diff --git a/lectures/markov_asset.ipynb b/lectures/markov_asset.ipynb index 70299125b..a9d812790 100644 --- a/lectures/markov_asset.ipynb +++ b/lectures/markov_asset.ipynb @@ -1,1589 +1,304 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "c264c82a", - "metadata": {}, - "source": [ - "(mass)=\n", - "```{raw} jupyter\n", - "
\n", - " \n", - " \"QuantEcon\"\n", - " \n", - "
\n", - "```\n", - "\n", - "# {index}`Asset Pricing: Finite State Models `\n", - "\n", - "```{index} single: Models; Markov Asset Pricing\n", - "```\n", - "\n", - "```{contents} Contents\n", - ":depth: 2\n", - "```\n", - "\n", - "```{epigraph}\n", - "\"A little knowledge of geometric series goes a long way\" -- Robert E. Lucas, Jr.\n", - "```\n", - "\n", - "```{epigraph}\n", - "\"Asset pricing is all about covariances\" -- Lars Peter Hansen\n", - "```\n", - "\n", - "```{admonition} GPU\n", - ":class: warning\n", - "\n", - "This lecture is accelerated via [hardware](status:machine-details) that has access to a GPU and JAX for GPU programming.\n", - "\n", - "Free GPUs are available on Google Colab. To use this option, please click on the play icon top right, select Colab, and set the runtime environment to include a GPU.\n", - "\n", - "Alternatively, if you have your own GPU, you can follow the [instructions](https://github.com/google/jax) for installing JAX with GPU support. If you would like to install JAX running on the `cpu` only you can use `pip install jax[cpu]`\n", - "```\n", - "\n", - "In addition to what's in Anaconda, this lecture will need the following libraries:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c69339f7", - "metadata": { - "tags": [ - "hide-output" - ] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: quantecon in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (0.10.1)\n", - "Requirement already satisfied: numba>=0.49.0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (0.61.0)\n", - "Requirement already satisfied: numpy>=1.17.0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (2.1.3)\n", - "Requirement already satisfied: requests in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (2.32.3)\n", - "Requirement already satisfied: scipy>=1.5.0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (1.15.3)\n", - "Requirement already satisfied: sympy in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from quantecon) (1.13.3)\n", - "Requirement already satisfied: llvmlite<0.45,>=0.44.0dev0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from numba>=0.49.0->quantecon) (0.44.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from requests->quantecon) (3.3.2)\n", - "Requirement already satisfied: idna<4,>=2.5 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from requests->quantecon) (3.7)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from requests->quantecon) (2.3.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from requests->quantecon) (2025.4.26)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in c:\\users\\edwar\\anaconda3\\envs\\quantecon\\lib\\site-packages (from sympy->quantecon) (1.3.0)\n" - ] - } - ], - "source": [ - "!pip install quantecon" - ] - }, - { - "cell_type": "markdown", - "id": "60bb52a4", - "metadata": {}, - "source": [ - "## Overview\n", - "\n", - "```{index} single: Markov Asset Pricing; Overview\n", - "```\n", - "\n", - "An asset is a claim on one or more future payoffs.\n", - "\n", - "The spot price of an asset depends primarily on\n", - "\n", - "* the anticipated income stream\n", - "* attitudes about risk\n", - "* rates of time preference\n", - "\n", - "In this lecture, we consider some standard pricing models and dividend stream specifications.\n", - "\n", - "We study how prices and dividend-price ratios respond in these different scenarios.\n", - "\n", - "We also look at creating and pricing *derivative* assets that repackage income streams.\n", - "\n", - "Key tools for the lecture are\n", - "\n", - "* Markov processes\n", - "* formulas for predicting future values of functions of a Markov state\n", - "* a formula for predicting the discounted sum of future values of a Markov state\n", - "\n", - "Let's start with some imports:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ce7fce98", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import quantecon as qe\n", - "import jax\n", - "import jax.numpy as jnp\n", - "from jax.numpy.linalg import eigvals, solve\n", - "from jax.experimental import checkify\n", - "from typing import NamedTuple" - ] - }, - { - "cell_type": "markdown", - "id": "66b8e8b0", - "metadata": {}, - "source": [ - "## {index}`Pricing Models `\n", - "\n", - "```{index} single: Models; Pricing\n", - "```\n", - "\n", - "Let $\\{d_t\\}_{t \\geq 0}$ be a stream of dividends\n", - "\n", - "* A time-$t$ **cum-dividend** asset is a claim to the stream $d_t, d_{t+1}, \\ldots$.\n", - "* A time-$t$ **ex-dividend** asset is a claim to the stream $d_{t+1}, d_{t+2}, \\ldots$.\n", - "\n", - "Let's look at some equations that we expect to hold for prices of assets under ex-dividend contracts\n", - "(we will consider cum-dividend pricing in the exercises).\n", - "\n", - "### Risk-neutral pricing\n", - "\n", - "```{index} single: Pricing Models; Risk-Neutral\n", - "```\n", - "\n", - "Our first scenario is risk-neutral pricing.\n", - "\n", - "Let $\\beta = 1/(1+\\rho)$ be an intertemporal discount **factor**, where\n", - "$\\rho$ is the **rate** at which agents discount the future.\n", - "\n", - "The basic risk-neutral asset pricing equation for pricing one unit of an ex-dividend asset is\n", - "\n", - "(mass_pra)=\n", - "```{math}\n", - ":label: rnapex\n", - "\n", - "p_t = \\beta {\\mathbb E}_t [d_{t+1} + p_{t+1}]\n", - "```\n", - "\n", - "This is a simple \"cost equals expected benefit\" relationship.\n", - "\n", - "Here ${\\mathbb E}_t [y]$ denotes the best forecast of $y$, conditioned on information available at time $t$.\n", - "\n", - "More precisely, ${\\mathbb E}_t [y]$ is the mathematical expectation of $y$ conditional on information available at time $t$.\n", - "\n", - "### Pricing with random discount factor\n", - "\n", - "```{index} single: Pricing Models; Risk Aversion\n", - "```\n", - "\n", - "What happens if for some reason traders discount payouts differently depending on the state of the world?\n", - "\n", - "Michael Harrison and David Kreps {cite}`HarrisonKreps1979` and Lars Peter Hansen\n", - "and Scott Richard {cite}`HansenRichard1987` showed that in quite general\n", - "settings the price of an ex-dividend asset obeys\n", - "\n", - "```{math}\n", - ":label: lteeqs0\n", - "\n", - "p_t = {\\mathbb E}_t \\left[ m_{t+1} ( d_{t+1} + p_{t+1} ) \\right]\n", - "```\n", - "\n", - "for some **stochastic discount factor** $m_{t+1}$.\n", - "\n", - "Here the fixed discount factor $\\beta$ in {eq}`rnapex` has been replaced by the random variable $m_{t+1}$.\n", - "\n", - "How anticipated future payoffs are evaluated now depends on statistical properties of $m_{t+1}$.\n", - "\n", - "The stochastic discount factor can be specified to capture the idea that assets that tend to have good payoffs in bad states of the world are valued more highly than other assets whose payoffs don't behave that way.\n", - "\n", - "This is because such assets pay well when funds are more urgently wanted.\n", - "\n", - "We give examples of how the stochastic discount factor has been modeled below.\n", - "\n", - "### Asset pricing and covariances\n", - "\n", - "Recall that, from the definition of a conditional covariance ${\\rm cov}_t (x_{t+1}, y_{t+1})$, we have\n", - "\n", - "```{math}\n", - ":label: lteeqs101\n", - "\n", - "{\\mathbb E}_t (x_{t+1} y_{t+1}) = {\\rm cov}_t (x_{t+1}, y_{t+1}) + {\\mathbb E}_t x_{t+1} {\\mathbb E}_t y_{t+1}\n", - "```\n", - "\n", - "If we apply this definition to the asset pricing equation {eq}`lteeqs0` we obtain\n", - "\n", - "```{math}\n", - ":label: lteeqs102\n", - "\n", - "p_t = {\\mathbb E}_t m_{t+1} {\\mathbb E}_t (d_{t+1} + p_{t+1}) + {\\rm cov}_t (m_{t+1}, d_{t+1}+ p_{t+1})\n", - "```\n", - "\n", - "It is useful to regard equation {eq}`lteeqs102` as a generalization of equation {eq}`rnapex`\n", - "\n", - "* In equation {eq}`rnapex`, the stochastic discount factor $m_{t+1} = \\beta$, a constant.\n", - "* In equation {eq}`rnapex`, the covariance term ${\\rm cov}_t (m_{t+1}, d_{t+1}+ p_{t+1})$ is zero because $m_{t+1} = \\beta$.\n", - "* In equation {eq}`rnapex`, ${\\mathbb E}_t m_{t+1}$ can be interpreted as the reciprocal of the one-period risk-free gross interest rate.\n", - "* When $m_{t+1}$ covaries more negatively with the payout $p_{t+1} + d_{t+1}$, the price of the asset is lower.\n", - "\n", - "Equation {eq}`lteeqs102` asserts that the covariance of the stochastic discount factor with the one period payout $d_{t+1} + p_{t+1}$ is an important determinant of the price $p_t$.\n", - "\n", - "We give examples of some models of stochastic discount factors that have been proposed later in this lecture and also in a {doc}`later lecture`.\n", - "\n", - "### The price-dividend ratio\n", - "\n", - "Aside from prices, another quantity of interest is the **price-dividend ratio** $v_t := p_t / d_t$.\n", - "\n", - "Let's write down an expression that this ratio should satisfy.\n", - "\n", - "We can divide both sides of {eq}`lteeqs0` by $d_t$ to get\n", - "\n", - "```{math}\n", - ":label: pdex\n", - "\n", - "v_t = {\\mathbb E}_t \\left[ m_{t+1} \\frac{d_{t+1}}{d_t} (1 + v_{t+1}) \\right]\n", - "```\n", - "\n", - "Below we'll discuss the implication of this equation.\n", - "\n", - "## Prices in the risk-neutral case\n", - "\n", - "What can we say about price dynamics on the basis of the models described above?\n", - "\n", - "The answer to this question depends on\n", - "\n", - "1. the process we specify for dividends\n", - "1. the stochastic discount factor and how it correlates with dividends\n", - "\n", - "For now we'll study the risk-neutral case in which the stochastic discount factor is constant.\n", - "\n", - "We'll focus on how an asset price depends on a dividend process.\n", - "\n", - "### Example 1: constant dividends\n", - "\n", - "The simplest case is risk-neutral price of a constant, non-random dividend stream $d_t = d > 0$.\n", - "\n", - "Removing the expectation from {eq}`rnapex` and iterating forward gives\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - " p_t & = \\beta (d + p_{t+1})\n", - " \\\\\n", - " & = \\beta (d + \\beta(d + p_{t+2}))\n", - " \\\\\n", - " & \\quad \\vdots\n", - " \\\\\n", - " & = \\beta (d + \\beta d + \\beta^2 d + \\cdots + \\beta^{k-2} d + \\beta^{k-1} p_{t+k})\n", - "\\end{aligned}\n", - "$$\n", - "\n", - "If $\\lim_{k \\rightarrow + \\infty} \\beta^{k-1} p_{t+k} = 0$, this sequence converges to\n", - "\n", - "```{math}\n", - ":label: ddet\n", - "\n", - "\\bar p := \\frac{\\beta d}{1-\\beta}\n", - "```\n", - "\n", - "This is the equilibrium price in the constant dividend case.\n", - "\n", - "Indeed, simple algebra shows that setting $p_t = \\bar p$ for all $t$\n", - "satisfies the difference equation $p_t = \\beta (d + p_{t+1})$.\n", - "\n", - "### Example 2: dividends with deterministic growth paths\n", - "\n", - "Consider a growing, non-random dividend process $d_{t+1} = g d_t$\n", - "where $0 < g \\beta < 1$.\n", - "\n", - "While prices are not usually constant when dividends grow over time, a price\n", - "dividend-ratio can be.\n", - "\n", - "If we guess this, substituting $v_t = v$ into {eq}`pdex` as well as our\n", - "other assumptions, we get $v = \\beta g (1 + v)$.\n", - "\n", - "Since $\\beta g < 1$, we have a unique positive solution:\n", - "\n", - "$$\n", - "v = \\frac{\\beta g}{1 - \\beta g }\n", - "$$\n", - "\n", - "The price is then\n", - "\n", - "$$\n", - "p_t = \\frac{\\beta g}{1 - \\beta g } d_t\n", - "$$\n", - "\n", - "If, in this example, we take $g = 1+\\kappa$ and let\n", - "$\\rho := 1/\\beta - 1$, then the price becomes\n", - "\n", - "$$\n", - "p_t = \\frac{1 + \\kappa}{ \\rho - \\kappa} d_t\n", - "$$\n", - "\n", - "This is called the *Gordon formula*.\n", - "\n", - "(mass_mg)=\n", - "### Example 3: Markov growth, risk-neutral pricing\n", - "\n", - "Next, we consider a dividend process\n", - "\n", - "```{math}\n", - ":label: mass_fmce\n", - "\n", - "d_{t+1} = g_{t+1} d_t\n", - "```\n", - "\n", - "The stochastic growth factor $\\{g_t\\}$ is given by\n", - "\n", - "$$\n", - "g_t = g(X_t), \\quad t = 1, 2, \\ldots\n", - "$$\n", - "\n", - "where\n", - "\n", - "1. $\\{X_t\\}$ is a finite Markov chain with state space $S$ and\n", - " transition probabilities\n", - "\n", - " $$\n", - " P(x, y) := \\mathbb P \\{ X_{t+1} = y \\,|\\, X_t = x \\}\n", - " \\qquad (x, y \\in S)\n", - " $$\n", - "\n", - "1. $g$ is a given function on $S$ taking nonnegative values\n", - "\n", - "You can think of\n", - "\n", - "* $S$ as $n$ possible \"states of the world\" and $X_t$ as the\n", - " current state.\n", - "* $g$ as a function that maps a given state $X_t$ into a growth of dividends\n", - " factor $g_t = g(X_t)$.\n", - "* $\\ln g_t = \\ln (d_{t+1} / d_t)$ is the growth rate of dividends.\n", - "\n", - "(For a refresher on notation and theory for finite Markov chains see {doc}`this lecture `)\n", - "\n", - "The next figure shows a simulation, where\n", - "\n", - "* $\\{X_t\\}$ evolves as a discretized AR1 process produced using {ref}`Tauchen's method `.\n", - "* $g_t = \\exp(X_t)$, so that $\\ln g_t = X_t$ is the growth rate." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "75117970", - "metadata": { - "mystnb": { - "figure": { - "caption": "State, growth, and dividend simulation\n", - "name": "fig_markov_sim" - } - } - }, - "outputs": [ + "cells": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n = 7\n", - "mc = qe.tauchen(n, 0.96, 0.25)\n", - "sim_length = 80\n", - "\n", - "x_series = mc.simulate(sim_length, init=jnp.median(mc.state_values))\n", - "g_series = jnp.exp(x_series)\n", - "d_series = jnp.cumprod(g_series) # Assumes d_0 = 1\n", - "\n", - "series = [x_series, g_series, d_series, jnp.log(d_series)]\n", - "labels = ['$X_t$', '$g_t$', '$d_t$', r'$\\log \\, d_t$']\n", - "\n", - "fig, axes = plt.subplots(2, 2)\n", - "for ax, s, label in zip(axes.flatten(), series, labels):\n", - " ax.plot(s, 'b-', lw=2, label=label)\n", - " ax.legend(loc='upper left', frameon=False)\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "5698f7fc", - "metadata": {}, - "source": [ - "#### Pricing formula\n", - "\n", - "To obtain asset prices in this setting, let's adapt our analysis from the case of deterministic growth.\n", - "\n", - "In that case, we found that $v$ is constant.\n", - "\n", - "This encourages us to guess that, in the current case, $v_t$ is a fixed function of the state $X_t$.\n", - "\n", - "We seek a function $v$ such that the price-dividend ratio satisfies $v_t = v(X_t)$.\n", - "\n", - "We can substitute this guess into {eq}`pdex` to get\n", - "\n", - "$$\n", - "v(X_t) = \\beta {\\mathbb E}_t [ g(X_{t+1}) (1 + v(X_{t+1})) ]\n", - "$$\n", - "\n", - "If we condition on $X_t = x$, this becomes\n", - "\n", - "$$\n", - "v(x) = \\beta \\sum_{y \\in S} g(y) (1 + v(y)) P(x, y)\n", - "$$\n", - "\n", - "or\n", - "\n", - "```{math}\n", - ":label: pstack\n", - "\n", - "v(x) = \\beta \\sum_{y \\in S} K(x, y) (1 + v(y))\n", - "\\quad \\text{where} \\quad\n", - "K(x, y) := g(y) P(x, y)\n", - "```\n", - "\n", - "Suppose that there are $n$ possible states $x_1, \\ldots, x_n$.\n", - "\n", - "We can then think of {eq}`pstack` as $n$ stacked equations, one for each state, and write it in matrix form as\n", - "\n", - "```{math}\n", - ":label: vcumrn\n", - "\n", - "v = \\beta K (\\mathbb 1 + v)\n", - "```\n", - "\n", - "Here\n", - "\n", - "* $v$ is understood to be the column vector $(v(x_1), \\ldots, v(x_n))'$.\n", - "* $K$ is the matrix $(K(x_i, x_j))_{1 \\leq i, j \\leq n}$.\n", - "* ${\\mathbb 1}$ is a column vector of ones.\n", - "\n", - "When does equation {eq}`vcumrn` have a unique solution?\n", - "\n", - "From the {ref}`Neumann series lemma ` and Gelfand's formula, equation {eq}`vcumrn` has a unique solution when $\\beta K$ has spectral radius strictly less than one.\n", - "\n", - "Thus, we require that the eigenvalues of $K$ be strictly less than $\\beta^{-1}$ in modulus.\n", - "\n", - "The solution is then\n", - "\n", - "```{math}\n", - ":label: rned\n", - "\n", - "v = (I - \\beta K)^{-1} \\beta K{\\mathbb 1}\n", - "```\n", - "\n", - "### Code\n", - "\n", - "Let's calculate and plot the price-dividend ratio at some parameters.\n", - "\n", - "As before, we'll generate $\\{X_t\\}$ as a {ref}`discretized AR1 process ` and set $g_t = \\exp(X_t)$.\n", - "\n", - "Here's the code, including a test of the spectral radius condition" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "6c41daf4", - "metadata": { - "mystnb": { - "figure": { - "caption": "Price-dividend ratio risk-neutral case\n", - "name": "fig_pdv_neutral" - } - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 2, + "id": "ce7fce98", + "metadata": { + "id": "ce7fce98" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import quantecon as qe\n", + "import jax\n", + "import jax.numpy as jnp\n", + "from jax.numpy.linalg import eigvals, solve\n", + "from jax.experimental import checkify\n", + "from typing import NamedTuple" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n = 25 # Size of state space\n", - "β = 0.9\n", - "mc = qe.tauchen(n, 0.96, 0.02)\n", - "\n", - "K = mc.P * jnp.exp(mc.state_values)\n", - "\n", - "warning_message = \"Spectral radius condition fails\"\n", - "assert jnp.max(jnp.abs(eigvals(K))) < 1 / β, warning_message\n", - "\n", - "I = jnp.identity(n)\n", - "v = solve(I - β * K, β * K @ jnp.ones(n))\n", - "\n", - "fig, ax = plt.subplots()\n", - "ax.plot(mc.state_values, v, 'g-o', lw=2, alpha=0.7, label='$v$')\n", - "ax.set_ylabel(\"price-dividend ratio\")\n", - "ax.set_xlabel(\"state\")\n", - "ax.legend(loc='upper left')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ded89da8", - "metadata": {}, - "source": [ - "Why does the price-dividend ratio increase with the state?\n", - "\n", - "The reason is that this Markov process is positively correlated, so high\n", - "current states suggest high future states.\n", - "\n", - "Moreover, dividend growth is increasing in the state.\n", - "\n", - "The anticipation of high future dividend growth leads to a high price-dividend ratio.\n", - "\n", - "## Risk Aversion and Asset Prices\n", - "\n", - "Now let's turn to the case where agents are risk averse.\n", - "\n", - "We'll price several distinct assets, including\n", - "\n", - "* An endowment stream\n", - "* A consol (a type of bond issued by the UK government in the 19th century)\n", - "* Call options on a consol\n", - "\n", - "### Pricing a Lucas tree\n", - "\n", - "```{index} single: Finite Markov Asset Pricing; Lucas Tree\n", - "```\n", - "\n", - "Let's start with a version of the celebrated asset pricing model of Robert E. Lucas, Jr. {cite}`Lucas1978`.\n", - "\n", - "Lucas considered an abstract pure exchange economy with these features:\n", - "\n", - "* a single non-storable consumption good\n", - "* a Markov process that governs the total amount of the consumption good available each period\n", - "* a single *tree* that each period yields *fruit* that equals the total amount of consumption available to the economy\n", - "* a competitive market in *shares* in the tree that entitles their owners to corresponding shares of the *dividend* stream, i.e., the *fruit* stream, yielded by the tree\n", - "\n", - "* a representative consumer who in a competitive equilibrium\n", - "\n", - " * consumes the economy's entire endowment each period\n", - " * owns 100 percent of the shares in the tree\n", - "\n", - "As in {cite}`Lucas1978`, we suppose that the stochastic discount factor takes the form\n", - "\n", - "```{math}\n", - ":label: lucsdf\n", - "\n", - "m_{t+1} = \\beta \\frac{u'(c_{t+1})}{u'(c_t)}\n", - "```\n", - "\n", - "where $u$ is a concave utility function and $c_t$ is time $t$ consumption of a representative consumer.\n", - "\n", - "(A derivation of this expression is given in a {doc}`later lecture`)\n", - "\n", - "Assume the existence of an endowment that follows growth process {eq}`mass_fmce`.\n", - "\n", - "The asset being priced is a claim on the endowment process, i.e., the *Lucas tree* described above.\n", - "\n", - "Following {cite}`Lucas1978`, we suppose that in equilibrium the representative consumer's consumption equals the aggregate endowment, so that $d_t = c_t$ for all $t$.\n", - "\n", - "For utility, we'll assume the **constant relative risk aversion** (CRRA)\n", - "specification\n", - "\n", - "```{math}\n", - ":label: eqCRRA\n", - "\n", - "u(c) = \\frac{c^{1-\\gamma}}{1 - \\gamma} \\ {\\rm with} \\ \\gamma > 0\n", - "```\n", - "\n", - "When $\\gamma =1$ we let $u(c) = \\ln c$.\n", - "\n", - "Inserting the CRRA specification into {eq}`lucsdf` and using $c_t = d_t$ gives\n", - "\n", - "```{math}\n", - ":label: lucsdf2\n", - "\n", - "m_{t+1}\n", - "= \\beta \\left(\\frac{c_{t+1}}{c_t}\\right)^{-\\gamma}\n", - "= \\beta g_{t+1}^{-\\gamma}\n", - "```\n", - "\n", - "Substituting this into {eq}`pdex` gives the price-dividend ratio\n", - "formula\n", - "\n", - "$$\n", - "v(X_t)\n", - "= \\beta {\\mathbb E}_t\n", - "\\left[\n", - " g(X_{t+1})^{1-\\gamma} (1 + v(X_{t+1}) )\n", - "\\right]\n", - "$$ (eq:neweqn101)\n", - "\n", - "Conditioning on $X_t = x$, we can write this as\n", - "\n", - "$$\n", - "v(x)\n", - "= \\beta \\sum_{y \\in S} g(y)^{1-\\gamma} (1 + v(y) ) P(x, y)\n", - "$$\n", - "\n", - "If we let\n", - "\n", - "$$\n", - "J(x, y) := g(y)^{1-\\gamma} P(x, y)\n", - "$$\n", - "\n", - "then we can rewrite equation {eq}`eq:neweqn101` in vector form as\n", - "\n", - "$$\n", - "v = \\beta J ({\\mathbb 1} + v )\n", - "$$\n", - "\n", - "Assuming that the spectral radius of $J$ is strictly less than $\\beta^{-1}$, this equation has the unique solution\n", - "\n", - "```{math}\n", - ":label: resolvent2\n", - "\n", - "v = (I - \\beta J)^{-1} \\beta J {\\mathbb 1}\n", - "```\n", - "\n", - "We will define a function `tree_price` to compute $v$ given parameters stored in\n", - "the class `AssetPriceModel`" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "b7bcf31f", - "metadata": {}, - "outputs": [], - "source": [ - "class MarkovChain(NamedTuple):\n", - " \"\"\"\n", - " A class that stores the primitives of a Markov chain.\n", - " Parameters\n", - " ----------\n", - " P : jnp.ndarray\n", - " Transition matrix\n", - " state_values : jnp.ndarray\n", - " The values associated with each state\n", - " \"\"\"\n", - " P: jax.Array\n", - " state_values: jax.Array\n", - "\n", - "\n", - "class AssetPriceModel(NamedTuple):\n", - " \"\"\"\n", - " A class that stores the primitives of the asset pricing model.\n", - "\n", - " Parameters\n", - " ----------\n", - " mc : MarkovChain\n", - " Contains the transition matrix and set of state values\n", - " G : jax.Array\n", - " The vector form of the function mapping states to growth rates\n", - " β : float\n", - " Discount factor\n", - " γ : float\n", - " Coefficient of risk aversion\n", - " \"\"\"\n", - " mc: MarkovChain\n", - " G: jax.Array\n", - " β: float\n", - " γ: float\n", - " \n", - "\n", - "def create_ap_model(g=jnp.exp, β=0.96, γ=2.0):\n", - " \"\"\"Create an AssetPriceModel class using standard Markov chain.\"\"\"\n", - " n, ρ, σ = 25, 0.9, 0.02\n", - " qe_mc = qe.tauchen(n, ρ, σ)\n", - " P = jnp.array(qe_mc.P)\n", - " state_values = jnp.array(qe_mc.state_values)\n", - " G = g(state_values)\n", - " mc = MarkovChain(P=P, state_values=state_values)\n", - "\n", - " return AssetPriceModel(mc=mc, G=G, β=β, γ=γ)\n", - "\n", - "\n", - "def create_customized_ap_model(mc: MarkovChain, g=jnp.exp, β=0.96, γ=2.0):\n", - " \"\"\"Create an AssetPriceModel class using a customized Markov chain.\"\"\"\n", - " G = g(mc.state_values)\n", - " return AssetPriceModel(mc=mc, G=G, β=β, γ=γ)\n", - "\n", - "\n", - "def test_stability(Q, β):\n", - " \"\"\"Stability test for a given matrix Q.\"\"\"\n", - " sr = jnp.max(jnp.abs(eigvals(Q)))\n", - " checkify.check(\n", - " sr < 1 / β, \n", - " \"Spectral radius condition failed with radius = {sr}\", sr=sr\n", - " )\n", - " return sr\n", - "\n", - "\n", - "def tree_price(ap):\n", - " \"\"\"\n", - " Computes the price-dividend ratio of the Lucas tree.\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - "\n", - " Returns\n", - " -------\n", - " v : array_like(float)\n", - " Lucas tree price-dividend ratio\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", - " J = P * G**(1 - γ)\n", - "\n", - " # Make sure that a unique solution exists\n", - " test_stability(J, β)\n", - "\n", - " # Compute v\n", - " n = J.shape[0]\n", - " I = jnp.identity(n)\n", - " Ones = jnp.ones(n)\n", - " v = solve(I - β * J, β * J @ Ones)\n", - "\n", - " return v\n", - "\n", - "# Wrap the function to be safely jitted\n", - "tree_price_jit = jax.jit(checkify.checkify(tree_price))" - ] - }, - { - "cell_type": "markdown", - "id": "265ecf44", - "metadata": {}, - "source": [ - "Here's a plot of $v$ as a function of the state for several values of $\\gamma$,\n", - "with a positively correlated Markov process and $g(x) = \\exp(x)$" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "959364d2", - "metadata": { - "mystnb": { - "figure": { - "caption": "Lucas tree prices for varying risk aversion\n", - "name": "fig_lucas_gamma" - } - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Compute price-dividend ratio of Lucas tree:: 0.37 ms elapsed\n", - "Compute price-dividend ratio of Lucas tree:: 0.08 ms elapsed\n", - "Compute price-dividend ratio of Lucas tree:: 0.04 ms elapsed\n", - "Compute price-dividend ratio of Lucas tree:: 0.05 ms elapsed\n", - "Compute price-dividend ratio of Lucas tree:: 0.05 ms elapsed\n" - ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 3, + "id": "b7bcf31f", + "metadata": { + "id": "b7bcf31f" + }, + "outputs": [], + "source": [ + "class MarkovChain(NamedTuple):\n", + " \"\"\"\n", + " A class that stores the primitives of a Markov chain.\n", + " Parameters\n", + " ----------\n", + " P : jnp.ndarray\n", + " Transition matrix\n", + " state_values : jnp.ndarray\n", + " The values associated with each state\n", + " \"\"\"\n", + " P: jax.Array\n", + " state_values: jax.Array\n", + "\n", + "\n", + "class AssetPriceModel(NamedTuple):\n", + " \"\"\"\n", + " A class that stores the primitives of the asset pricing model.\n", + "\n", + " Parameters\n", + " ----------\n", + " mc : MarkovChain\n", + " Contains the transition matrix and set of state values\n", + " G : jax.Array\n", + " The vector form of the function mapping states to growth rates\n", + " β : float\n", + " Discount factor\n", + " γ : float\n", + " Coefficient of risk aversion\n", + " \"\"\"\n", + " mc: MarkovChain\n", + " G: jax.Array\n", + " β: float\n", + " γ: float\n", + "\n", + "\n", + "def create_ap_model(g=jnp.exp, β=0.96, γ=2.0):\n", + " \"\"\"Create an AssetPriceModel class using standard Markov chain.\"\"\"\n", + " n, ρ, σ = 25, 0.9, 0.02\n", + " qe_mc = qe.tauchen(n, ρ, σ)\n", + " P = jnp.array(qe_mc.P)\n", + " state_values = jnp.array(qe_mc.state_values)\n", + " G = g(state_values)\n", + " mc = MarkovChain(P=P, state_values=state_values)\n", + "\n", + " return AssetPriceModel(mc=mc, G=G, β=β, γ=γ)\n", + "\n", + "\n", + "def create_customized_ap_model(mc: MarkovChain, g=jnp.exp, β=0.96, γ=2.0):\n", + " \"\"\"Create an AssetPriceModel class using a customized Markov chain.\"\"\"\n", + " G = g(mc.state_values)\n", + " return AssetPriceModel(mc=mc, G=G, β=β, γ=γ)\n", + "\n", + "\n", + "def test_stability(Q, β):\n", + " \"\"\"Stability test for a given matrix Q.\"\"\"\n", + " sr = jnp.max(jnp.abs(eigvals(Q)))\n", + " checkify.check(\n", + " sr < 1 / β,\n", + " \"Spectral radius condition failed with radius = {sr}\", sr=sr\n", + " )\n", + " return sr\n", + "\n", + "\n", + "def tree_price(ap):\n", + " \"\"\"\n", + " Computes the price-dividend ratio of the Lucas tree.\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + "\n", + " Returns\n", + " -------\n", + " v : array_like(float)\n", + " Lucas tree price-dividend ratio\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", + " J = P * G**(1 - γ)\n", + "\n", + " # Make sure that a unique solution exists\n", + " test_stability(J, β)\n", + "\n", + " # Compute v\n", + " n = J.shape[0]\n", + " I = jnp.identity(n)\n", + " Ones = jnp.ones(n)\n", + " v = solve(I - β * J, β * J @ Ones)\n", + "\n", + " return v\n", + "\n", + "# Wrap the function to be safely jitted\n", + "tree_price_jit = jax.jit(checkify.checkify(tree_price))" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "γs = [1.2, 1.4, 1.6, 1.8, 2.0]\n", - "ap = create_ap_model()\n", - "states = ap.mc.state_values\n", - "\n", - "fig, ax = plt.subplots()\n", - "\n", - "for γ in γs:\n", - " tem_ap = create_customized_ap_model(ap.mc, γ=γ)\n", - " # checkify returns a tuple\n", - " # err indicates whether errors happened\n", - " err, v = tree_price_jit(tem_ap)\n", - " # Stop if errors raised\n", - " err.throw()\n", - " ax.plot(states, v, lw=2, alpha=0.6, label=rf\"$\\gamma = {γ}$\")\n", - "\n", - "ax.set_ylabel(\"price-dividend ratio\")\n", - "ax.set_xlabel(\"state\")\n", - "ax.legend(loc='upper right')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "b6c03815", - "metadata": {}, - "source": [ - "Notice that $v$ is decreasing in each case.\n", - "\n", - "This is because, with a positively correlated state process, higher states indicate higher future consumption growth.\n", - "\n", - "With the stochastic discount factor {eq}`lucsdf2`, higher growth decreases the\n", - "discount factor, lowering the weight placed on future dividends.\n", - "\n", - "#### Special Cases\n", - "\n", - "In the special case $\\gamma =1$, we have $J = P$.\n", - "\n", - "Recalling that $P^i {\\mathbb 1} = {\\mathbb 1}$ for all $i$ and applying {ref}`Neumann's geometric series lemma `, we are led to\n", - "\n", - "$$\n", - "v = \\beta(I-\\beta P)^{-1} {\\mathbb 1}\n", - "= \\beta \\sum_{i=0}^{\\infty} \\beta^i P^i {\\mathbb 1}\n", - "= \\beta \\frac{1}{1 - \\beta} {\\mathbb 1}\n", - "$$\n", - "\n", - "Thus, with log preferences, the price-dividend ratio for a Lucas tree is constant.\n", - "\n", - "Alternatively, if $\\gamma = 0$, then $J = K$ and we recover the\n", - "risk-neutral solution {eq}`rned`.\n", - "\n", - "This is as expected, since $\\gamma = 0$ implies $u(c) = c$ (and hence agents are risk-neutral).\n", - "\n", - "### A Risk-Free Consol\n", - "\n", - "Consider the same pure exchange representative agent economy.\n", - "\n", - "A risk-free consol promises to pay a constant amount $\\zeta> 0$ each period.\n", - "\n", - "Recycling notation, let $p_t$ now be the price of an ex-coupon claim to the consol.\n", - "\n", - "An ex-coupon claim to the consol entitles an owner at the end of period $t$ to\n", - "\n", - "* $\\zeta$ in period $t+1$, plus\n", - "* the right to sell the claim for $p_{t+1}$ next period\n", - "\n", - "The price satisfies {eq}`lteeqs0` with $d_t = \\zeta$, or\n", - "\n", - "$$\n", - "p_t = {\\mathbb E}_t \\left[ m_{t+1} ( \\zeta + p_{t+1} ) \\right]\n", - "$$\n", - "\n", - "With the stochastic discount factor {eq}`lucsdf2`, this becomes\n", - "\n", - "```{math}\n", - ":label: consolguess1\n", - "\n", - "p_t\n", - "= {\\mathbb E}_t \\left[ \\beta g_{t+1}^{-\\gamma} ( \\zeta + p_{t+1} ) \\right]\n", - "```\n", - "\n", - "Guessing a solution of the form $p_t = p(X_t)$ and conditioning on\n", - "$X_t = x$, we get\n", - "\n", - "$$\n", - "p(x)\n", - "= \\beta \\sum_{y \\in S} g(y)^{-\\gamma} (\\zeta + p(y)) P(x, y)\n", - "$$\n", - "\n", - "Letting $M(x, y) = P(x, y) g(y)^{-\\gamma}$ and rewriting in vector notation\n", - "yields the solution\n", - "\n", - "```{math}\n", - ":label: consol_price\n", - "\n", - "p = (I - \\beta M)^{-1} \\beta M \\zeta {\\mathbb 1}\n", - "```\n", - "\n", - "The above is implemented in the function `consol_price`." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "29a2f7a6", - "metadata": {}, - "outputs": [], - "source": [ - "def consol_price(ap, ζ):\n", - " \"\"\"\n", - " Computes price of a consol bond with payoff ζ\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - " \n", - " ζ : scalar(float)\n", - " Coupon of the console\n", - "\n", - " Returns\n", - " -------\n", - " p : array_like(float)\n", - " Console bond prices\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", - " M = P * G**(- γ)\n", - "\n", - " # Make sure that a unique solution exists\n", - " test_stability(M, β)\n", - "\n", - " # Compute price\n", - " n = M.shape[0]\n", - " I = jnp.identity(n)\n", - " Ones = jnp.ones(n)\n", - " p = solve(I - β * M, β * ζ * M @ Ones)\n", - "\n", - " return p\n", - "\n", - "# Wrap the function to be safely jitted\n", - "consol_price_jit = jax.jit(checkify.checkify(consol_price))" - ] - }, - { - "cell_type": "markdown", - "id": "b6022349", - "metadata": {}, - "source": [ - "### Pricing an Option to Purchase the Consol\n", - "\n", - "Let's now price options of various maturities.\n", - "\n", - "We'll study an option that gives the owner the right to purchase a consol at a price $p_S$.\n", - "\n", - "#### An Infinite Horizon Call Option\n", - "\n", - "We want to price an *infinite horizon* option to purchase a consol at a price $p_S$.\n", - "\n", - "The option entitles the owner at the beginning of a period either\n", - "\n", - "1. to purchase the bond at price $p_S$ now, or\n", - "1. not to exercise the option to purchase the asset now but to retain the right to exercise it later\n", - "\n", - "Thus, the owner either *exercises* the option now or chooses *not to exercise* and wait until next period.\n", - "\n", - "This is termed an infinite-horizon *call option* with *strike price* $p_S$.\n", - "\n", - "The owner of the option is entitled to purchase the consol at price $p_S$ at the beginning of any period, after the coupon has been paid to the previous owner of the bond.\n", - "\n", - "The fundamentals of the economy are identical with the one above, including the stochastic discount factor and the process for consumption.\n", - "\n", - "Let $w(X_t, p_S)$ be the value of the option when the time $t$ growth state is known to be $X_t$ but *before* the owner has decided whether to exercise the option\n", - "at time $t$ (i.e., today).\n", - "\n", - "Recalling that $p(X_t)$ is the value of the consol when the initial growth state is $X_t$, the value of the option satisfies\n", - "\n", - "$$\n", - "w(X_t, p_S)\n", - "= \\max \\left\\{\n", - " \\beta \\, {\\mathbb E}_t \\frac{u'(c_{t+1})}{u'(c_t)} w(X_{t+1}, p_S), \\;\n", - " p(X_t) - p_S\n", - "\\right\\}\n", - "$$\n", - "\n", - "The first term on the right is the value of waiting, while the second is the value of exercising now.\n", - "\n", - "We can also write this as\n", - "\n", - "```{math}\n", - ":label: FEoption0\n", - "\n", - "w(x, p_S)\n", - "= \\max \\left\\{\n", - " \\beta \\sum_{y \\in S} P(x, y) g(y)^{-\\gamma}\n", - " w (y, p_S), \\;\n", - " p(x) - p_S\n", - "\\right\\}\n", - "```\n", - "\n", - "With $M(x, y) = P(x, y) g(y)^{-\\gamma}$ and $w$ as the vector of\n", - "values $(w(x_i), p_S)_{i = 1}^n$, we can express {eq}`FEoption0` as the nonlinear vector equation\n", - "\n", - "```{math}\n", - ":label: FEoption\n", - "\n", - "w = \\max \\{ \\beta M w, \\; p - p_S {\\mathbb 1} \\}\n", - "```\n", - "\n", - "To solve {eq}`FEoption`, form an operator $T$ that maps vector $w$\n", - "into vector $Tw$ via\n", - "\n", - "$$\n", - "T w\n", - "= \\max \\{ \\beta M w,\\; p - p_S {\\mathbb 1} \\}\n", - "$$\n", - "\n", - "Start at some initial $w$ and iterate with $T$ to convergence.\n", - "\n", - "We can find the solution with the following function `call_option`" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "8cfa0f41", - "metadata": {}, - "outputs": [], - "source": [ - "def call_option(ap, ζ, p_s, ϵ=1e-7):\n", - " \"\"\"\n", - " Computes price of a call option on a consol bond.\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - "\n", - " ζ : scalar(float)\n", - " Coupon of the console\n", - "\n", - " p_s : scalar(float)\n", - " Strike price\n", - "\n", - " ϵ : scalar(float), optional(default=1e-7)\n", - " Tolerance for infinite horizon problem\n", - "\n", - " Returns\n", - " -------\n", - " w : array_like(float)\n", - " Infinite horizon call option prices\n", - "\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", - " M = P * G**(- γ)\n", - "\n", - " # Make sure that a unique consol price exists\n", - " test_stability(M, β)\n", - "\n", - " # Compute option price\n", - " p = consol_price(ap, ζ)\n", - " err.throw()\n", - " n = M.shape[0]\n", - " w = jnp.zeros(n)\n", - " error = ϵ + 1\n", - "\n", - " def step(state):\n", - " w, _ = state\n", - " # Maximize across columns\n", - " w_new = jnp.maximum(β * M @ w, p - p_s)\n", - " # Find maximal difference of each component and update\n", - " error_new = jnp.amax(jnp.abs(w - w_new))\n", - " return (w_new, error_new)\n", - "\n", - " # Check whether converged\n", - " def cond(state):\n", - " _, error = state\n", - " return error > ϵ\n", - "\n", - " final_w, _ = jax.lax.while_loop(cond, step, (w, error))\n", - "\n", - " return final_w\n", - "\n", - "call_option_jit = jax.jit(checkify.checkify(call_option))" - ] - }, - { - "cell_type": "markdown", - "id": "21192c28", - "metadata": {}, - "source": [ - "Here's a plot of $w$ compared to the consol price when $P_S = 40$" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7179ea30", - "metadata": { - "mystnb": { - "figure": { - "caption": "Consol price and call option value\n", - "name": "fig_consol_call" - } - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Compute consol price Jit: 0.20 ms elapsed\n", - "Compute call option price: 0.21 ms elapsed\n" - ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 4, + "id": "29a2f7a6", + "metadata": { + "id": "29a2f7a6" + }, + "outputs": [], + "source": [ + "def consol_price(ap, ζ):\n", + " \"\"\"\n", + " Computes price of a consol bond with payoff ζ\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + "\n", + " ζ : scalar(float)\n", + " Coupon of the console\n", + "\n", + " Returns\n", + " -------\n", + " p : array_like(float)\n", + " Console bond prices\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", + " M = P * G**(- γ)\n", + "\n", + " # Make sure that a unique solution exists\n", + " test_stability(M, β)\n", + "\n", + " # Compute price\n", + " n = M.shape[0]\n", + " I = jnp.identity(n)\n", + " Ones = jnp.ones(n)\n", + " p = solve(I - β * M, β * ζ * M @ Ones)\n", + "\n", + " return p\n", + "\n", + "# Wrap the function to be safely jitted\n", + "consol_price_jit = jax.jit(checkify.checkify(consol_price))" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ap = create_ap_model(β=0.9)\n", - "ζ = 1.0\n", - "strike_price = 40\n", - "\n", - "x = ap.mc.state_values\n", - "err, p = consol_price_jit(ap, ζ)\n", - "err.throw()\n", - "err, w = call_option_jit(ap, ζ, strike_price)\n", - "err.throw()\n", - "\n", - "fig, ax = plt.subplots()\n", - "ax.plot(x, p, 'b-', lw=2, label='consol price')\n", - "ax.plot(x, w, 'g-', lw=2, label='value of call option')\n", - "ax.set_xlabel(\"state\")\n", - "ax.legend(loc='upper right')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "fea37311", - "metadata": {}, - "source": [ - "In high values of the Markov growth state, the value of the option is close to zero.\n", - "\n", - "This is despite the facts that the Markov chain is irreducible and that low states ---\n", - "where the consol prices are high --- will be visited recurrently.\n", - "\n", - "The reason for low valuations in high Markov growth states is that $\\beta=0.9$, so future payoffs are discounted substantially.\n", - "\n", - "### Risk-Free Rates\n", - "\n", - "Let's look at risk-free interest rates over different periods.\n", - "\n", - "#### The One-period Risk-free Interest Rate\n", - "\n", - "As before, the stochastic discount factor is $m_{t+1} = \\beta g_{t+1}^{-\\gamma}$.\n", - "\n", - "It follows that the reciprocal $R_t^{-1}$ of the gross risk-free interest rate $R_t$ in state $x$ is\n", - "\n", - "$$\n", - "{\\mathbb E}_t m_{t+1} = \\beta \\sum_{y \\in S} P(x, y) g(y)^{-\\gamma}\n", - "$$\n", - "\n", - "We can write this as\n", - "\n", - "$$\n", - "m_1 = \\beta M {\\mathbb 1}\n", - "$$\n", - "\n", - "where the $i$-th element of $m_1$ is the reciprocal of the one-period gross risk-free interest rate in state $x_i$.\n", - "\n", - "#### Other Terms\n", - "\n", - "Let $m_j$ be an $n \\times 1$ vector whose $i$ th component is the reciprocal of the $j$ -period gross risk-free interest rate in state $x_i$.\n", - "\n", - "Then $m_1 = \\beta M$, and $m_{j+1} = M m_j$ for $j \\geq 1$.\n", - "\n", - "## Exercises\n", - "\n", - "```{exercise}\n", - ":label: ma_ex1\n", - "\n", - "In the lecture, we considered **ex-dividend assets**.\n", - "\n", - "A **cum-dividend** asset is a claim to the stream $d_t, d_{t+1}, \\ldots$.\n", - "\n", - "Following {eq}`rnapex`, find the risk-neutral asset pricing equation for\n", - "one unit of a cum-dividend asset.\n", - "\n", - "With a constant, non-random dividend stream $d_t = d > 0$, what is the equilibrium\n", - "price of a cum-dividend asset?\n", - "\n", - "With a growing, non-random dividend process $d_t = g d_t$ where $0 < g \\beta < 1$,\n", - "what is the equilibrium price of a cum-dividend asset?\n", - "```\n", - "\n", - "```{solution} ma_ex1\n", - ":class: dropdown\n", - "\n", - "For a cum-dividend asset, the basic risk-neutral asset pricing equation is\n", - "\n", - "$$\n", - "p_t = d_t + \\beta {\\mathbb E}_t [ p_{t+1} ]\n", - "$$\n", - "\n", - "(mass_ex1)=\n", - "With constant dividends, the equilibrium price is\n", - "\n", - "$$\n", - "p_t = \\frac{1}{1-\\beta} d_t\n", - "$$\n", - "\n", - "With a growing, non-random dividend process, the equilibrium price is\n", - "\n", - "$$\n", - "p_t = \\frac{1}{1 - \\beta g} d_t\n", - "$$\n", - "```\n", - "\n", - "```{exercise-start}\n", - ":label: ma_ex2\n", - "```\n", - "\n", - "Consider the following primitives" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "391b7ed0", - "metadata": {}, - "outputs": [], - "source": [ - "n = 5 # Size of State Space\n", - "P = jnp.full((n, n), 0.0125)\n", - "P = P.at[jnp.arange(n), jnp.arange(n)].set(\n", - " P[jnp.arange(n), jnp.arange(n)] + 1 - P.sum(1)\n", - " )\n", - "# State values of the Markov chain\n", - "s = jnp.array([0.95, 0.975, 1.0, 1.025, 1.05])\n", - "γ = 2.0\n", - "β = 0.94" - ] - }, - { - "cell_type": "markdown", - "id": "3788996d", - "metadata": {}, - "source": [ - "Let $g$ be defined by $g(x) = x$ (that is, $g$ is the identity map).\n", - "\n", - "Compute the price of the Lucas tree.\n", - "\n", - "Do the same for\n", - "\n", - "* the price of the risk-free consol when $\\zeta = 1$\n", - "* the call option on the consol when $\\zeta = 1$ and $p_S = 150.0$\n", - "\n", - "```{exercise-end}\n", - "```\n", - "\n", - "```{solution-start} ma_ex2\n", - ":class: dropdown\n", - "```\n", - "\n", - "First, let's enter the parameters:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "470d5128", - "metadata": {}, - "outputs": [], - "source": [ - "n = 5\n", - "P = jnp.full((n, n), 0.0125)\n", - "P = P.at[jnp.arange(n), jnp.arange(n)].set(\n", - " P[jnp.arange(n), jnp.arange(n)] + 1 - P.sum(1)\n", - " )\n", - "s = jnp.array([0.95, 0.975, 1.0, 1.025, 1.05]) # State values\n", - "mc = MarkovChain(P=P, state_values=s)\n", - "\n", - "γ = 2.0\n", - "β = 0.94\n", - "ζ = 1.0\n", - "p_s = 150.0" - ] - }, - { - "cell_type": "markdown", - "id": "106db117", - "metadata": {}, - "source": [ - "Next, we'll create an instance of `AssetPriceModel` to feed into the\n", - "functions" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "1d7266b9", - "metadata": {}, - "outputs": [], - "source": [ - "apm = create_customized_ap_model(mc=mc, g=lambda x: x, β=β, γ=γ)" - ] - }, - { - "cell_type": "markdown", - "id": "32fa55d6", - "metadata": {}, - "source": [ - "Now we just need to call the relevant functions on the data:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "fe25d419", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[29.474087 21.935726 17.571445 14.72517 12.72224 ]\n" - ] - } - ], - "source": [ - "err, v = tree_price_jit(apm)\n", - "err.throw()\n", - "print(v)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "c01b2432", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[753.92316 242.56683 148.68501 109.25806 87.57421]\n" - ] - } - ], - "source": [ - "err, p = consol_price_jit(apm, ζ)\n", - "err.throw()\n", - "print(p)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "557f6eec", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[603.92316 176.8546 108.686775 80.05874 64.31402 ]\n" - ] - } - ], - "source": [ - "err, w = call_option_jit(apm, ζ, p_s)\n", - "err.throw()\n", - "print(w)" - ] - }, - { - "cell_type": "markdown", - "id": "6fdff8eb", - "metadata": {}, - "source": [ - "Let's show the last two functions as a plot" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "6f1015e7", - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 5, + "id": "8cfa0f41", + "metadata": { + "id": "8cfa0f41" + }, + "outputs": [], + "source": [ + "def call_option(ap, ζ, p_s, ϵ=1e-7):\n", + " \"\"\"\n", + " Computes price of a call option on a consol bond.\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + "\n", + " ζ : scalar(float)\n", + " Coupon of the console\n", + "\n", + " p_s : scalar(float)\n", + " Strike price\n", + "\n", + " ϵ : scalar(float), optional(default=1e-7)\n", + " Tolerance for infinite horizon problem\n", + "\n", + " Returns\n", + " -------\n", + " w : array_like(float)\n", + " Infinite horizon call option prices\n", + "\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", + " M = P * G**(- γ)\n", + "\n", + " # Make sure that a unique consol price exists\n", + " test_stability(M, β)\n", + "\n", + " # Compute option price\n", + " p = consol_price(ap, ζ)\n", + " err.throw()\n", + " n = M.shape[0]\n", + " w = jnp.zeros(n)\n", + " error = ϵ + 1\n", + "\n", + " def step(state):\n", + " w, _ = state\n", + " # Maximize across columns\n", + " w_new = jnp.maximum(β * M @ w, p - p_s)\n", + " # Find maximal difference of each component and update\n", + " error_new = jnp.amax(jnp.abs(w - w_new))\n", + " return (w_new, error_new)\n", + "\n", + " # Check whether converged\n", + " def cond(state):\n", + " _, error = state\n", + " return error > ϵ\n", + "\n", + " final_w, _ = jax.lax.while_loop(cond, step, (w, error))\n", + "\n", + " return final_w\n", + "\n", + "call_option_jit = jax.jit(checkify.checkify(call_option))" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "ax.plot(s, p, label='consol')\n", - "ax.plot(s, w, label='call option')\n", - "ax.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "19c72f7a", - "metadata": {}, - "source": [ - "```{solution-end}\n", - "```\n", - "\n", - "```{exercise}\n", - ":label: ma_ex3\n", - "\n", - "Let's consider finite horizon call options, which are more common than\n", - "infinite horizon ones.\n", - "\n", - "Finite horizon options obey functional equations closely related to {eq}`FEoption0`.\n", - "\n", - "A $k$ period option expires after $k$ periods.\n", - "\n", - "If we view today as date zero, a $k$ period option gives the owner the right to exercise the option to purchase the risk-free consol at the strike price $p_S$ at dates $0, 1, \\ldots , k-1$.\n", - "\n", - "The option expires at time $k$.\n", - "\n", - "Thus, for $k=1, 2, \\ldots$, let $w(x, k)$ be the value of a $k$-period option.\n", - "\n", - "It obeys\n", - "\n", - "$$\n", - "w(x, k)\n", - "= \\max \\left\\{\n", - " \\beta \\sum_{y \\in S} P(x, y) g(y)^{-\\gamma}\n", - " w (y, k-1), \\;\n", - " p(x) - p_S\n", - "\\right\\}\n", - "$$\n", - "\n", - "where $w(x, 0) = 0$ for all $x$.\n", - "\n", - "We can express this as a sequence of nonlinear vector equations\n", - "\n", - "$$\n", - "w_k = \\max \\{ \\beta M w_{k-1}, \\; p - p_S {\\mathbb 1} \\}\n", - " \\quad k =1, 2, \\ldots\n", - " \\quad \\text{with } w_0 = 0\n", - "$$\n", - "\n", - "Write a function that computes $w_k$ for any given $k$.\n", - "\n", - "Compute the value of the option with `k = 5` and `k = 25` using parameter values as in {ref}`ma_ex1`.\n", - "\n", - "Is one higher than the other? Can you give intuition?\n", - "```\n", - "\n", - "```{solution-start} ma_ex3\n", - ":class: dropdown\n", - "```\n", - "\n", - "Here's a suitable function:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "366ea0fd", - "metadata": {}, - "outputs": [], - "source": [ - "def finite_call_option(ap, ζ, p_s, k):\n", - " \"\"\"\n", - " Computes k period option value.\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", - " M = P * G**(- γ)\n", - "\n", - " # Make sure that a unique solution exists\n", - " test_stability(M, β)\n", - "\n", - " # Compute option price\n", - " p = consol_price(ap, ζ)\n", - " n = M.shape[0]\n", - " def step(i, w):\n", - " # Maximize across columns\n", - " w = jnp.maximum(β * M @ w, p - p_s)\n", - " return w\n", - " \n", - " w = jax.lax.fori_loop(0, k, step, jnp.zeros(n))\n", - "\n", - " return w\n", - "\n", - "finite_call_option_jit = jax.jit(\n", - " checkify.checkify(finite_call_option)\n", - " )" - ] - }, - { - "cell_type": "markdown", - "id": "495b19dd", - "metadata": {}, - "source": [ - "Now let's compute the option values at `k=5` and `k=25`" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "7844ffa8", - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 6, + "id": "7179ea30", + "metadata": { + "mystnb": { + "figure": { + "caption": "Consol price and call option value\n", + "name": "fig_consol_call" + } + }, + "id": "7179ea30" + }, + "outputs": [], + "source": [ + "ap = create_ap_model(β=0.9)\n", + "ζ = 1.0\n", + "strike_price = 40\n", + "\n", + "x = ap.mc.state_values\n", + "err, p = consol_price_jit(ap, ζ)\n", + "err.throw()\n", + "err, w = call_option_jit(ap, ζ, strike_price)\n", + "err.throw()\n" ] - }, - "metadata": {}, - "output_type": "display_data" } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "for k in [5, 25]:\n", - " err, w = finite_call_option_jit(apm, ζ, p_s, k)\n", - " err.throw()\n", - " ax.plot(s, w, label=rf'$k = {k}$')\n", - "ax.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f30664ff", - "metadata": {}, - "source": [ - "Not surprisingly, options with larger $k$ are worth more.\n", - "\n", - "This is because an owner has a longer horizon over which\n", - " the option can be exercised.\n", - "\n", - "```{solution-end}\n", - "```" - ] - } - ], - "metadata": { - "jupytext": { - "default_lexer": "ipython" - }, - "kernelspec": { - "display_name": "quantecon", - "language": "python", - "name": "python3" + ], + "metadata": { + "jupytext": { + "default_lexer": "ipython" + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + }, + "colab": { + "provenance": [], + "gpuType": "T4", + "include_colab_link": true + }, + "accelerator": "GPU" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 79cf2882588d775cabadc47f03c761e7acae5962 Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Fri, 6 Feb 2026 16:05:57 +0800 Subject: [PATCH 10/12] Compare the runtime --- lectures/markov_asset.ipynb | 100 ++- lectures/timer_results_jax_cpu.json | 1007 +++++++++++++++++++++++++++ lectures/timer_results_jax_gpu.json | 1007 +++++++++++++++++++++++++++ 3 files changed, 2090 insertions(+), 24 deletions(-) create mode 100644 lectures/timer_results_jax_cpu.json create mode 100644 lectures/timer_results_jax_gpu.json diff --git a/lectures/markov_asset.ipynb b/lectures/markov_asset.ipynb index a9d812790..8420ada2b 100644 --- a/lectures/markov_asset.ipynb +++ b/lectures/markov_asset.ipynb @@ -3,8 +3,8 @@ { "cell_type": "markdown", "metadata": { - "id": "view-in-github", - "colab_type": "text" + "colab_type": "text", + "id": "view-in-github" }, "source": [ "\"Open" @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "id": "ce7fce98", "metadata": { "id": "ce7fce98" @@ -30,7 +30,25 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 13, + "id": "50d12e94", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[CpuDevice(id=0)]\n" + ] + } + ], + "source": [ + "print(jax.devices())" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "id": "b7bcf31f", "metadata": { "id": "b7bcf31f" @@ -135,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 15, "id": "29a2f7a6", "metadata": { "id": "29a2f7a6" @@ -180,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 16, "id": "8cfa0f41", "metadata": { "id": "8cfa0f41" @@ -220,7 +238,6 @@ "\n", " # Compute option price\n", " p = consol_price(ap, ζ)\n", - " err.throw()\n", " n = M.shape[0]\n", " w = jnp.zeros(n)\n", " error = ϵ + 1\n", @@ -247,37 +264,78 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 17, "id": "7179ea30", "metadata": { + "id": "7179ea30", "mystnb": { "figure": { "caption": "Consol price and call option value\n", "name": "fig_consol_call" } - }, - "id": "7179ea30" + } }, "outputs": [], "source": [ "ap = create_ap_model(β=0.9)\n", "ζ = 1.0\n", "strike_price = 40\n", - "\n", "x = ap.mc.state_values\n", - "err, p = consol_price_jit(ap, ζ)\n", - "err.throw()\n", - "err, w = call_option_jit(ap, ζ, strike_price)\n", - "err.throw()\n" + "\n", + "def timer_function():\n", + " err, p = consol_price_jit(ap, ζ)\n", + " err, w = call_option_jit(ap, ζ, strike_price)\n", + "\n", + "result = qe.timeit(\n", + " timer_function, runs=1000, verbose=False, \n", + " results=True, unit=\"milliseconds\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1ec35c54", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results saved to timer_results_jax_cpu.json\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "# result is already a dictionary, no need to call _asdict()\n", + "result_dict = result\n", + "\n", + "# Define the filename\n", + "filename = 'timer_results_jax_cpu.json'\n", + "\n", + "# Save the dictionary to a JSON file\n", + "with open(filename, 'w') as f:\n", + " json.dump(result_dict, f, indent=4)\n", + "\n", + "print(f\"Results saved to {filename}\")" ] } ], "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "include_colab_link": true, + "provenance": [] + }, "jupytext": { "default_lexer": "ipython" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "quantecon", + "language": "python", "name": "python3" }, "language_info": { @@ -291,14 +349,8 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.5" - }, - "colab": { - "provenance": [], - "gpuType": "T4", - "include_colab_link": true - }, - "accelerator": "GPU" + } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/lectures/timer_results_jax_cpu.json b/lectures/timer_results_jax_cpu.json new file mode 100644 index 000000000..f18d2966d --- /dev/null +++ b/lectures/timer_results_jax_cpu.json @@ -0,0 +1,1007 @@ +{ + "elapsed": [ + 0.1983966827392578, + 9.870529174804688e-05, + 4.2438507080078125e-05, + 4.00543212890625e-05, + 4.00543212890625e-05, + 4.267692565917969e-05, + 3.600120544433594e-05, + 3.8623809814453125e-05, + 4.076957702636719e-05, + 3.7670135498046875e-05, + 4.1484832763671875e-05, + 3.457069396972656e-05, + 3.600120544433594e-05, + 3.409385681152344e-05, + 3.457069396972656e-05, + 3.2901763916015625e-05, + 5.841255187988281e-05, + 3.62396240234375e-05, + 9.655952453613281e-05, + 8.511543273925781e-05, + 0.0001938343048095703, + 0.0002701282501220703, + 6.747245788574219e-05, + 0.00013136863708496094, + 0.0001270771026611328, + 0.00015163421630859375, + 0.0001456737518310547, + 0.00012922286987304688, + 0.0001277923583984375, + 0.00012993812561035156, + 0.00013256072998046875, + 0.00013303756713867188, + 0.00012826919555664062, + 0.000141143798828125, + 0.0001270771026611328, + 0.00012755393981933594, + 0.00019311904907226562, + 0.00010895729064941406, + 0.0001773834228515625, + 0.00014662742614746094, + 9.632110595703125e-05, + 0.00031495094299316406, + 0.000164031982421875, + 0.0001583099365234375, + 0.0003082752227783203, + 0.00018095970153808594, + 7.939338684082031e-05, + 0.00012421607971191406, + 0.0001709461212158203, + 0.00013637542724609375, + 0.0001423358917236328, + 0.00013899803161621094, + 0.00013637542724609375, + 0.00017213821411132812, + 0.00012135505676269531, + 0.0001227855682373047, + 0.0001544952392578125, + 0.0001423358917236328, + 0.00013875961303710938, + 0.0001385211944580078, + 0.0001392364501953125, + 0.0001399517059326172, + 0.00013709068298339844, + 0.0001373291015625, + 0.0001430511474609375, + 0.0001380443572998047, + 0.00014209747314453125, + 0.00014257431030273438, + 0.00013637542724609375, + 0.00013947486877441406, + 0.00014066696166992188, + 0.0001392364501953125, + 0.00013780593872070312, + 0.00013971328735351562, + 0.00013756752014160156, + 0.0001399517059326172, + 0.00013637542724609375, + 0.00013709068298339844, + 0.0001361370086669922, + 0.00014066696166992188, + 0.000141143798828125, + 0.00013780593872070312, + 0.00013756752014160156, + 0.00013709068298339844, + 0.0001366138458251953, + 0.0001385211944580078, + 0.00013637542724609375, + 0.0001366138458251953, + 0.0001366138458251953, + 0.00013780593872070312, + 0.0001354217529296875, + 0.00013828277587890625, + 0.00013589859008789062, + 0.00013566017150878906, + 0.00013685226440429688, + 0.00013685226440429688, + 0.0001366138458251953, + 0.0001366138458251953, + 0.0001361370086669922, + 0.00013756752014160156, + 0.0001354217529296875, + 0.00013899803161621094, + 0.0001366138458251953, + 0.00013780593872070312, + 0.00013756752014160156, + 0.00013637542724609375, + 0.0001361370086669922, + 0.00013756752014160156, + 0.0001366138458251953, + 0.00013566017150878906, + 0.00013756752014160156, + 0.0001366138458251953, + 0.0001366138458251953, + 0.00013637542724609375, + 0.0001373291015625, + 0.0001392364501953125, + 0.00013875961303710938, + 0.00013828277587890625, + 0.00013875961303710938, + 0.00013566017150878906, + 0.0001361370086669922, + 0.00013709068298339844, + 0.00013709068298339844, + 0.00013875961303710938, + 0.00013756752014160156, + 0.0001385211944580078, + 0.00013589859008789062, + 0.00013709068298339844, + 0.00013637542724609375, + 0.0001354217529296875, + 0.00013709068298339844, + 0.0001380443572998047, + 0.00013518333435058594, + 0.00018405914306640625, + 0.0003001689910888672, + 0.00013113021850585938, + 0.00017833709716796875, + 0.0001518726348876953, + 0.0001304149627685547, + 0.00013780593872070312, + 0.00013685226440429688, + 0.0001380443572998047, + 0.0001366138458251953, + 0.0001366138458251953, + 0.00013589859008789062, + 0.00013685226440429688, + 0.00013518333435058594, + 0.00013566017150878906, + 0.00013709068298339844, + 0.0001354217529296875, + 0.00013828277587890625, + 0.0001373291015625, + 0.0003345012664794922, + 0.0002722740173339844, + 0.00013518333435058594, + 0.0001327991485595703, + 0.00021457672119140625, + 0.0001544952392578125, + 0.00019359588623046875, + 0.00011420249938964844, + 0.00014710426330566406, + 0.000110626220703125, + 0.00016617774963378906, + 0.00013113021850585938, + 0.00013875961303710938, + 0.00011920928955078125, + 0.0001475811004638672, + 0.0001270771026611328, + 0.00012445449829101562, + 0.00014352798461914062, + 0.00010800361633300781, + 0.0001773834228515625, + 0.00022864341735839844, + 0.00022292137145996094, + 0.0001862049102783203, + 0.00016164779663085938, + 0.0001678466796875, + 0.00015044212341308594, + 0.00017523765563964844, + 9.369850158691406e-05, + 0.0001251697540283203, + 0.00015497207641601562, + 0.00015854835510253906, + 0.0001373291015625, + 0.00014448165893554688, + 0.0001430511474609375, + 0.0001494884490966797, + 0.00014138221740722656, + 0.00014138221740722656, + 0.00014352798461914062, + 0.0002734661102294922, + 0.0001533031463623047, + 0.00010776519775390625, + 0.00010418891906738281, + 0.00010156631469726562, + 9.298324584960938e-05, + 0.0001647472381591797, + 0.0001270771026611328, + 0.00014138221740722656, + 0.00013828277587890625, + 0.00013756752014160156, + 0.0001354217529296875, + 0.00013828277587890625, + 0.00013518333435058594, + 0.00013709068298339844, + 0.00013685226440429688, + 0.0001392364501953125, + 0.00013637542724609375, + 0.00013756752014160156, + 0.00013828277587890625, + 0.00013518333435058594, + 0.00013828277587890625, + 0.00013637542724609375, + 0.00013780593872070312, + 0.00013756752014160156, + 0.00013637542724609375, + 0.0001361370086669922, + 0.0001354217529296875, + 0.00013756752014160156, + 0.0001347064971923828, + 0.00013685226440429688, + 0.0001385211944580078, + 0.00013828277587890625, + 0.0001373291015625, + 0.0001392364501953125, + 0.00013303756713867188, + 0.00013637542724609375, + 0.00013566017150878906, + 0.0001347064971923828, + 0.00013566017150878906, + 0.0001373291015625, + 0.00013685226440429688, + 0.00013494491577148438, + 0.00013375282287597656, + 0.00013589859008789062, + 0.00013637542724609375, + 0.00013756752014160156, + 0.00013518333435058594, + 0.00017833709716796875, + 0.00012373924255371094, + 0.0001316070556640625, + 0.0001246929168701172, + 0.00021505355834960938, + 0.00015163421630859375, + 0.00010728836059570312, + 0.0001461505889892578, + 0.00014352798461914062, + 0.00013828277587890625, + 0.0001392364501953125, + 0.0001380443572998047, + 0.0001380443572998047, + 0.00013685226440429688, + 0.00013780593872070312, + 0.00013756752014160156, + 0.0001385211944580078, + 0.00013709068298339844, + 0.00013828277587890625, + 0.00013780593872070312, + 0.00013709068298339844, + 0.00013566017150878906, + 0.0001373291015625, + 0.00013685226440429688, + 0.00017452239990234375, + 0.0001468658447265625, + 0.00018286705017089844, + 0.0002701282501220703, + 4.8160552978515625e-05, + 0.00021910667419433594, + 0.0001289844512939453, + 0.00016188621520996094, + 0.00020956993103027344, + 4.6253204345703125e-05, + 0.00014519691467285156, + 0.0001220703125, + 0.00011181831359863281, + 0.0001285076141357422, + 0.0001842975616455078, + 0.00015234947204589844, + 0.0001544952392578125, + 0.0001239776611328125, + 0.0001285076141357422, + 0.00012874603271484375, + 0.00012731552124023438, + 0.0001277923583984375, + 0.00013589859008789062, + 0.00011897087097167969, + 0.00012063980102539062, + 0.00015497207641601562, + 0.0001723766326904297, + 0.00013899803161621094, + 0.0001404285430908203, + 0.00013709068298339844, + 0.00013685226440429688, + 0.0001366138458251953, + 0.00013637542724609375, + 0.00015282630920410156, + 0.00013685226440429688, + 0.0002186298370361328, + 0.00012922286987304688, + 0.0001251697540283203, + 0.0001266002655029297, + 0.0001277923583984375, + 0.00011920928955078125, + 0.00012540817260742188, + 0.00012683868408203125, + 0.00012922286987304688, + 0.00013017654418945312, + 0.00013256072998046875, + 0.00013017654418945312, + 0.0001270771026611328, + 0.00012969970703125, + 0.00013875961303710938, + 0.00012564659118652344, + 0.00012636184692382812, + 0.00012612342834472656, + 0.00012564659118652344, + 0.000125885009765625, + 0.00012612342834472656, + 0.00012731552124023438, + 0.0001251697540283203, + 0.0001266002655029297, + 0.00012540817260742188, + 0.0001251697540283203, + 0.00012683868408203125, + 0.0001251697540283203, + 0.000125885009765625, + 0.00012445449829101562, + 0.00012922286987304688, + 0.00012731552124023438, + 0.00012540817260742188, + 0.00012683868408203125, + 0.0001270771026611328, + 0.0001735687255859375, + 8.606910705566406e-05, + 0.00012493133544921875, + 0.00012803077697753906, + 0.0001270771026611328, + 0.00015544891357421875, + 0.00014352798461914062, + 0.00013780593872070312, + 0.00014066696166992188, + 0.00014209747314453125, + 0.0001366138458251953, + 0.00013589859008789062, + 0.00013256072998046875, + 0.00013589859008789062, + 0.0001380443572998047, + 0.00013566017150878906, + 0.00013899803161621094, + 0.0001366138458251953, + 0.00014925003051757812, + 0.00012350082397460938, + 0.0001277923583984375, + 0.00012373924255371094, + 0.00012803077697753906, + 0.00012564659118652344, + 0.0001266002655029297, + 0.00012564659118652344, + 0.0001289844512939453, + 0.00013899803161621094, + 0.00012493133544921875, + 0.00012683868408203125, + 0.0001246929168701172, + 0.0001308917999267578, + 0.000125885009765625, + 0.00012540817260742188, + 0.0001266002655029297, + 0.00012683868408203125, + 0.00012445449829101562, + 0.00012445449829101562, + 0.00012540817260742188, + 0.00013208389282226562, + 0.00011920928955078125, + 0.00012493133544921875, + 0.0001251697540283203, + 0.0001342296600341797, + 0.00011348724365234375, + 0.00012564659118652344, + 0.00014638900756835938, + 0.00014543533325195312, + 0.00013303756713867188, + 0.0001354217529296875, + 0.0001361370086669922, + 0.0001404285430908203, + 0.00013756752014160156, + 0.00014090538024902344, + 0.0001418590545654297, + 0.0003788471221923828, + 9.274482727050781e-05, + 4.4345855712890625e-05, + 0.0001533031463623047, + 0.0001404285430908203, + 0.00014543533325195312, + 0.00015974044799804688, + 0.00011277198791503906, + 0.000148773193359375, + 0.00010704994201660156, + 0.0001232624053955078, + 0.00013184547424316406, + 0.0001316070556640625, + 0.00013184547424316406, + 0.0001285076141357422, + 0.00013065338134765625, + 0.00014328956604003906, + 0.00013303756713867188, + 0.00013065338134765625, + 0.00013184547424316406, + 0.00013446807861328125, + 0.000133514404296875, + 0.00012922286987304688, + 0.00016355514526367188, + 0.00013971328735351562, + 0.00019598007202148438, + 0.0003581047058105469, + 7.987022399902344e-05, + 0.0001418590545654297, + 0.00012969970703125, + 0.00012803077697753906, + 0.00012922286987304688, + 0.0001323223114013672, + 0.00013208389282226562, + 0.00013136863708496094, + 0.0001285076141357422, + 0.00012636184692382812, + 0.00012803077697753906, + 0.00015735626220703125, + 0.00010085105895996094, + 0.00012302398681640625, + 0.0001461505889892578, + 0.00012040138244628906, + 0.00012874603271484375, + 0.00012683868408203125, + 0.00012969970703125, + 0.0002593994140625, + 0.00011301040649414062, + 9.083747863769531e-05, + 8.511543273925781e-05, + 8.463859558105469e-05, + 0.0001537799835205078, + 9.369850158691406e-05, + 0.0001266002655029297, + 0.00012922286987304688, + 0.0001266002655029297, + 0.00013446807861328125, + 0.0001289844512939453, + 0.0001270771026611328, + 0.00013017654418945312, + 0.00012755393981933594, + 0.00012803077697753906, + 0.00013113021850585938, + 0.0002148151397705078, + 0.0001461505889892578, + 0.00015783309936523438, + 0.0001518726348876953, + 0.00013136863708496094, + 0.00012803077697753906, + 0.00012755393981933594, + 0.00012731552124023438, + 0.00012826919555664062, + 0.0001277923583984375, + 0.00012874603271484375, + 0.0001277923583984375, + 0.0001285076141357422, + 0.000125885009765625, + 0.0001270771026611328, + 0.0001285076141357422, + 0.0001323223114013672, + 0.00012803077697753906, + 0.0001277923583984375, + 0.0001304149627685547, + 0.00012564659118652344, + 0.0001304149627685547, + 0.00012612342834472656, + 0.00012612342834472656, + 0.00012683868408203125, + 0.0001289844512939453, + 0.0001285076141357422, + 0.00012683868408203125, + 0.00012683868408203125, + 0.00012755393981933594, + 0.00012636184692382812, + 0.0001316070556640625, + 0.00012636184692382812, + 0.00012969970703125, + 0.00012731552124023438, + 0.0001285076141357422, + 0.00012731552124023438, + 0.0001556873321533203, + 0.00015211105346679688, + 0.0001289844512939453, + 0.00012636184692382812, + 0.00012922286987304688, + 0.00013184547424316406, + 0.00012922286987304688, + 0.0001270771026611328, + 0.00012922286987304688, + 0.0001285076141357422, + 0.00012683868408203125, + 0.00012826919555664062, + 0.00012731552124023438, + 0.00013065338134765625, + 0.00013327598571777344, + 0.00012969970703125, + 0.00012540817260742188, + 0.00012922286987304688, + 0.00012874603271484375, + 0.00012803077697753906, + 0.00012731552124023438, + 0.0001270771026611328, + 0.00025844573974609375, + 0.0005631446838378906, + 0.0001468658447265625, + 0.00013017654418945312, + 0.00013375282287597656, + 0.0001316070556640625, + 0.0001342296600341797, + 0.00013113021850585938, + 0.00012731552124023438, + 0.00013113021850585938, + 0.00012755393981933594, + 0.0001285076141357422, + 0.000125885009765625, + 0.00012993812561035156, + 0.0001392364501953125, + 0.00013136863708496094, + 0.00012969970703125, + 0.0001308917999267578, + 0.00012683868408203125, + 0.0001499652862548828, + 0.00010848045349121094, + 0.0001246929168701172, + 0.00012683868408203125, + 0.00012612342834472656, + 0.00013017654418945312, + 0.00012993812561035156, + 0.0001304149627685547, + 0.0001289844512939453, + 0.0001308917999267578, + 0.0001246929168701172, + 0.00013375282287597656, + 0.00013184547424316406, + 0.00012612342834472656, + 0.0001289844512939453, + 0.00012874603271484375, + 0.00013136863708496094, + 0.0001323223114013672, + 0.00012826919555664062, + 0.00012993812561035156, + 0.0001289844512939453, + 0.00012874603271484375, + 0.0001270771026611328, + 0.0002155303955078125, + 0.0001571178436279297, + 0.0001571178436279297, + 0.00015401840209960938, + 0.0001289844512939453, + 0.00012111663818359375, + 0.0001277923583984375, + 0.0001277923583984375, + 0.00012731552124023438, + 0.0001277923583984375, + 0.0001304149627685547, + 0.00012540817260742188, + 0.00012683868408203125, + 0.00012731552124023438, + 0.00012946128845214844, + 0.000125885009765625, + 0.00017070770263671875, + 0.00013256072998046875, + 0.00013136863708496094, + 0.0001304149627685547, + 0.00012969970703125, + 0.00012946128845214844, + 0.0001277923583984375, + 0.00012826919555664062, + 0.00013017654418945312, + 0.00012826919555664062, + 0.0001277923583984375, + 0.0001277923583984375, + 0.00012636184692382812, + 0.00017213821411132812, + 0.0001506805419921875, + 0.000133514404296875, + 0.00013113021850585938, + 0.00013327598571777344, + 0.00012731552124023438, + 0.0001270771026611328, + 0.00012731552124023438, + 0.00012874603271484375, + 0.0001277923583984375, + 0.00012683868408203125, + 0.0001289844512939453, + 0.0001285076141357422, + 0.00012755393981933594, + 0.0001304149627685547, + 0.00012946128845214844, + 0.00012993812561035156, + 0.0001266002655029297, + 0.00012826919555664062, + 0.00012683868408203125, + 0.00012803077697753906, + 0.00012993812561035156, + 0.00012612342834472656, + 0.0001304149627685547, + 0.00012636184692382812, + 0.0001289844512939453, + 0.00012612342834472656, + 0.0001266002655029297, + 0.00012946128845214844, + 0.00013303756713867188, + 0.00012922286987304688, + 0.0001266002655029297, + 0.00012636184692382812, + 0.00012636184692382812, + 0.000125885009765625, + 0.00012803077697753906, + 0.0001270771026611328, + 0.00012969970703125, + 0.0001246929168701172, + 0.00012922286987304688, + 0.00012946128845214844, + 0.0001285076141357422, + 0.0001285076141357422, + 0.00012731552124023438, + 0.0001277923583984375, + 0.0001327991485595703, + 0.0001327991485595703, + 0.0001270771026611328, + 0.00012302398681640625, + 0.0001399517059326172, + 0.0004208087921142578, + 0.00013756752014160156, + 0.00043964385986328125, + 0.00018024444580078125, + 0.0003104209899902344, + 0.0001652240753173828, + 0.00010251998901367188, + 0.00012063980102539062, + 0.00015234947204589844, + 0.00012969970703125, + 0.00018405914306640625, + 0.00012946128845214844, + 0.000156402587890625, + 0.00013828277587890625, + 0.0001316070556640625, + 0.00013828277587890625, + 0.0001354217529296875, + 0.00014400482177734375, + 0.0001590251922607422, + 0.00011777877807617188, + 0.00014638900756835938, + 0.00010824203491210938, + 0.00014638900756835938, + 0.00013875961303710938, + 0.00011968612670898438, + 0.0002548694610595703, + 0.000125885009765625, + 3.62396240234375e-05, + 6.222724914550781e-05, + 0.00015854835510253906, + 0.00013375282287597656, + 0.00013375282287597656, + 0.00013399124145507812, + 0.00012826919555664062, + 0.0001327991485595703, + 0.00013208389282226562, + 0.00013303756713867188, + 0.00013208389282226562, + 0.00013113021850585938, + 0.00012803077697753906, + 0.00017786026000976562, + 0.00014710426330566406, + 0.0001308917999267578, + 0.0001246929168701172, + 0.00013208389282226562, + 0.0001289844512939453, + 0.00013065338134765625, + 0.00012922286987304688, + 0.00015163421630859375, + 0.00012946128845214844, + 0.00013065338134765625, + 0.0001277923583984375, + 0.00012946128845214844, + 0.0001266002655029297, + 0.0001239776611328125, + 0.00012803077697753906, + 0.00012803077697753906, + 0.00012874603271484375, + 0.0001316070556640625, + 0.00012993812561035156, + 0.00017070770263671875, + 0.0001475811004638672, + 0.0001323223114013672, + 0.0001285076141357422, + 0.00012731552124023438, + 0.0001289844512939453, + 0.00013256072998046875, + 0.00012946128845214844, + 0.0001308917999267578, + 0.00012874603271484375, + 0.00012826919555664062, + 0.00012731552124023438, + 0.00012993812561035156, + 0.00012803077697753906, + 0.0001354217529296875, + 0.00013065338134765625, + 0.0001366138458251953, + 0.000152587890625, + 0.00012993812561035156, + 0.00012874603271484375, + 0.00013065338134765625, + 0.00012969970703125, + 0.00013017654418945312, + 0.00013327598571777344, + 0.00013256072998046875, + 0.0001456737518310547, + 0.00012493133544921875, + 0.0001289844512939453, + 0.00012993812561035156, + 0.00013303756713867188, + 0.00013256072998046875, + 0.0001316070556640625, + 0.00012731552124023438, + 0.0001289844512939453, + 0.00014090538024902344, + 0.00015234947204589844, + 0.0001285076141357422, + 0.0001277923583984375, + 0.0001289844512939453, + 0.00013136863708496094, + 0.00012755393981933594, + 0.00012683868408203125, + 0.00012755393981933594, + 0.00012826919555664062, + 0.0001671314239501953, + 0.00014591217041015625, + 0.00013113021850585938, + 0.00012612342834472656, + 0.00013017654418945312, + 0.00012826919555664062, + 0.00019860267639160156, + 0.0003211498260498047, + 0.00012564659118652344, + 0.00013208389282226562, + 0.0004520416259765625, + 0.00011301040649414062, + 0.00023794174194335938, + 0.00017452239990234375, + 0.00012540817260742188, + 0.00020265579223632812, + 0.00013828277587890625, + 0.00011229515075683594, + 0.00013113021850585938, + 0.00013113021850585938, + 0.0001342296600341797, + 0.00013017654418945312, + 0.00013113021850585938, + 0.0001316070556640625, + 0.0001289844512939453, + 0.00012969970703125, + 0.00012969970703125, + 0.0001361370086669922, + 0.0001285076141357422, + 0.00019621849060058594, + 0.00016832351684570312, + 9.34600830078125e-05, + 0.00014019012451171875, + 0.00013017654418945312, + 0.00012874603271484375, + 0.00013065338134765625, + 0.00012803077697753906, + 0.00012969970703125, + 0.00012731552124023438, + 0.00012993812561035156, + 0.0001270771026611328, + 0.00012874603271484375, + 0.0001289844512939453, + 0.00013399124145507812, + 0.00013017654418945312, + 0.0001304149627685547, + 0.00017571449279785156, + 0.0001518726348876953, + 0.0001347064971923828, + 0.00015115737915039062, + 0.0001308917999267578, + 0.00012993812561035156, + 0.00013017654418945312, + 0.0001304149627685547, + 0.00012683868408203125, + 0.00012969970703125, + 0.0001285076141357422, + 0.0001270771026611328, + 0.0001270771026611328, + 0.0001289844512939453, + 0.0001697540283203125, + 0.00023627281188964844, + 4.076957702636719e-05, + 0.0002281665802001953, + 9.083747863769531e-05, + 0.00012969970703125, + 0.00010895729064941406, + 0.00012922286987304688, + 0.0001308917999267578, + 0.0001304149627685547, + 0.0001304149627685547, + 0.00012946128845214844, + 0.00013065338134765625, + 0.00012993812561035156, + 0.00013184547424316406, + 0.00013303756713867188, + 0.00013113021850585938, + 0.00013589859008789062, + 0.00012111663818359375, + 0.0001308917999267578, + 0.00013065338134765625, + 0.0001316070556640625, + 0.00012946128845214844, + 0.00012969970703125, + 0.00012946128845214844, + 0.00012922286987304688, + 0.0001304149627685547, + 0.00012993812561035156, + 0.00013017654418945312, + 0.00012969970703125, + 0.00012946128845214844, + 0.00012993812561035156, + 0.0001347064971923828, + 0.00013256072998046875, + 0.00012946128845214844, + 0.00012969970703125, + 0.00012969970703125, + 0.00012922286987304688, + 0.0001304149627685547, + 0.00012946128845214844, + 0.00012874603271484375, + 0.0001289844512939453, + 0.00012993812561035156, + 0.00012969970703125, + 0.00012946128845214844, + 0.000133514404296875, + 0.00013017654418945312, + 0.00013065338134765625, + 0.00012993812561035156, + 0.00012922286987304688, + 0.0001308917999267578, + 0.0001289844512939453, + 0.0001289844512939453, + 0.0001308917999267578, + 0.00012755393981933594, + 0.00012922286987304688, + 0.00013017654418945312, + 0.00012874603271484375, + 0.0001304149627685547, + 0.0001289844512939453, + 0.00013113021850585938, + 0.0002384185791015625, + 8.893013000488281e-05, + 0.00011301040649414062, + 0.00011682510375976562, + 0.00012826919555664062, + 0.0001385211944580078, + 0.00011610984802246094, + 0.0001285076141357422, + 0.00012946128845214844, + 0.00012755393981933594, + 0.0004611015319824219, + 0.0002624988555908203, + 0.0001513957977294922, + 0.0001919269561767578, + 0.000213623046875, + 0.00020885467529296875, + 0.0002079010009765625, + 0.00018906593322753906, + 0.00023889541625976562, + 0.0001506805419921875, + 0.0002067089080810547, + 9.393692016601562e-05, + 0.00012874603271484375, + 0.00012373924255371094, + 0.00013136863708496094, + 0.00013303756713867188, + 0.00013136863708496094, + 0.00013017654418945312, + 0.0001316070556640625, + 0.0001289844512939453, + 0.00017404556274414062, + 0.0001327991485595703, + 0.00014090538024902344, + 0.00012946128845214844, + 0.00015091896057128906, + 0.00015974044799804688, + 7.581710815429688e-05, + 0.00045013427734375, + 0.0002474784851074219, + 0.0001399517059326172, + 0.00013208389282226562, + 0.00013113021850585938, + 0.0001323223114013672, + 0.00013113021850585938, + 0.00012969970703125, + 0.0001308917999267578, + 0.0001308917999267578, + 0.0001289844512939453, + 0.00012969970703125, + 0.00012969970703125, + 0.00012946128845214844, + 0.00013875961303710938, + 0.00012946128845214844, + 0.00013065338134765625, + 0.00012922286987304688, + 0.00012683868408203125, + 0.0001285076141357422, + 0.00012993812561035156, + 0.00012993812561035156, + 0.0001308917999267578, + 0.00012826919555664062, + 0.00013017654418945312, + 0.00013065338134765625, + 0.0001304149627685547, + 0.0001277923583984375, + 0.0001304149627685547, + 0.0001347064971923828, + 0.0001316070556640625, + 0.00012946128845214844, + 0.0001285076141357422, + 0.00012993812561035156, + 0.00012922286987304688, + 0.0001285076141357422, + 0.0001304149627685547, + 0.0001304149627685547, + 0.00012874603271484375, + 0.00012969970703125, + 0.0001289844512939453, + 0.00012993812561035156, + 0.0001304149627685547, + 0.00012969970703125, + 0.00013566017150878906, + 0.00012826919555664062, + 0.0003554821014404297, + 0.00012445449829101562, + 0.00011181831359863281, + 0.00011086463928222656, + 0.00011777877807617188, + 0.00012040138244628906, + 0.0001308917999267578, + 0.00012874603271484375, + 0.0001304149627685547, + 0.0001289844512939453, + 0.0001277923583984375, + 0.00012803077697753906, + 0.00012731552124023438, + 0.00012946128845214844, + 0.0001289844512939453, + 0.00012803077697753906, + 0.00013184547424316406, + 0.00012969970703125, + 0.0001277923583984375, + 0.00012826919555664062, + 0.0001289844512939453, + 0.00012803077697753906, + 0.00047135353088378906, + 0.0004661083221435547, + 0.00016164779663085938, + 0.0001251697540283203, + 0.00032520294189453125, + 0.00015735626220703125, + 0.00011348724365234375, + 0.00011014938354492188, + 0.00010991096496582031, + 0.00010848045349121094, + 0.00010967254638671875, + 0.00010728836059570312, + 0.0012195110321044922, + 4.553794860839844e-05, + 3.4332275390625e-05, + 3.218650817871094e-05, + 3.0517578125e-05, + 3.337860107421875e-05, + 3.0994415283203125e-05, + 0.0005459785461425781, + 0.0004143714904785156, + 4.696846008300781e-05, + 7.724761962890625e-05, + 0.00016999244689941406, + 0.0006077289581298828, + 0.0001556873321533203, + 0.00011801719665527344, + 0.00011301040649414062, + 0.00010919570922851562, + 0.00010824203491210938, + 0.00011038780212402344, + 0.0001087188720703125, + 0.00010848045349121094, + 0.00010776519775390625, + 0.00011110305786132812, + 0.00023651123046875, + 0.00017333030700683594, + 0.00014448165893554688, + 0.0002624988555908203, + 0.00013327598571777344 + ], + "average": 0.0003386068344116211, + "minimum": 3.0517578125e-05, + "maximum": 0.1983966827392578 +} \ No newline at end of file diff --git a/lectures/timer_results_jax_gpu.json b/lectures/timer_results_jax_gpu.json new file mode 100644 index 000000000..7384a8045 --- /dev/null +++ b/lectures/timer_results_jax_gpu.json @@ -0,0 +1,1007 @@ +{ + "elapsed": [ + 0.00894927978515625, + 0.0077893733978271484, + 0.00783848762512207, + 0.007742881774902344, + 0.008021831512451172, + 0.008403778076171875, + 0.00877690315246582, + 0.009249448776245117, + 0.009325742721557617, + 0.007759571075439453, + 0.007692813873291016, + 0.007470369338989258, + 0.007610321044921875, + 0.0074825286865234375, + 0.007505655288696289, + 0.0074405670166015625, + 0.007567882537841797, + 0.00752568244934082, + 0.0075266361236572266, + 0.007463932037353516, + 0.007449626922607422, + 0.007368564605712891, + 0.00751948356628418, + 0.00741267204284668, + 0.00746464729309082, + 0.0075054168701171875, + 0.007444858551025391, + 0.007678985595703125, + 0.007574796676635742, + 0.0077114105224609375, + 0.007683753967285156, + 0.007571220397949219, + 0.007487297058105469, + 0.007385969161987305, + 0.0072841644287109375, + 0.007334232330322266, + 0.007352590560913086, + 0.0076525211334228516, + 0.0078277587890625, + 0.007426261901855469, + 0.00733184814453125, + 0.007588863372802734, + 0.007337093353271484, + 0.0075054168701171875, + 0.007489919662475586, + 0.007448434829711914, + 0.0073969364166259766, + 0.007444143295288086, + 0.007250070571899414, + 0.0072324275970458984, + 0.007323741912841797, + 0.007349252700805664, + 0.007457256317138672, + 0.007370948791503906, + 0.007367849349975586, + 0.0073642730712890625, + 0.007434844970703125, + 0.007540225982666016, + 0.007413148880004883, + 0.0073719024658203125, + 0.007552385330200195, + 0.007336854934692383, + 0.007337808609008789, + 0.00720977783203125, + 0.0071849822998046875, + 0.0072689056396484375, + 0.0072247982025146484, + 0.00731968879699707, + 0.007339000701904297, + 0.007465362548828125, + 0.0072269439697265625, + 0.007188320159912109, + 0.0072040557861328125, + 0.0072863101959228516, + 0.00837850570678711, + 0.007498025894165039, + 0.00730443000793457, + 0.007451534271240234, + 0.007972478866577148, + 0.007239341735839844, + 0.007331132888793945, + 0.007318973541259766, + 0.007255077362060547, + 0.007398128509521484, + 0.007372140884399414, + 0.007241010665893555, + 0.007323741912841797, + 0.007458686828613281, + 0.007277250289916992, + 0.0073163509368896484, + 0.007129192352294922, + 0.007196664810180664, + 0.0072786808013916016, + 0.00723576545715332, + 0.007236480712890625, + 0.007346391677856445, + 0.0072672367095947266, + 0.007182121276855469, + 0.007494211196899414, + 0.0073699951171875, + 0.00756072998046875, + 0.007221221923828125, + 0.00718998908996582, + 0.0072324275970458984, + 0.007302284240722656, + 0.00754857063293457, + 0.009068489074707031, + 0.00790715217590332, + 0.008527755737304688, + 0.008210182189941406, + 0.011906623840332031, + 0.008292913436889648, + 0.007605791091918945, + 0.009207487106323242, + 0.009471654891967773, + 0.01461935043334961, + 0.00813436508178711, + 0.008111238479614258, + 0.008356332778930664, + 0.00919795036315918, + 0.016668319702148438, + 0.008682012557983398, + 0.00827646255493164, + 0.007841110229492188, + 0.008556842803955078, + 0.008398294448852539, + 0.007370948791503906, + 0.00728297233581543, + 0.007416486740112305, + 0.007297039031982422, + 0.007281303405761719, + 0.0071566104888916016, + 0.007378578186035156, + 0.007262468338012695, + 0.007253885269165039, + 0.0070972442626953125, + 0.007194042205810547, + 0.0071675777435302734, + 0.007120847702026367, + 0.008023262023925781, + 0.0075702667236328125, + 0.007699489593505859, + 0.007712841033935547, + 0.0075261592864990234, + 0.007371664047241211, + 0.0071218013763427734, + 0.007317066192626953, + 0.0071985721588134766, + 0.007280111312866211, + 0.007114887237548828, + 0.00730586051940918, + 0.007183074951171875, + 0.007381439208984375, + 0.007197141647338867, + 0.00724339485168457, + 0.0071756839752197266, + 0.007266998291015625, + 0.007156848907470703, + 0.007177591323852539, + 0.007179975509643555, + 0.007282257080078125, + 0.0071506500244140625, + 0.007104396820068359, + 0.0071065425872802734, + 0.007241010665893555, + 0.007120847702026367, + 0.0071485042572021484, + 0.007211923599243164, + 0.00720524787902832, + 0.007305145263671875, + 0.007249116897583008, + 0.006999969482421875, + 0.007219076156616211, + 0.007281064987182617, + 0.0072383880615234375, + 0.007224559783935547, + 0.0070989131927490234, + 0.007096290588378906, + 0.007146358489990234, + 0.007042646408081055, + 0.0071811676025390625, + 0.007082223892211914, + 0.007155895233154297, + 0.007238149642944336, + 0.007129192352294922, + 0.007277488708496094, + 0.007277965545654297, + 0.007107257843017578, + 0.007270336151123047, + 0.007373332977294922, + 0.0073740482330322266, + 0.008176803588867188, + 0.007331371307373047, + 0.007120370864868164, + 0.007020473480224609, + 0.007232189178466797, + 0.007283687591552734, + 0.007192850112915039, + 0.0072231292724609375, + 0.007257223129272461, + 0.0071871280670166016, + 0.007084369659423828, + 0.007172346115112305, + 0.007170438766479492, + 0.007084369659423828, + 0.007151365280151367, + 0.007338047027587891, + 0.007124900817871094, + 0.007176399230957031, + 0.00713038444519043, + 0.007172584533691406, + 0.0071201324462890625, + 0.00712895393371582, + 0.007082223892211914, + 0.007166862487792969, + 0.007182598114013672, + 0.007147073745727539, + 0.007116556167602539, + 0.007161617279052734, + 0.007193088531494141, + 0.0070667266845703125, + 0.0070574283599853516, + 0.007298946380615234, + 0.007250070571899414, + 0.007103919982910156, + 0.00710606575012207, + 0.00718235969543457, + 0.007061958312988281, + 0.0072252750396728516, + 0.007208824157714844, + 0.007238149642944336, + 0.0073795318603515625, + 0.009131669998168945, + 0.00827479362487793, + 0.008715391159057617, + 0.008734703063964844, + 0.007229328155517578, + 0.007062435150146484, + 0.00708770751953125, + 0.007140636444091797, + 0.007266044616699219, + 0.007165193557739258, + 0.007125377655029297, + 0.007047414779663086, + 0.00720524787902832, + 0.006979227066040039, + 0.0071620941162109375, + 0.007021427154541016, + 0.0076291561126708984, + 0.007161378860473633, + 0.007355928421020508, + 0.007161140441894531, + 0.0072782039642333984, + 0.007496356964111328, + 0.00710606575012207, + 0.00709843635559082, + 0.007381439208984375, + 0.009734630584716797, + 0.012171030044555664, + 0.00762486457824707, + 0.007074594497680664, + 0.0070955753326416016, + 0.0072171688079833984, + 0.007250070571899414, + 0.007467985153198242, + 0.00722503662109375, + 0.0073277950286865234, + 0.0071620941162109375, + 0.007193803787231445, + 0.007155179977416992, + 0.0071675777435302734, + 0.007237672805786133, + 0.00711369514465332, + 0.007418155670166016, + 0.007233381271362305, + 0.007153034210205078, + 0.0071218013763427734, + 0.0070683956146240234, + 0.0071222782135009766, + 0.007197141647338867, + 0.0070476531982421875, + 0.01286935806274414, + 0.00999140739440918, + 0.007722616195678711, + 0.008667707443237305, + 0.007975578308105469, + 0.007681846618652344, + 0.007479429244995117, + 0.007181882858276367, + 0.015595674514770508, + 0.014226436614990234, + 0.009690999984741211, + 0.007378339767456055, + 0.0071947574615478516, + 0.007163524627685547, + 0.007230281829833984, + 0.007164716720581055, + 0.007239341735839844, + 0.007156848907470703, + 0.007259845733642578, + 0.007276058197021484, + 0.007372140884399414, + 0.007281780242919922, + 0.0072078704833984375, + 0.007158041000366211, + 0.007188081741333008, + 0.0071294307708740234, + 0.0072438716888427734, + 0.007301807403564453, + 0.007174968719482422, + 0.00709223747253418, + 0.0071222782135009766, + 0.007420778274536133, + 0.0071086883544921875, + 0.007596254348754883, + 0.0073740482330322266, + 0.007146596908569336, + 0.00709986686706543, + 0.007021188735961914, + 0.007097959518432617, + 0.007472515106201172, + 0.007132291793823242, + 0.007207155227661133, + 0.0071489810943603516, + 0.007122039794921875, + 0.007085084915161133, + 0.007021188735961914, + 0.007106781005859375, + 0.007116079330444336, + 0.0071735382080078125, + 0.007048130035400391, + 0.007073640823364258, + 0.00713801383972168, + 0.007075071334838867, + 0.007047176361083984, + 0.007024288177490234, + 0.007042884826660156, + 0.007042884826660156, + 0.007111310958862305, + 0.007592439651489258, + 0.007111787796020508, + 0.0070383548736572266, + 0.0071010589599609375, + 0.007037639617919922, + 0.007018566131591797, + 0.007133960723876953, + 0.007188081741333008, + 0.007060527801513672, + 0.007207393646240234, + 0.007055759429931641, + 0.007146120071411133, + 0.007066965103149414, + 0.007110595703125, + 0.006989002227783203, + 0.007099628448486328, + 0.007232666015625, + 0.007322788238525391, + 0.0072917938232421875, + 0.007248878479003906, + 0.00720524787902832, + 0.007298946380615234, + 0.0073261260986328125, + 0.007050514221191406, + 0.007036685943603516, + 0.00727534294128418, + 0.0071926116943359375, + 0.00737452507019043, + 0.007292270660400391, + 0.036690711975097656, + 0.03507518768310547, + 0.0381016731262207, + 0.03814864158630371, + 0.03513336181640625, + 0.030566692352294922, + 0.02220940589904785, + 0.02411055564880371, + 0.023044347763061523, + 0.02397012710571289, + 0.010378122329711914, + 0.008206844329833984, + 0.00722813606262207, + 0.00736689567565918, + 0.007264375686645508, + 0.0073015689849853516, + 0.007363557815551758, + 0.007221698760986328, + 0.007307291030883789, + 0.00713038444519043, + 0.007215023040771484, + 0.007846355438232422, + 0.008081436157226562, + 0.008908271789550781, + 0.008430242538452148, + 0.0072231292724609375, + 0.007277250289916992, + 0.007365226745605469, + 0.0072095394134521484, + 0.007120847702026367, + 0.007192134857177734, + 0.007294178009033203, + 0.00725102424621582, + 0.007162809371948242, + 0.007226467132568359, + 0.007110118865966797, + 0.007241725921630859, + 0.007134437561035156, + 0.0073430538177490234, + 0.007382392883300781, + 0.007411479949951172, + 0.007285118103027344, + 0.007201671600341797, + 0.00712132453918457, + 0.007196903228759766, + 0.007291316986083984, + 0.007220268249511719, + 0.007147073745727539, + 0.007172346115112305, + 0.0071027278900146484, + 0.007306814193725586, + 0.007319927215576172, + 0.00712275505065918, + 0.0071811676025390625, + 0.007083892822265625, + 0.007180452346801758, + 0.0071833133697509766, + 0.0072100162506103516, + 0.007221698760986328, + 0.007248401641845703, + 0.007070302963256836, + 0.00718998908996582, + 0.007283210754394531, + 0.0072934627532958984, + 0.007147073745727539, + 0.007178544998168945, + 0.0073394775390625, + 0.0074236392974853516, + 0.007506608963012695, + 0.007380008697509766, + 0.007401466369628906, + 0.007271766662597656, + 0.007142305374145508, + 0.007149457931518555, + 0.007284402847290039, + 0.007195234298706055, + 0.0072021484375, + 0.007145881652832031, + 0.007225751876831055, + 0.00707697868347168, + 0.007158994674682617, + 0.007176637649536133, + 0.015395879745483398, + 0.038988351821899414, + 0.03654766082763672, + 0.04114723205566406, + 0.013225555419921875, + 0.015584230422973633, + 0.01636052131652832, + 0.016962766647338867, + 0.022106409072875977, + 0.0225677490234375, + 0.011452913284301758, + 0.015201330184936523, + 0.01706695556640625, + 0.016536235809326172, + 0.013992547988891602, + 0.016102313995361328, + 0.017148494720458984, + 0.008769512176513672, + 0.007285356521606445, + 0.007350444793701172, + 0.0072290897369384766, + 0.007119894027709961, + 0.007043361663818359, + 0.00720977783203125, + 0.007189750671386719, + 0.0071926116943359375, + 0.007196903228759766, + 0.0070953369140625, + 0.007021427154541016, + 0.007518291473388672, + 0.007029056549072266, + 0.007181644439697266, + 0.0071680545806884766, + 0.007202863693237305, + 0.007090330123901367, + 0.007100105285644531, + 0.007136821746826172, + 0.007125377655029297, + 0.007145881652832031, + 0.00711822509765625, + 0.0070803165435791016, + 0.00703120231628418, + 0.007002353668212891, + 0.00706028938293457, + 0.0072405338287353516, + 0.007262229919433594, + 0.007168769836425781, + 0.007116556167602539, + 0.007226705551147461, + 0.007029056549072266, + 0.007934331893920898, + 0.007883310317993164, + 0.008924484252929688, + 0.0084075927734375, + 0.007273674011230469, + 0.007206439971923828, + 0.007546424865722656, + 0.007191658020019531, + 0.007179737091064453, + 0.00713348388671875, + 0.0071904659271240234, + 0.007225513458251953, + 0.0071010589599609375, + 0.0071561336517333984, + 0.007140398025512695, + 0.007100820541381836, + 0.0070955753326416016, + 0.0071489810943603516, + 0.007231950759887695, + 0.007233619689941406, + 0.00713348388671875, + 0.007120847702026367, + 0.007150173187255859, + 0.007075071334838867, + 0.0070421695709228516, + 0.007173776626586914, + 0.007164478302001953, + 0.00716710090637207, + 0.007169008255004883, + 0.007172584533691406, + 0.007130861282348633, + 0.007195949554443359, + 0.0072784423828125, + 0.007217884063720703, + 0.007241964340209961, + 0.0071659088134765625, + 0.0070149898529052734, + 0.007053375244140625, + 0.007044792175292969, + 0.007116794586181641, + 0.007135629653930664, + 0.0071811676025390625, + 0.007134675979614258, + 0.007124662399291992, + 0.0072479248046875, + 0.007128715515136719, + 0.0071604251861572266, + 0.007094621658325195, + 0.007096529006958008, + 0.00700688362121582, + 0.007084369659423828, + 0.007156848907470703, + 0.0077974796295166016, + 0.007052421569824219, + 0.007349729537963867, + 0.007244110107421875, + 0.0072422027587890625, + 0.007025957107543945, + 0.007237434387207031, + 0.0070688724517822266, + 0.0071790218353271484, + 0.007050514221191406, + 0.007236480712890625, + 0.0071506500244140625, + 0.0071258544921875, + 0.007107973098754883, + 0.007052421569824219, + 0.007144451141357422, + 0.007294893264770508, + 0.007196903228759766, + 0.007056713104248047, + 0.00723576545715332, + 0.007178544998168945, + 0.007122993469238281, + 0.007153511047363281, + 0.007272958755493164, + 0.007138252258300781, + 0.00717616081237793, + 0.007378339767456055, + 0.007242918014526367, + 0.007092475891113281, + 0.007117033004760742, + 0.007160663604736328, + 0.0070002079010009766, + 0.0070912837982177734, + 0.007106304168701172, + 0.007125139236450195, + 0.007132291793823242, + 0.007134914398193359, + 0.007076740264892578, + 0.007161140441894531, + 0.007189512252807617, + 0.007228374481201172, + 0.0071032047271728516, + 0.007415771484375, + 0.007195472717285156, + 0.00735020637512207, + 0.007052898406982422, + 0.007218360900878906, + 0.0070765018463134766, + 0.0070497989654541016, + 0.007172107696533203, + 0.007299184799194336, + 0.007365703582763672, + 0.0076482295989990234, + 0.007239341735839844, + 0.007136106491088867, + 0.007231235504150391, + 0.007045745849609375, + 0.007025718688964844, + 0.007126569747924805, + 0.0070421695709228516, + 0.0071430206298828125, + 0.007035732269287109, + 0.007105827331542969, + 0.007145404815673828, + 0.007191658020019531, + 0.0071828365325927734, + 0.007086753845214844, + 0.0072476863861083984, + 0.007150173187255859, + 0.007384538650512695, + 0.007229804992675781, + 0.007169246673583984, + 0.007285356521606445, + 0.007492780685424805, + 0.007581233978271484, + 0.007402896881103516, + 0.007477760314941406, + 0.007331371307373047, + 0.007441997528076172, + 0.0074253082275390625, + 0.007195472717285156, + 0.007241964340209961, + 0.007444620132446289, + 0.007351875305175781, + 0.007686614990234375, + 0.0072307586669921875, + 0.007142305374145508, + 0.0073451995849609375, + 0.0074689388275146484, + 0.00755620002746582, + 0.007530689239501953, + 0.008685827255249023, + 0.008925437927246094, + 0.008840560913085938, + 0.007294893264770508, + 0.007278919219970703, + 0.0072612762451171875, + 0.00737452507019043, + 0.007315158843994141, + 0.007302522659301758, + 0.0072879791259765625, + 0.0073888301849365234, + 0.00799703598022461, + 0.0077250003814697266, + 0.00764775276184082, + 0.007357120513916016, + 0.007331132888793945, + 0.007336616516113281, + 0.0075681209564208984, + 0.007628679275512695, + 0.007318735122680664, + 0.007242918014526367, + 0.007186174392700195, + 0.007077455520629883, + 0.007136344909667969, + 0.007271528244018555, + 0.007079362869262695, + 0.007128238677978516, + 0.007114887237548828, + 0.0072476863861083984, + 0.00727534294128418, + 0.007117748260498047, + 0.007132053375244141, + 0.007356405258178711, + 0.007401704788208008, + 0.007226705551147461, + 0.007290363311767578, + 0.007416963577270508, + 0.007323265075683594, + 0.007319927215576172, + 0.007511138916015625, + 0.007473945617675781, + 0.007165431976318359, + 0.0074024200439453125, + 0.007239103317260742, + 0.007195472717285156, + 0.007264852523803711, + 0.007269382476806641, + 0.007307767868041992, + 0.0074176788330078125, + 0.007481098175048828, + 0.007256984710693359, + 0.007292985916137695, + 0.007086753845214844, + 0.0071887969970703125, + 0.00728917121887207, + 0.007111310958862305, + 0.007231235504150391, + 0.007248640060424805, + 0.007193565368652344, + 0.007417201995849609, + 0.007409811019897461, + 0.007180929183959961, + 0.0072901248931884766, + 0.007146596908569336, + 0.007241487503051758, + 0.007174253463745117, + 0.0073850154876708984, + 0.007271528244018555, + 0.007237672805786133, + 0.0071904659271240234, + 0.007299661636352539, + 0.007189273834228516, + 0.007267951965332031, + 0.007172346115112305, + 0.007173061370849609, + 0.00710296630859375, + 0.007326602935791016, + 0.007146120071411133, + 0.00716710090637207, + 0.0071163177490234375, + 0.007300615310668945, + 0.007239818572998047, + 0.0071141719818115234, + 0.007052183151245117, + 0.007256984710693359, + 0.007191658020019531, + 0.007061958312988281, + 0.007135868072509766, + 0.007170677185058594, + 0.007138490676879883, + 0.007999181747436523, + 0.007155418395996094, + 0.00705409049987793, + 0.0071294307708740234, + 0.007147789001464844, + 0.0073528289794921875, + 0.007322549819946289, + 0.007256746292114258, + 0.007194042205810547, + 0.007086992263793945, + 0.007074832916259766, + 0.007119178771972656, + 0.0071985721588134766, + 0.007056236267089844, + 0.0071315765380859375, + 0.007068157196044922, + 0.007128238677978516, + 0.007146120071411133, + 0.007163524627685547, + 0.007356882095336914, + 0.007458925247192383, + 0.007225513458251953, + 0.007533550262451172, + 0.00732111930847168, + 0.0073854923248291016, + 0.007178544998168945, + 0.0074520111083984375, + 0.007168769836425781, + 0.007752895355224609, + 0.007218122482299805, + 0.0071794986724853516, + 0.0075206756591796875, + 0.007381439208984375, + 0.007287740707397461, + 0.007125377655029297, + 0.007395505905151367, + 0.007150888442993164, + 0.007214546203613281, + 0.007455348968505859, + 0.00728154182434082, + 0.0073909759521484375, + 0.007367372512817383, + 0.007147789001464844, + 0.0071599483489990234, + 0.0073130130767822266, + 0.0072705745697021484, + 0.007393360137939453, + 0.007477521896362305, + 0.007273674011230469, + 0.007323503494262695, + 0.007313251495361328, + 0.00823521614074707, + 0.008041620254516602, + 0.008969783782958984, + 0.00760197639465332, + 0.007387638092041016, + 0.007260322570800781, + 0.00745844841003418, + 0.007386207580566406, + 0.007304191589355469, + 0.007154941558837891, + 0.007363319396972656, + 0.007093191146850586, + 0.007223606109619141, + 0.0072994232177734375, + 0.007231235504150391, + 0.007204771041870117, + 0.007123470306396484, + 0.007284402847290039, + 0.007292032241821289, + 0.007462978363037109, + 0.007276296615600586, + 0.007123708724975586, + 0.00725865364074707, + 0.007309913635253906, + 0.0072078704833984375, + 0.007454872131347656, + 0.0072438716888427734, + 0.007119655609130859, + 0.007180452346801758, + 0.007284402847290039, + 0.0072154998779296875, + 0.0073070526123046875, + 0.00728297233581543, + 0.007113933563232422, + 0.007186174392700195, + 0.007155179977416992, + 0.007164478302001953, + 0.007027864456176758, + 0.007130146026611328, + 0.007166624069213867, + 0.007083415985107422, + 0.007088184356689453, + 0.0070836544036865234, + 0.007821321487426758, + 0.00718998908996582, + 0.00799560546875, + 0.007227182388305664, + 0.007270097732543945, + 0.007042646408081055, + 0.007171630859375, + 0.0070953369140625, + 0.007112741470336914, + 0.007110595703125, + 0.007214069366455078, + 0.0071866512298583984, + 0.00708770751953125, + 0.007089376449584961, + 0.007304668426513672, + 0.0072345733642578125, + 0.007218122482299805, + 0.00712132453918457, + 0.007215261459350586, + 0.0071773529052734375, + 0.007208347320556641, + 0.007088422775268555, + 0.007086038589477539, + 0.007353782653808594, + 0.007260799407958984, + 0.007149934768676758, + 0.007184028625488281, + 0.007379770278930664, + 0.007238864898681641, + 0.007335186004638672, + 0.007430553436279297, + 0.0072536468505859375, + 0.007124662399291992, + 0.007223606109619141, + 0.007154226303100586, + 0.0072019100189208984, + 0.007083415985107422, + 0.007090091705322266, + 0.007143974304199219, + 0.007209062576293945, + 0.007422685623168945, + 0.007337808609008789, + 0.007189035415649414, + 0.007152557373046875, + 0.008496761322021484, + 0.007238864898681641, + 0.007299184799194336, + 0.007205009460449219, + 0.007345676422119141, + 0.00833749771118164, + 0.007983207702636719, + 0.007524728775024414, + 0.007230997085571289, + 0.0071790218353271484, + 0.007154941558837891, + 0.007254362106323242, + 0.007234334945678711, + 0.0073931217193603516, + 0.007142305374145508, + 0.0070989131927490234, + 0.007216215133666992, + 0.007016420364379883, + 0.007245779037475586, + 0.007132530212402344, + 0.007158041000366211, + 0.0072934627532958984, + 0.0071599483489990234, + 0.007133960723876953, + 0.007160663604736328, + 0.007138729095458984, + 0.007099628448486328, + 0.007422208786010742, + 0.007198333740234375, + 0.007178783416748047, + 0.0071713924407958984, + 0.007174015045166016, + 0.00722813606262207, + 0.007526397705078125, + 0.007518291473388672, + 0.007188558578491211, + 0.007365703582763672, + 0.00729060173034668, + 0.0072078704833984375, + 0.00713658332824707, + 0.007208347320556641, + 0.0072174072265625, + 0.007230281829833984, + 0.007161617279052734, + 0.007280826568603516, + 0.007099628448486328, + 0.007163047790527344, + 0.007094860076904297, + 0.00709986686706543, + 0.0072367191314697266, + 0.007139682769775391, + 0.007180213928222656, + 0.007390737533569336, + 0.007216215133666992, + 0.007736921310424805, + 0.007616758346557617, + 0.00797414779663086, + 0.008023738861083984, + 0.007673501968383789, + 0.007364511489868164, + 0.007250308990478516, + 0.0072536468505859375, + 0.007231950759887695, + 0.0071032047271728516, + 0.00719904899597168, + 0.007136821746826172, + 0.0072133541107177734, + 0.007206916809082031, + 0.007127046585083008, + 0.007119178771972656, + 0.007170677185058594, + 0.0070972442626953125, + 0.0071332454681396484, + 0.007318258285522461, + 0.007112979888916016, + 0.007292747497558594, + 0.007104158401489258, + 0.007124900817871094, + 0.007070302963256836, + 0.007134914398193359, + 0.007099628448486328, + 0.007174253463745117, + 0.007185220718383789, + 0.007096052169799805, + 0.007190704345703125, + 0.00719451904296875, + 0.00709843635559082, + 0.0071849822998046875, + 0.007086753845214844, + 0.007205486297607422, + 0.007114887237548828, + 0.007155895233154297, + 0.007160186767578125, + 0.0071790218353271484, + 0.007619619369506836, + 0.007390260696411133, + 0.0071904659271240234, + 0.0072002410888671875, + 0.0071811676025390625, + 0.0070400238037109375, + 0.007214546203613281, + 0.007096290588378906, + 0.0071713924407958984, + 0.0070722103118896484, + 0.00741887092590332, + 0.00718998908996582, + 0.007219552993774414, + 0.0071277618408203125, + 0.007262229919433594, + 0.007213592529296875, + 0.00712895393371582, + 0.007136106491088867, + 0.007175922393798828, + 0.007081747055053711, + 0.0073206424713134766, + 0.007332324981689453, + 0.0071637630462646484, + 0.007120370864868164, + 0.007072925567626953, + 0.007289409637451172, + 0.007253170013427734, + 0.00730443000793457, + 0.0072100162506103516, + 0.007387399673461914, + 0.007208347320556641, + 0.007140398025512695, + 0.00722050666809082, + 0.0072858333587646484, + 0.007251739501953125 + ], + "average": 0.007824363708496094, + "minimum": 0.006979227066040039, + "maximum": 0.04114723205566406 +} \ No newline at end of file From 6d31b96d35f22721eae9eff9056ea0df043d44ba Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Fri, 6 Feb 2026 16:34:07 +0800 Subject: [PATCH 11/12] Plot the result of comparison of runtime --- lectures/markov_asset_numpy.ipynb | 265 +++++++ lectures/markov_asset_numpy.md | 1128 +++++++++++++++++++++++++++++ lectures/runtime_comparison.ipynb | 213 ++++++ lectures/timer_results_numpy.json | 1007 +++++++++++++++++++++++++ 4 files changed, 2613 insertions(+) create mode 100644 lectures/markov_asset_numpy.ipynb create mode 100644 lectures/markov_asset_numpy.md create mode 100644 lectures/runtime_comparison.ipynb create mode 100644 lectures/timer_results_numpy.json diff --git a/lectures/markov_asset_numpy.ipynb b/lectures/markov_asset_numpy.ipynb new file mode 100644 index 000000000..44240ff35 --- /dev/null +++ b/lectures/markov_asset_numpy.ipynb @@ -0,0 +1,265 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "id": "143dede4", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import quantecon as qe\n", + "from numpy.linalg import eigvals, solve" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0c89899c", + "metadata": {}, + "outputs": [], + "source": [ + "class AssetPriceModel:\n", + " \"\"\"\n", + " A class that stores the primitives of the asset pricing model.\n", + "\n", + " Parameters\n", + " ----------\n", + " β : scalar, float\n", + " Discount factor\n", + " mc : MarkovChain\n", + " Contains the transition matrix and set of state values for the state\n", + " process\n", + " γ : scalar(float)\n", + " Coefficient of risk aversion\n", + " g : callable\n", + " The function mapping states to growth rates\n", + "\n", + " \"\"\"\n", + " def __init__(self, β=0.96, mc=None, γ=2.0, g=np.exp):\n", + " self.β, self.γ = β, γ\n", + " self.g = g\n", + "\n", + " # A default process for the Markov chain\n", + " if mc is None:\n", + " self.ρ = 0.9\n", + " self.σ = 0.02\n", + " self.mc = qe.tauchen(n, self.ρ, self.σ)\n", + " else:\n", + " self.mc = mc\n", + "\n", + " self.n = self.mc.P.shape[0]\n", + "\n", + " def test_stability(self, Q):\n", + " \"\"\"\n", + " Stability test for a given matrix Q.\n", + " \"\"\"\n", + " sr = np.max(np.abs(eigvals(Q)))\n", + " if not sr < 1 / self.β:\n", + " msg = f\"Spectral radius condition failed with radius = {sr}\"\n", + " raise ValueError(msg)\n", + "\n", + "\n", + "def tree_price(ap):\n", + " \"\"\"\n", + " Computes the price-dividend ratio of the Lucas tree.\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + "\n", + " Returns\n", + " -------\n", + " v : array_like(float)\n", + " Lucas tree price-dividend ratio\n", + "\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values\n", + " J = P * ap.g(y)**(1 - γ)\n", + "\n", + " # Make sure that a unique solution exists\n", + " ap.test_stability(J)\n", + "\n", + " # Compute v\n", + " I = np.identity(ap.n)\n", + " Ones = np.ones(ap.n)\n", + " v = solve(I - β * J, β * J @ Ones)\n", + "\n", + " return v" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "00ec6099", + "metadata": {}, + "outputs": [], + "source": [ + "def consol_price(ap, ζ):\n", + " \"\"\"\n", + " Computes price of a consol bond with payoff ζ\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + "\n", + " ζ : scalar(float)\n", + " Coupon of the console\n", + "\n", + " Returns\n", + " -------\n", + " p : array_like(float)\n", + " Console bond prices\n", + "\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values\n", + " M = P * ap.g(y)**(- γ)\n", + "\n", + " # Make sure that a unique solution exists\n", + " ap.test_stability(M)\n", + "\n", + " # Compute price\n", + " I = np.identity(ap.n)\n", + " Ones = np.ones(ap.n)\n", + " p = solve(I - β * M, β * ζ * M @ Ones)\n", + "\n", + " return p" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "57f42de4", + "metadata": {}, + "outputs": [], + "source": [ + "def call_option(ap, ζ, p_s, ϵ=1e-7):\n", + " \"\"\"\n", + " Computes price of a call option on a consol bond.\n", + "\n", + " Parameters\n", + " ----------\n", + " ap: AssetPriceModel\n", + " An instance of AssetPriceModel containing primitives\n", + "\n", + " ζ : scalar(float)\n", + " Coupon of the console\n", + "\n", + " p_s : scalar(float)\n", + " Strike price\n", + "\n", + " ϵ : scalar(float), optional(default=1e-8)\n", + " Tolerance for infinite horizon problem\n", + "\n", + " Returns\n", + " -------\n", + " w : array_like(float)\n", + " Infinite horizon call option prices\n", + "\n", + " \"\"\"\n", + " # Simplify names, set up matrices\n", + " β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values\n", + " M = P * ap.g(y)**(- γ)\n", + "\n", + " # Make sure that a unique consol price exists\n", + " ap.test_stability(M)\n", + "\n", + " # Compute option price\n", + " p = consol_price(ap, ζ)\n", + " w = np.zeros(ap.n)\n", + " error = ϵ + 1\n", + " while error > ϵ:\n", + " # Maximize across columns\n", + " w_new = np.maximum(β * M @ w, p - p_s)\n", + " # Find maximal difference of each component and update\n", + " error = np.amax(np.abs(w - w_new))\n", + " w = w_new\n", + "\n", + " return w" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6bc6db6f", + "metadata": {}, + "outputs": [], + "source": [ + "n = 25\n", + "ap = AssetPriceModel(β=0.9)\n", + "ζ = 1.0\n", + "strike_price = 40\n", + "\n", + "x = ap.mc.state_values\n", + "\n", + "def timer_function():\n", + " p = consol_price(ap, ζ)\n", + " w = call_option(ap, ζ, strike_price)\n", + "\n", + "result = qe.timeit(\n", + " timer_function, runs=1000, verbose=False, \n", + " results=True, unit=\"milliseconds\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d4b6a2e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results saved to timer_results_numpy.json\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "# result is already a dictionary, no need to call _asdict()\n", + "result_dict = result\n", + "\n", + "# Define the filename\n", + "filename = 'timer_results_numpy.json'\n", + "\n", + "# Save the dictionary to a JSON file\n", + "with open(filename, 'w') as f:\n", + " json.dump(result_dict, f, indent=4)\n", + "\n", + "print(f\"Results saved to {filename}\")" + ] + } + ], + "metadata": { + "jupytext": { + "default_lexer": "ipython" + }, + "kernelspec": { + "display_name": "quantecon", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lectures/markov_asset_numpy.md b/lectures/markov_asset_numpy.md new file mode 100644 index 000000000..4421b37b4 --- /dev/null +++ b/lectures/markov_asset_numpy.md @@ -0,0 +1,1128 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst +kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +(mass)= +```{raw} jupyter + +``` + +# {index}`Asset Pricing: Finite State Models ` + +```{index} single: Models; Markov Asset Pricing +``` + +```{contents} Contents +:depth: 2 +``` + +```{epigraph} +"A little knowledge of geometric series goes a long way" -- Robert E. Lucas, Jr. +``` + +```{epigraph} +"Asset pricing is all about covariances" -- Lars Peter Hansen +``` + +In addition to what's in Anaconda, this lecture will need the following libraries: + +```{code-cell} ipython +--- +tags: [hide-output] +--- +!pip install quantecon +``` + +## Overview + +```{index} single: Markov Asset Pricing; Overview +``` + +An asset is a claim on one or more future payoffs. + +The spot price of an asset depends primarily on + +* the anticipated income stream +* attitudes about risk +* rates of time preference + +In this lecture, we consider some standard pricing models and dividend stream specifications. + +We study how prices and dividend-price ratios respond in these different scenarios. + +We also look at creating and pricing *derivative* assets that repackage income streams. + +Key tools for the lecture are + +* Markov processses +* formulas for predicting future values of functions of a Markov state +* a formula for predicting the discounted sum of future values of a Markov state + +Let's start with some imports: + +```{code-cell} ipython +import matplotlib.pyplot as plt +import numpy as np +import quantecon as qe +from numpy.linalg import eigvals, solve +``` + +## {index}`Pricing Models ` + +```{index} single: Models; Pricing +``` + +Let $\{d_t\}_{t \geq 0}$ be a stream of dividends + +* A time-$t$ **cum-dividend** asset is a claim to the stream $d_t, d_{t+1}, \ldots$. +* A time-$t$ **ex-dividend** asset is a claim to the stream $d_{t+1}, d_{t+2}, \ldots$. + +Let's look at some equations that we expect to hold for prices of assets under ex-dividend contracts +(we will consider cum-dividend pricing in the exercises). + +### Risk-Neutral Pricing + +```{index} single: Pricing Models; Risk-Neutral +``` + +Our first scenario is risk-neutral pricing. + +Let $\beta = 1/(1+\rho)$ be an intertemporal discount **factor**, where +$\rho$ is the **rate** at which agents discount the future. + +The basic risk-neutral asset pricing equation for pricing one unit of an ex-dividend asset is + +(mass_pra)= +```{math} +:label: rnapex + +p_t = \beta {\mathbb E}_t [d_{t+1} + p_{t+1}] +``` + +This is a simple "cost equals expected benefit" relationship. + +Here ${\mathbb E}_t [y]$ denotes the best forecast of $y$, conditioned on information available at time $t$. + +More precisely, ${\mathbb E}_t [y]$ is the mathematical expectation of $y$ conditional on information available at time $t$. + +### Pricing with Random Discount Factor + +```{index} single: Pricing Models; Risk Aversion +``` + +What happens if for some reason traders discount payouts differently depending on the state of the world? + +Michael Harrison and David Kreps {cite}`HarrisonKreps1979` and Lars Peter Hansen +and Scott Richard {cite}`HansenRichard1987` showed that in quite general +settings the price of an ex-dividend asset obeys + +```{math} +:label: lteeqs0 + +p_t = {\mathbb E}_t \left[ m_{t+1} ( d_{t+1} + p_{t+1} ) \right] +``` + +for some **stochastic discount factor** $m_{t+1}$. + +Here the fixed discount factor $\beta$ in {eq}`rnapex` has been replaced by the random variable $m_{t+1}$. + +How anticipated future payoffs are evaluated now depends on statistical properties of $m_{t+1}$. + +The stochastic discount factor can be specified to capture the idea that assets that tend to have good payoffs in bad states of the world are valued more highly than other assets whose payoffs don't behave that way. + +This is because such assets pay well when funds are more urgently wanted. + +We give examples of how the stochastic discount factor has been modeled below. + +### Asset Pricing and Covariances + +Recall that, from the definition of a conditional covariance ${\rm cov}_t (x_{t+1}, y_{t+1})$, we have + +```{math} +:label: lteeqs101 + +{\mathbb E}_t (x_{t+1} y_{t+1}) = {\rm cov}_t (x_{t+1}, y_{t+1}) + {\mathbb E}_t x_{t+1} {\mathbb E}_t y_{t+1} +``` + +If we apply this definition to the asset pricing equation {eq}`lteeqs0` we obtain + +```{math} +:label: lteeqs102 + +p_t = {\mathbb E}_t m_{t+1} {\mathbb E}_t (d_{t+1} + p_{t+1}) + {\rm cov}_t (m_{t+1}, d_{t+1}+ p_{t+1}) +``` + +It is useful to regard equation {eq}`lteeqs102` as a generalization of equation {eq}`rnapex` + +* In equation {eq}`rnapex`, the stochastic discount factor $m_{t+1} = \beta$, a constant. +* In equation {eq}`rnapex`, the covariance term ${\rm cov}_t (m_{t+1}, d_{t+1}+ p_{t+1})$ is zero because $m_{t+1} = \beta$. +* In equation {eq}`rnapex`, ${\mathbb E}_t m_{t+1}$ can be interpreted as the reciprocal of the one-period risk-free gross interest rate. +* When $m_{t+1}$ covaries more negatively with the payout $p_{t+1} + d_{t+1}$, the price of the asset is lower. + +Equation {eq}`lteeqs102` asserts that the covariance of the stochastic discount factor with the one period payout $d_{t+1} + p_{t+1}$ is an important determinant of the price $p_t$. + +We give examples of some models of stochastic discount factors that have been proposed later in this lecture and also in a [later lecture](https://python-advanced.quantecon.org/lucas_model.html). + +### The Price-Dividend Ratio + +Aside from prices, another quantity of interest is the **price-dividend ratio** $v_t := p_t / d_t$. + +Let's write down an expression that this ratio should satisfy. + +We can divide both sides of {eq}`lteeqs0` by $d_t$ to get + +```{math} +:label: pdex + +v_t = {\mathbb E}_t \left[ m_{t+1} \frac{d_{t+1}}{d_t} (1 + v_{t+1}) \right] +``` + +Below we'll discuss the implication of this equation. + +## Prices in the Risk-Neutral Case + +What can we say about price dynamics on the basis of the models described above? + +The answer to this question depends on + +1. the process we specify for dividends +1. the stochastic discount factor and how it correlates with dividends + +For now we'll study the risk-neutral case in which the stochastic discount factor is constant. + +We'll focus on how an asset price depends on a dividend process. + +### Example 1: Constant Dividends + +The simplest case is risk-neutral price of a constant, non-random dividend stream $d_t = d > 0$. + +Removing the expectation from {eq}`rnapex` and iterating forward gives + +$$ +\begin{aligned} + p_t & = \beta (d + p_{t+1}) + \\ + & = \beta (d + \beta(d + p_{t+2})) + \\ + & \quad \vdots + \\ + & = \beta (d + \beta d + \beta^2 d + \cdots + \beta^{k-2} d + \beta^{k-1} p_{t+k}) +\end{aligned} +$$ + +If $\lim_{k \rightarrow + \infty} \beta^{k-1} p_{t+k} = 0$, this sequence converges to + +```{math} +:label: ddet + +\bar p := \frac{\beta d}{1-\beta} +``` + +This is the equilibrium price in the constant dividend case. + +Indeed, simple algebra shows that setting $p_t = \bar p$ for all $t$ +satisfies the difference equation $p_t = \beta (d + p_{t+1})$. + +### Example 2: Dividends with Deterministic Growth Paths + +Consider a growing, non-random dividend process $d_{t+1} = g d_t$ +where $0 < g \beta < 1$. + +While prices are not usually constant when dividends grow over time, a price +dividend-ratio can be. + +If we guess this, substituting $v_t = v$ into {eq}`pdex` as well as our +other assumptions, we get $v = \beta g (1 + v)$. + +Since $\beta g < 1$, we have a unique positive solution: + +$$ +v = \frac{\beta g}{1 - \beta g } +$$ + +The price is then + +$$ +p_t = \frac{\beta g}{1 - \beta g } d_t +$$ + +If, in this example, we take $g = 1+\kappa$ and let +$\rho := 1/\beta - 1$, then the price becomes + +$$ +p_t = \frac{1 + \kappa}{ \rho - \kappa} d_t +$$ + +This is called the **Gordon formula**. + +(mass_mg)= +### Example 3: Markov Growth, Risk-Neutral Pricing + +Next, we consider a dividend process + +```{math} +:label: mass_fmce + +d_{t+1} = g_{t+1} d_t +``` + +The stochastic growth factor $\{g_t\}$ is given by + +$$ +g_t = g(X_t), \quad t = 1, 2, \ldots +$$ + +where + +1. $\{X_t\}$ is a finite Markov chain with state space $S$ and + transition probabilities + + $$ + P(x, y) := \mathbb P \{ X_{t+1} = y \,|\, X_t = x \} + \qquad (x, y \in S) + $$ + +1. $g$ is a given function on $S$ taking nonnegative values + +You can think of + +* $S$ as $n$ possible "states of the world" and $X_t$ as the + current state. +* $g$ as a function that maps a given state $X_t$ into a growth of dividends + factor $g_t = g(X_t)$. +* $\ln g_t = \ln (d_{t+1} / d_t)$ is the growth rate of dividends. + +(For a refresher on notation and theory for finite Markov chains see {doc}`this lecture `) + +The next figure shows a simulation, where + +* $\{X_t\}$ evolves as a discretized AR1 process produced using {ref}`Tauchen's method `. +* $g_t = \exp(X_t)$, so that $\ln g_t = X_t$ is the growth rate. + +```{code-cell} ipython +n = 7 +mc = qe.tauchen(n, 0.96, 0.25) +sim_length = 80 + +x_series = mc.simulate(sim_length, init=np.median(mc.state_values)) +g_series = np.exp(x_series) +d_series = np.cumprod(g_series) # Assumes d_0 = 1 + +series = [x_series, g_series, d_series, np.log(d_series)] +labels = ['$X_t$', '$g_t$', '$d_t$', r'$\log \, d_t$'] + +fig, axes = plt.subplots(2, 2) +for ax, s, label in zip(axes.flatten(), series, labels): + ax.plot(s, 'b-', lw=2, label=label) + ax.legend(loc='upper left', frameon=False) +plt.tight_layout() +plt.show() +``` + +#### Pricing Formula + +To obtain asset prices in this setting, let's adapt our analysis from the case of deterministic growth. + +In that case, we found that $v$ is constant. + +This encourages us to guess that, in the current case, $v_t$ is a fixed function of the state $X_t$. + +We seek a function $v$ such that the price-dividend ratio satisfies $v_t = v(X_t)$. + +We can substitute this guess into {eq}`pdex` to get + +$$ +v(X_t) = \beta {\mathbb E}_t [ g(X_{t+1}) (1 + v(X_{t+1})) ] +$$ + +If we condition on $X_t = x$, this becomes + +$$ +v(x) = \beta \sum_{y \in S} g(y) (1 + v(y)) P(x, y) +$$ + +or + +```{math} +:label: pstack + +v(x) = \beta \sum_{y \in S} K(x, y) (1 + v(y)) +\quad \text{where} \quad +K(x, y) := g(y) P(x, y) +``` + +Suppose that there are $n$ possible states $x_1, \ldots, x_n$. + +We can then think of {eq}`pstack` as $n$ stacked equations, one for each state, and write it in matrix form as + +```{math} +:label: vcumrn + +v = \beta K (\mathbb 1 + v) +``` + +Here + +* $v$ is understood to be the column vector $(v(x_1), \ldots, v(x_n))'$. +* $K$ is the matrix $(K(x_i, x_j))_{1 \leq i, j \leq n}$. +* ${\mathbb 1}$ is a column vector of ones. + +When does equation {eq}`vcumrn` have a unique solution? + +From the {ref}`Neumann series lemma ` and Gelfand's formula, equation {eq}`vcumrn` has a unique solution when $\beta K$ has spectral radius strictly less than one. + +Thus, we require that the eigenvalues of $K$ be strictly less than $\beta^{-1}$ in modulus. + +The solution is then + +```{math} +:label: rned + +v = (I - \beta K)^{-1} \beta K{\mathbb 1} +``` + +### Code + +Let's calculate and plot the price-dividend ratio at some parameters. + +As before, we'll generate $\{X_t\}$ as a {ref}`discretized AR1 process ` and set $g_t = \exp(X_t)$. + +Here's the code, including a test of the spectral radius condition + +```{code-cell} python3 +n = 25 # Size of state space +β = 0.9 +mc = qe.tauchen(n, 0.96, 0.02) + +K = mc.P * np.exp(mc.state_values) + +warning_message = "Spectral radius condition fails" +assert np.max(np.abs(eigvals(K))) < 1 / β, warning_message + +I = np.identity(n) +v = solve(I - β * K, β * K @ np.ones(n)) + +fig, ax = plt.subplots() +ax.plot(mc.state_values, v, 'g-o', lw=2, alpha=0.7, label='$v$') +ax.set_ylabel("price-dividend ratio") +ax.set_xlabel("state") +ax.legend(loc='upper left') +plt.show() +``` + +Why does the price-dividend ratio increase with the state? + +The reason is that this Markov process is positively correlated, so high +current states suggest high future states. + +Moreover, dividend growth is increasing in the state. + +The anticipation of high future dividend growth leads to a high price-dividend ratio. + +## Risk Aversion and Asset Prices + +Now let's turn to the case where agents are risk averse. + +We'll price several distinct assets, including + +* An endowment stream +* A consol (a type of bond issued by the UK government in the 19th century) +* Call options on a consol + +### Pricing a Lucas Tree + +```{index} single: Finite Markov Asset Pricing; Lucas Tree +``` + +Let's start with a version of the celebrated asset pricing model of Robert E. Lucas, Jr. {cite}`Lucas1978`. + +Lucas considered an abstract pure exchange economy with these features: + +* a single non-storable consumption good +* a Markov process that governs the total amount of the consumption good available each period +* a single *tree* that each period yields *fruit* that equals the total amount of consumption available to the economy +* a competitive market in *shares* in the tree that entitles their owners to corresponding shares of the *dividend* stream, i.e., the *fruit* stream, yielded by the tree + +* a representative consumer who in a competitive equilibrium + + * consumes the economy's entire endowment each period + * owns 100 percent of the shares in the tree + +As in {cite}`Lucas1978`, we suppose that the stochastic discount factor takes the form + +```{math} +:label: lucsdf + +m_{t+1} = \beta \frac{u'(c_{t+1})}{u'(c_t)} +``` + +where $u$ is a concave utility function and $c_t$ is time $t$ consumption of a representative consumer. + +(A derivation of this expression is given in a [later lecture](https://python-advanced.quantecon.org/lucas_model.html)) + +Assume the existence of an endowment that follows growth process {eq}`mass_fmce`. + +The asset being priced is a claim on the endowment process, i.e., the **Lucas tree** described above. + +Following {cite}`Lucas1978`, we suppose that in equilibrium the representative consumer's consumption equals the aggregate endowment, so that $d_t = c_t$ for all $t$. + +For utility, we'll assume the **constant relative risk aversion** (CRRA) +specification + +```{math} +:label: eqCRRA + +u(c) = \frac{c^{1-\gamma}}{1 - \gamma} \ {\rm with} \ \gamma > 0 +``` + +When $\gamma =1$ we let $u(c) = \ln c$. + +Inserting the CRRA specification into {eq}`lucsdf` and using $c_t = d_t$ gives + +```{math} +:label: lucsdf2 + +m_{t+1} += \beta \left(\frac{c_{t+1}}{c_t}\right)^{-\gamma} += \beta g_{t+1}^{-\gamma} +``` + +Substituting this into {eq}`pdex` gives the price-dividend ratio +formula + +$$ +v(X_t) += \beta {\mathbb E}_t +\left[ + g(X_{t+1})^{1-\gamma} (1 + v(X_{t+1}) ) +\right] +$$ (eq:neweqn101) + +Conditioning on $X_t = x$, we can write this as + +$$ +v(x) += \beta \sum_{y \in S} g(y)^{1-\gamma} (1 + v(y) ) P(x, y) +$$ + +If we let + +$$ +J(x, y) := g(y)^{1-\gamma} P(x, y) +$$ + +then we can rewrite equation {eq}`eq:neweqn101` in vector form as + +$$ +v = \beta J ({\mathbb 1} + v ) +$$ + +Assuming that the spectral radius of $J$ is strictly less than $\beta^{-1}$, this equation has the unique solution + +```{math} +:label: resolvent2 + +v = (I - \beta J)^{-1} \beta J {\mathbb 1} +``` + +We will define a function tree_price to compute $v$ given parameters stored in +the class AssetPriceModel + +```{code-cell} python3 +class AssetPriceModel: + """ + A class that stores the primitives of the asset pricing model. + + Parameters + ---------- + β : scalar, float + Discount factor + mc : MarkovChain + Contains the transition matrix and set of state values for the state + process + γ : scalar(float) + Coefficient of risk aversion + g : callable + The function mapping states to growth rates + + """ + def __init__(self, β=0.96, mc=None, γ=2.0, g=np.exp): + self.β, self.γ = β, γ + self.g = g + + # A default process for the Markov chain + if mc is None: + self.ρ = 0.9 + self.σ = 0.02 + self.mc = qe.tauchen(n, self.ρ, self.σ) + else: + self.mc = mc + + self.n = self.mc.P.shape[0] + + def test_stability(self, Q): + """ + Stability test for a given matrix Q. + """ + sr = np.max(np.abs(eigvals(Q))) + if not sr < 1 / self.β: + msg = f"Spectral radius condition failed with radius = {sr}" + raise ValueError(msg) + + +def tree_price(ap): + """ + Computes the price-dividend ratio of the Lucas tree. + + Parameters + ---------- + ap: AssetPriceModel + An instance of AssetPriceModel containing primitives + + Returns + ------- + v : array_like(float) + Lucas tree price-dividend ratio + + """ + # Simplify names, set up matrices + β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values + J = P * ap.g(y)**(1 - γ) + + # Make sure that a unique solution exists + ap.test_stability(J) + + # Compute v + I = np.identity(ap.n) + Ones = np.ones(ap.n) + v = solve(I - β * J, β * J @ Ones) + + return v +``` + +Here's a plot of $v$ as a function of the state for several values of $\gamma$, +with a positively correlated Markov process and $g(x) = \exp(x)$ + +```{code-cell} python3 +γs = [1.2, 1.4, 1.6, 1.8, 2.0] +ap = AssetPriceModel() +states = ap.mc.state_values + +fig, ax = plt.subplots() + +for γ in γs: + ap.γ = γ + v = tree_price(ap) + ax.plot(states, v, lw=2, alpha=0.6, label=rf"$\gamma = {γ}$") + +ax.set_title('Price-dividend ratio as a function of the state') +ax.set_ylabel("price-dividend ratio") +ax.set_xlabel("state") +ax.legend(loc='upper right') +plt.show() +``` + +Notice that $v$ is decreasing in each case. + +This is because, with a positively correlated state process, higher states indicate higher future consumption growth. + +With the stochastic discount factor {eq}`lucsdf2`, higher growth decreases the +discount factor, lowering the weight placed on future dividends. + +#### Special Cases + +In the special case $\gamma =1$, we have $J = P$. + +Recalling that $P^i {\mathbb 1} = {\mathbb 1}$ for all $i$ and applying {ref}`Neumann's geometric series lemma `, we are led to + +$$ +v = \beta(I-\beta P)^{-1} {\mathbb 1} += \beta \sum_{i=0}^{\infty} \beta^i P^i {\mathbb 1} += \beta \frac{1}{1 - \beta} {\mathbb 1} +$$ + +Thus, with log preferences, the price-dividend ratio for a Lucas tree is constant. + +Alternatively, if $\gamma = 0$, then $J = K$ and we recover the +risk-neutral solution {eq}`rned`. + +This is as expected, since $\gamma = 0$ implies $u(c) = c$ (and hence agents are risk-neutral). + +### A Risk-Free Consol + +Consider the same pure exchange representative agent economy. + +A risk-free consol promises to pay a constant amount $\zeta> 0$ each period. + +Recycling notation, let $p_t$ now be the price of an ex-coupon claim to the consol. + +An ex-coupon claim to the consol entitles an owner at the end of period $t$ to + +* $\zeta$ in period $t+1$, plus +* the right to sell the claim for $p_{t+1}$ next period + +The price satisfies {eq}`lteeqs0` with $d_t = \zeta$, or + +$$ +p_t = {\mathbb E}_t \left[ m_{t+1} ( \zeta + p_{t+1} ) \right] +$$ + +With the stochastic discount factor {eq}`lucsdf2`, this becomes + +```{math} +:label: consolguess1 + +p_t += {\mathbb E}_t \left[ \beta g_{t+1}^{-\gamma} ( \zeta + p_{t+1} ) \right] +``` + +Guessing a solution of the form $p_t = p(X_t)$ and conditioning on +$X_t = x$, we get + +$$ +p(x) += \beta \sum_{y \in S} g(y)^{-\gamma} (\zeta + p(y)) P(x, y) +$$ + +Letting $M(x, y) = P(x, y) g(y)^{-\gamma}$ and rewriting in vector notation +yields the solution + +```{math} +:label: consol_price + +p = (I - \beta M)^{-1} \beta M \zeta {\mathbb 1} +``` + +The above is implemented in the function consol_price. + +```{code-cell} python3 +def consol_price(ap, ζ): + """ + Computes price of a consol bond with payoff ζ + + Parameters + ---------- + ap: AssetPriceModel + An instance of AssetPriceModel containing primitives + + ζ : scalar(float) + Coupon of the console + + Returns + ------- + p : array_like(float) + Console bond prices + + """ + # Simplify names, set up matrices + β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values + M = P * ap.g(y)**(- γ) + + # Make sure that a unique solution exists + ap.test_stability(M) + + # Compute price + I = np.identity(ap.n) + Ones = np.ones(ap.n) + p = solve(I - β * M, β * ζ * M @ Ones) + + return p +``` + +### Pricing an Option to Purchase the Consol + +Let's now price options of various maturities. + +We'll study an option that gives the owner the right to purchase a consol at a price $p_S$. + +#### An Infinite Horizon Call Option + +We want to price an **infinite horizon** option to purchase a consol at a price $p_S$. + +The option entitles the owner at the beginning of a period either + +1. to purchase the bond at price $p_S$ now, or +1. not to exercise the option to purchase the asset now but to retain the right to exercise it later + +Thus, the owner either *exercises* the option now or chooses *not to exercise* and wait until next period. + +This is termed an infinite-horizon **call option** with **strike price** $p_S$. + +The owner of the option is entitled to purchase the consol at price $p_S$ at the beginning of any period, after the coupon has been paid to the previous owner of the bond. + +The fundamentals of the economy are identical with the one above, including the stochastic discount factor and the process for consumption. + +Let $w(X_t, p_S)$ be the value of the option when the time $t$ growth state is known to be $X_t$ but *before* the owner has decided whether to exercise the option +at time $t$ (i.e., today). + +Recalling that $p(X_t)$ is the value of the consol when the initial growth state is $X_t$, the value of the option satisfies + +$$ +w(X_t, p_S) += \max \left\{ + \beta \, {\mathbb E}_t \frac{u'(c_{t+1})}{u'(c_t)} w(X_{t+1}, p_S), \; + p(X_t) - p_S +\right\} +$$ + +The first term on the right is the value of waiting, while the second is the value of exercising now. + +We can also write this as + +```{math} +:label: FEoption0 + +w(x, p_S) += \max \left\{ + \beta \sum_{y \in S} P(x, y) g(y)^{-\gamma} + w (y, p_S), \; + p(x) - p_S +\right\} +``` + +With $M(x, y) = P(x, y) g(y)^{-\gamma}$ and $w$ as the vector of +values $(w(x_i), p_S)_{i = 1}^n$, we can express {eq}`FEoption0` as the nonlinear vector equation + +```{math} +:label: FEoption + +w = \max \{ \beta M w, \; p - p_S {\mathbb 1} \} +``` + +To solve {eq}`FEoption`, form an operator $T$ that maps vector $w$ +into vector $Tw$ via + +$$ +T w += \max \{ \beta M w,\; p - p_S {\mathbb 1} \} +$$ + +Start at some initial $w$ and iterate with $T$ to convergence . + +We can find the solution with the following function call_option + +```{code-cell} python3 +def call_option(ap, ζ, p_s, ϵ=1e-7): + """ + Computes price of a call option on a consol bond. + + Parameters + ---------- + ap: AssetPriceModel + An instance of AssetPriceModel containing primitives + + ζ : scalar(float) + Coupon of the console + + p_s : scalar(float) + Strike price + + ϵ : scalar(float), optional(default=1e-8) + Tolerance for infinite horizon problem + + Returns + ------- + w : array_like(float) + Infinite horizon call option prices + + """ + # Simplify names, set up matrices + β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values + M = P * ap.g(y)**(- γ) + + # Make sure that a unique consol price exists + ap.test_stability(M) + + # Compute option price + p = consol_price(ap, ζ) + w = np.zeros(ap.n) + error = ϵ + 1 + while error > ϵ: + # Maximize across columns + w_new = np.maximum(β * M @ w, p - p_s) + # Find maximal difference of each component and update + error = np.amax(np.abs(w - w_new)) + w = w_new + + return w +``` + +Here's a plot of $w$ compared to the consol price when $P_S = 40$ + +```{code-cell} python3 +ap = AssetPriceModel(β=0.9) +ζ = 1.0 +strike_price = 40 + +x = ap.mc.state_values +p = consol_price(ap, ζ) +w = call_option(ap, ζ, strike_price) + +fig, ax = plt.subplots() +ax.plot(x, p, 'b-', lw=2, label='consol price') +ax.plot(x, w, 'g-', lw=2, label='value of call option') +ax.set_xlabel("state") +ax.legend(loc='upper right') +plt.show() +``` + +In high values of the Markov growth state, the value of the option is close to zero. + +This is despite the facts that the Markov chain is irreducible and that low states --- +where the consol prices are high --- will be visited recurrently. + +The reason for low valuations in high Markov growth states is that $\beta=0.9$, so future payoffs are discounted substantially. + +### Risk-Free Rates + +Let's look at risk-free interest rates over different periods. + +#### The One-period Risk-free Interest Rate + +As before, the stochastic discount factor is $m_{t+1} = \beta g_{t+1}^{-\gamma}$. + +It follows that the reciprocal $R_t^{-1}$ of the gross risk-free interest rate $R_t$ in state $x$ is + +$$ +{\mathbb E}_t m_{t+1} = \beta \sum_{y \in S} P(x, y) g(y)^{-\gamma} +$$ + +We can write this as + +$$ +m_1 = \beta M {\mathbb 1} +$$ + +where the $i$-th element of $m_1$ is the reciprocal of the one-period gross risk-free interest rate in state $x_i$. + +#### Other Terms + +Let $m_j$ be an $n \times 1$ vector whose $i$ th component is the reciprocal of the $j$ -period gross risk-free interest rate in state $x_i$. + +Then $m_1 = \beta M$, and $m_{j+1} = M m_j$ for $j \geq 1$. + +## Exercises + +```{exercise} +:label: ma_ex1 + +In the lecture, we considered **ex-dividend assets**. + +A **cum-dividend** asset is a claim to the stream $d_t, d_{t+1}, \ldots$. + +Following {eq}`rnapex`, find the risk-neutral asset pricing equation for +one unit of a cum-dividend asset. + +With a constant, non-random dividend stream $d_t = d > 0$, what is the equilibrium +price of a cum-dividend asset? + +With a growing, non-random dividend process $d_t = g d_t$ where $0 < g \beta < 1$, +what is the equilibrium price of a cum-dividend asset? +``` + +```{solution} ma_ex1 +:class: dropdown + +For a cum-dividend asset, the basic risk-neutral asset pricing equation is + +$$ +p_t = d_t + \beta {\mathbb E}_t [ p_{t+1} ] +$$ + +(mass_ex1)= +With constant dividends, the equilibrium price is + +$$ +p_t = \frac{1}{1-\beta} d_t +$$ + +With a growing, non-random dividend process, the equilibrium price is + +$$ +p_t = \frac{1}{1 - \beta g} d_t +$$ +``` + +```{exercise-start} +:label: ma_ex2 +``` + +Consider the following primitives + +```{code-cell} python3 +n = 5 # Size of State Space +P = np.full((n, n), 0.0125) +P[range(n), range(n)] += 1 - P.sum(1) +# State values of the Markov chain +s = np.array([0.95, 0.975, 1.0, 1.025, 1.05]) +γ = 2.0 +β = 0.94 +``` + +Let $g$ be defined by $g(x) = x$ (that is, $g$ is the identity map). + +Compute the price of the Lucas tree. + +Do the same for + +* the price of the risk-free consol when $\zeta = 1$ +* the call option on the consol when $\zeta = 1$ and $p_S = 150.0$ + +```{exercise-end} +``` + +```{solution-start} ma_ex2 +:class: dropdown +``` + +First, let's enter the parameters: + +```{code-cell} python3 +n = 5 +P = np.full((n, n), 0.0125) +P[range(n), range(n)] += 1 - P.sum(1) +s = np.array([0.95, 0.975, 1.0, 1.025, 1.05]) # State values +mc = qe.MarkovChain(P, state_values=s) + +γ = 2.0 +β = 0.94 +ζ = 1.0 +p_s = 150.0 +``` + +Next, we'll create an instance of `AssetPriceModel` to feed into the +functions + +```{code-cell} python3 +apm = AssetPriceModel(β=β, mc=mc, γ=γ, g=lambda x: x) +``` + +Now we just need to call the relevant functions on the data: + +```{code-cell} python3 +tree_price(apm) +``` + +```{code-cell} python3 +consol_price(apm, ζ) +``` + +```{code-cell} python3 +call_option(apm, ζ, p_s) +``` + +Let's show the last two functions as a plot + +```{code-cell} python3 +fig, ax = plt.subplots() +ax.plot(s, consol_price(apm, ζ), label='consol') +ax.plot(s, call_option(apm, ζ, p_s), label='call option') +ax.legend() +plt.show() +``` + +```{solution-end} +``` + +```{exercise} +:label: ma_ex3 + +Let's consider finite horizon call options, which are more common than +infinite horizon ones. + +Finite horizon options obey functional equations closely related to {eq}`FEoption0`. + +A $k$ period option expires after $k$ periods. + +If we view today as date zero, a $k$ period option gives the owner the right to exercise the option to purchase the risk-free consol at the strike price $p_S$ at dates $0, 1, \ldots , k-1$. + +The option expires at time $k$. + +Thus, for $k=1, 2, \ldots$, let $w(x, k)$ be the value of a $k$-period option. + +It obeys + +$$ +w(x, k) += \max \left\{ + \beta \sum_{y \in S} P(x, y) g(y)^{-\gamma} + w (y, k-1), \; + p(x) - p_S +\right\} +$$ + +where $w(x, 0) = 0$ for all $x$. + +We can express this as a sequence of nonlinear vector equations + +$$ +w_k = \max \{ \beta M w_{k-1}, \; p - p_S {\mathbb 1} \} + \quad k =1, 2, \ldots + \quad \text{with } w_0 = 0 +$$ + +Write a function that computes $w_k$ for any given $k$. + +Compute the value of the option with `k = 5` and `k = 25` using parameter values as in {ref}`ma_ex1`. + +Is one higher than the other? Can you give intuition? +``` + +```{solution-start} ma_ex3 +:class: dropdown +``` + +Here's a suitable function: + +```{code-cell} python3 +def finite_horizon_call_option(ap, ζ, p_s, k): + """ + Computes k period option value. + """ + # Simplify names, set up matrices + β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values + M = P * ap.g(y)**(- γ) + + # Make sure that a unique solution exists + ap.test_stability(M) + + + # Compute option price + p = consol_price(ap, ζ) + w = np.zeros(ap.n) + for i in range(k): + # Maximize across columns + w = np.maximum(β * M @ w, p - p_s) + + return w +``` + +Now let's compute the option values at `k=5` and `k=25` + +```{code-cell} python3 +fig, ax = plt.subplots() +for k in [5, 25]: + w = finite_horizon_call_option(apm, ζ, p_s, k) + ax.plot(s, w, label=rf'$k = {k}$') +ax.legend() +plt.show() +``` + +Not surprisingly, options with larger $k$ are worth more. + +This is because an owner has a longer horizon over which + the option can be exercised. + +```{solution-end} +``` diff --git a/lectures/runtime_comparison.ipynb b/lectures/runtime_comparison.ipynb new file mode 100644 index 000000000..b9e018f4b --- /dev/null +++ b/lectures/runtime_comparison.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "62d7892a", + "metadata": {}, + "source": [ + "# Runtime Comparison of Asset Pricing Implementations\n", + "\n", + "This notebook compares the execution times of various implementations (NumPy, JAX CPU, JAX GPU) of asset pricing models." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6fddc1fc", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import json\n", + "import os\n", + "\n", + "# Define file paths\n", + "files = {\n", + " 'NumPy': 'timer_results_numpy.json',\n", + " 'JAX (CPU)': 'timer_results_jax_cpu.json',\n", + " 'JAX (GPU)': 'timer_results_jax_gpu.json'\n", + "}\n", + "\n", + "# Load the timing data\n", + "results = {}\n", + "for name, filename in files.items():\n", + " if os.path.exists(filename):\n", + " with open(filename, 'r') as f:\n", + " results[name] = json.load(f)\n", + " else:\n", + " print(f\"Warning: {filename} not found.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e70b0221", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NumPy: 0.0014 ms\n", + "JAX (CPU): 0.0003 ms\n", + "JAX (GPU): 0.0078 ms\n" + ] + } + ], + "source": [ + "# Process Simulation Results\n", + "averages = {}\n", + "\n", + "for name, data in results.items():\n", + " if 'average' in data:\n", + " averages[name] = data['average']\n", + " elif 'elapsed' in data:\n", + " # Calculate average if not explicitly provided\n", + " averages[name] = np.mean(data['elapsed'])\n", + "\n", + "# Display averages\n", + "for name, avg in averages.items():\n", + " print(f\"{name}: {avg:.4f} ms\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0eb86cb1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize Runtime Performance\n", + "if averages:\n", + " labels = list(averages.keys())\n", + " values = list(averages.values())\n", + "\n", + " fig, ax = plt.subplots(figsize=(10, 6))\n", + " bars = ax.bar(labels, values, color=['skyblue', 'orange', 'lightgreen'])\n", + "\n", + " ax.set_ylabel('Time (milliseconds)')\n", + " ax.set_title('Average Execution Time Comparison (n=25 states)')\n", + " \n", + " # Add labels on top of bars\n", + " for bar in bars:\n", + " height = bar.get_height()\n", + " ax.text(bar.get_x() + bar.get_width()/2., height,\n", + " f'{height:.4f} ms', ha='center', va='bottom')\n", + "\n", + " plt.show()\n", + "else:\n", + " print(\"No data available to plot.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7c3e9b95", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\edwar\\AppData\\Local\\Temp\\ipykernel_5116\\2208887528.py:14: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + " ax.boxplot(plot_data, labels=plot_labels)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize Runtime Distribution with Box Plot\n", + "if results:\n", + " plot_data = []\n", + " plot_labels = []\n", + " \n", + " for name, data in results.items():\n", + " if 'elapsed' in data:\n", + " plot_data.append(data['elapsed'])\n", + " plot_labels.append(name)\n", + " \n", + " if plot_data:\n", + " fig, ax = plt.subplots(figsize=(10, 6))\n", + " # Use 'labels' for broader compatibility\n", + " ax.boxplot(plot_data, labels=plot_labels)\n", + " ax.set_ylabel('Time (milliseconds)')\n", + " ax.set_title('Distribution of Execution Times')\n", + " ax.set_yscale('log')\n", + " plt.show()\n", + " else:\n", + " print(\"No 'elapsed' time sequences available for box plots.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fb7c5ad0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Relative Speedup (vs NumPy):\n", + "- JAX (CPU): 4.15x faster\n", + "- JAX (GPU): 0.18x faster\n" + ] + } + ], + "source": [ + "# Calculate Performance Speedup\n", + "if 'NumPy' in averages:\n", + " t_base = averages['NumPy']\n", + " print(\"Relative Speedup (vs NumPy):\")\n", + " for name, t_opt in averages.items():\n", + " if name != 'NumPy':\n", + " speedup = t_base / t_opt\n", + " print(f\"- {name}: {speedup:.2f}x faster\")\n", + "else:\n", + " print(\"NumPy results not found to calculate speedup.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantecon", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lectures/timer_results_numpy.json b/lectures/timer_results_numpy.json new file mode 100644 index 000000000..7d2369741 --- /dev/null +++ b/lectures/timer_results_numpy.json @@ -0,0 +1,1007 @@ +{ + "elapsed": [ + 0.03485107421875, + 0.003374338150024414, + 0.003468036651611328, + 0.002163410186767578, + 0.0011875629425048828, + 0.0011622905731201172, + 0.0011417865753173828, + 0.0011415481567382812, + 0.001125335693359375, + 0.002493619918823242, + 0.002718687057495117, + 0.0011758804321289062, + 0.0011055469512939453, + 0.0010995864868164062, + 0.0010933876037597656, + 0.0010962486267089844, + 0.0010788440704345703, + 0.001089334487915039, + 0.00107574462890625, + 0.0010952949523925781, + 0.0010874271392822266, + 0.0011005401611328125, + 0.0010809898376464844, + 0.0010881423950195312, + 0.0011265277862548828, + 0.0016629695892333984, + 0.001201629638671875, + 0.0017817020416259766, + 0.0011317729949951172, + 0.0011172294616699219, + 0.0010972023010253906, + 0.0010762214660644531, + 0.0010726451873779297, + 0.0010776519775390625, + 0.0010678768157958984, + 0.0010905265808105469, + 0.0011107921600341797, + 0.0010836124420166016, + 0.0012850761413574219, + 0.004054069519042969, + 0.00261688232421875, + 0.002283811569213867, + 0.0017521381378173828, + 0.001451730728149414, + 0.0011775493621826172, + 0.001119375228881836, + 0.0010952949523925781, + 0.0015110969543457031, + 0.0013339519500732422, + 0.0011794567108154297, + 0.0012125968933105469, + 0.006528377532958984, + 0.0027506351470947266, + 0.0012350082397460938, + 0.001255035400390625, + 0.0023221969604492188, + 0.0027480125427246094, + 0.002214670181274414, + 0.0012836456298828125, + 0.0011167526245117188, + 0.0011019706726074219, + 0.0011043548583984375, + 0.0010876655578613281, + 0.0011811256408691406, + 0.001074075698852539, + 0.0010907649993896484, + 0.001669168472290039, + 0.0013208389282226562, + 0.0010991096496582031, + 0.001107931137084961, + 0.0015621185302734375, + 0.0012485980987548828, + 0.0012073516845703125, + 0.0012302398681640625, + 0.0011057853698730469, + 0.0011129379272460938, + 0.0011508464813232422, + 0.001092672348022461, + 0.0010809898376464844, + 0.001085042953491211, + 0.0014019012451171875, + 0.0012331008911132812, + 0.0011157989501953125, + 0.0011129379272460938, + 0.0011093616485595703, + 0.0013425350189208984, + 0.001112222671508789, + 0.0011036396026611328, + 0.0010762214660644531, + 0.0010907649993896484, + 0.0011146068572998047, + 0.0010983943939208984, + 0.0010802745819091797, + 0.0010797977447509766, + 0.0012552738189697266, + 0.0018649101257324219, + 0.0011777877807617188, + 0.001600027084350586, + 0.001104593276977539, + 0.0010929107666015625, + 0.0010874271392822266, + 0.0010917186737060547, + 0.0010838508605957031, + 0.0010750293731689453, + 0.002599954605102539, + 0.002160310745239258, + 0.0033898353576660156, + 0.0012593269348144531, + 0.0011372566223144531, + 0.0011277198791503906, + 0.0010848045349121094, + 0.0011012554168701172, + 0.001073598861694336, + 0.0010945796966552734, + 0.0012166500091552734, + 0.001135110855102539, + 0.001386880874633789, + 0.0018775463104248047, + 0.002843141555786133, + 0.0029516220092773438, + 0.0054209232330322266, + 0.003277301788330078, + 0.0019173622131347656, + 0.006273746490478516, + 0.0031821727752685547, + 0.004769086837768555, + 0.0036094188690185547, + 0.005305767059326172, + 0.0020737648010253906, + 0.002979278564453125, + 0.0019860267639160156, + 0.0015826225280761719, + 0.0015387535095214844, + 0.00213623046875, + 0.0018558502197265625, + 0.0017545223236083984, + 0.0013089179992675781, + 0.001171112060546875, + 0.0010981559753417969, + 0.0011479854583740234, + 0.0011234283447265625, + 0.0011322498321533203, + 0.0011093616485595703, + 0.001089334487915039, + 0.0010955333709716797, + 0.0026907920837402344, + 0.0034983158111572266, + 0.0022728443145751953, + 0.0011992454528808594, + 0.001135110855102539, + 0.0011093616485595703, + 0.0010917186737060547, + 0.0011806488037109375, + 0.0011382102966308594, + 0.001186370849609375, + 0.0014882087707519531, + 0.0012843608856201172, + 0.0011796951293945312, + 0.0012350082397460938, + 0.0014605522155761719, + 0.0012030601501464844, + 0.0012226104736328125, + 0.0011637210845947266, + 0.0011091232299804688, + 0.00113677978515625, + 0.0011341571807861328, + 0.0011179447174072266, + 0.0011196136474609375, + 0.001123189926147461, + 0.0017898082733154297, + 0.0014731884002685547, + 0.0012710094451904297, + 0.001168966293334961, + 0.0011610984802246094, + 0.001905202865600586, + 0.0015821456909179688, + 0.0011708736419677734, + 0.0011119842529296875, + 0.0011129379272460938, + 0.0011630058288574219, + 0.0010981559753417969, + 0.0015418529510498047, + 0.001329660415649414, + 0.0011489391326904297, + 0.0011410713195800781, + 0.0015134811401367188, + 0.0011663436889648438, + 0.0015668869018554688, + 0.0012280941009521484, + 0.001154184341430664, + 0.0011296272277832031, + 0.0011692047119140625, + 0.0011096000671386719, + 0.001104593276977539, + 0.0010900497436523438, + 0.001363515853881836, + 0.0019228458404541016, + 0.0014526844024658203, + 0.0012683868408203125, + 0.0011360645294189453, + 0.0011208057403564453, + 0.0011715888977050781, + 0.0011522769927978516, + 0.0011277198791503906, + 0.0010824203491210938, + 0.0010952949523925781, + 0.00109100341796875, + 0.0014541149139404297, + 0.0022759437561035156, + 0.0013744831085205078, + 0.0012292861938476562, + 0.0011408329010009766, + 0.0011076927185058594, + 0.0011737346649169922, + 0.001088857650756836, + 0.0010905265808105469, + 0.0011258125305175781, + 0.0010938644409179688, + 0.0011327266693115234, + 0.001176595687866211, + 0.0015702247619628906, + 0.0012874603271484375, + 0.0012617111206054688, + 0.0016891956329345703, + 0.0011794567108154297, + 0.001123189926147461, + 0.001108407974243164, + 0.0012135505676269531, + 0.0012946128845214844, + 0.0014042854309082031, + 0.0011398792266845703, + 0.0011072158813476562, + 0.0010898113250732422, + 0.0011153221130371094, + 0.0016431808471679688, + 0.001604318618774414, + 0.001382589340209961, + 0.0011534690856933594, + 0.0011034011840820312, + 0.0011341571807861328, + 0.001325845718383789, + 0.0012369155883789062, + 0.0012214183807373047, + 0.0011260509490966797, + 0.0011248588562011719, + 0.0011436939239501953, + 0.0012674331665039062, + 0.0011260509490966797, + 0.0015482902526855469, + 0.0015690326690673828, + 0.001687765121459961, + 0.0015020370483398438, + 0.0011398792266845703, + 0.0011250972747802734, + 0.0011072158813476562, + 0.0012257099151611328, + 0.0012774467468261719, + 0.0011703968048095703, + 0.0011057853698730469, + 0.0010921955108642578, + 0.0011513233184814453, + 0.0027730464935302734, + 0.001512289047241211, + 0.002217531204223633, + 0.0011916160583496094, + 0.0016875267028808594, + 0.0011909008026123047, + 0.0011324882507324219, + 0.0012011528015136719, + 0.0011668205261230469, + 0.0011556148529052734, + 0.0011324882507324219, + 0.0025482177734375, + 0.002037525177001953, + 0.0014679431915283203, + 0.001256704330444336, + 0.0012514591217041016, + 0.0012922286987304688, + 0.002262115478515625, + 0.001550912857055664, + 0.0011663436889648438, + 0.0011281967163085938, + 0.0014116764068603516, + 0.0027217864990234375, + 0.0015273094177246094, + 0.0012850761413574219, + 0.001110076904296875, + 0.0010957717895507812, + 0.0010972023010253906, + 0.00109100341796875, + 0.0010769367218017578, + 0.0010771751403808594, + 0.0010738372802734375, + 0.0011832714080810547, + 0.0010986328125, + 0.0015099048614501953, + 0.0012195110321044922, + 0.0012102127075195312, + 0.001119852066040039, + 0.0011377334594726562, + 0.0010876655578613281, + 0.00122833251953125, + 0.0010809898376464844, + 0.0010924339294433594, + 0.0010707378387451172, + 0.0010867118835449219, + 0.0010733604431152344, + 0.0011065006256103516, + 0.0010769367218017578, + 0.0010814666748046875, + 0.002773761749267578, + 0.0012412071228027344, + 0.001115560531616211, + 0.0010924339294433594, + 0.0011150836944580078, + 0.0011487007141113281, + 0.001110076904296875, + 0.0011010169982910156, + 0.0010738372802734375, + 0.00121307373046875, + 0.001119852066040039, + 0.0011501312255859375, + 0.0010933876037597656, + 0.0015344619750976562, + 0.0013275146484375, + 0.0011837482452392578, + 0.0038280487060546875, + 0.0015041828155517578, + 0.0019593238830566406, + 0.0011684894561767578, + 0.0011365413665771484, + 0.0011358261108398438, + 0.001132965087890625, + 0.0011615753173828125, + 0.0030193328857421875, + 0.002869844436645508, + 0.0023860931396484375, + 0.0011920928955078125, + 0.001132965087890625, + 0.0011353492736816406, + 0.0011186599731445312, + 0.0011181831359863281, + 0.0010941028594970703, + 0.0011172294616699219, + 0.002175569534301758, + 0.0016019344329833984, + 0.0014064311981201172, + 0.0011987686157226562, + 0.00116729736328125, + 0.0011382102966308594, + 0.0011150836944580078, + 0.0011379718780517578, + 0.0011141300201416016, + 0.001131296157836914, + 0.0011098384857177734, + 0.001100778579711914, + 0.0010876655578613281, + 0.0016396045684814453, + 0.0013239383697509766, + 0.0011415481567382812, + 0.001104116439819336, + 0.0011191368103027344, + 0.0011243820190429688, + 0.0011181831359863281, + 0.0010786056518554688, + 0.0010874271392822266, + 0.0011096000671386719, + 0.0012176036834716797, + 0.0011348724365234375, + 0.0011060237884521484, + 0.0010986328125, + 0.001445770263671875, + 0.0014176368713378906, + 0.0013298988342285156, + 0.0025441646575927734, + 0.0016999244689941406, + 0.0015535354614257812, + 0.0019559860229492188, + 0.0033566951751708984, + 0.004685401916503906, + 0.0023102760314941406, + 0.001222372055053711, + 0.0011165142059326172, + 0.0011799335479736328, + 0.0011107921600341797, + 0.0011067390441894531, + 0.0010867118835449219, + 0.001089334487915039, + 0.0010726451873779297, + 0.0010895729064941406, + 0.0010864734649658203, + 0.0014777183532714844, + 0.0016598701477050781, + 0.001230478286743164, + 0.0011143684387207031, + 0.0011124610900878906, + 0.0011394023895263672, + 0.0011174678802490234, + 0.0010831356048583984, + 0.001092672348022461, + 0.0010731220245361328, + 0.0010876655578613281, + 0.0010766983032226562, + 0.0010826587677001953, + 0.0010728836059570312, + 0.0013573169708251953, + 0.0014412403106689453, + 0.0011451244354248047, + 0.0011248588562011719, + 0.0011115074157714844, + 0.001096963882446289, + 0.0011200904846191406, + 0.0022706985473632812, + 0.0027997493743896484, + 0.0023980140686035156, + 0.0014758110046386719, + 0.0018415451049804688, + 0.001226663589477539, + 0.0011239051818847656, + 0.0011324882507324219, + 0.0011413097381591797, + 0.0011208057403564453, + 0.0013346672058105469, + 0.0011341571807861328, + 0.001123189926147461, + 0.0011239051818847656, + 0.0011031627655029297, + 0.0011105537414550781, + 0.0010814666748046875, + 0.0010945796966552734, + 0.0014829635620117188, + 0.0011434555053710938, + 0.0011355876922607422, + 0.0011217594146728516, + 0.00121307373046875, + 0.002201080322265625, + 0.0012233257293701172, + 0.0011258125305175781, + 0.0011186599731445312, + 0.0011496543884277344, + 0.0010967254638671875, + 0.0010919570922851562, + 0.0010874271392822266, + 0.0021915435791015625, + 0.0012462139129638672, + 0.0011827945709228516, + 0.0011017322540283203, + 0.0011546611785888672, + 0.001085519790649414, + 0.0010933876037597656, + 0.0010867118835449219, + 0.0010976791381835938, + 0.001066446304321289, + 0.001096963882446289, + 0.0010833740234375, + 0.0010762214660644531, + 0.0014264583587646484, + 0.002371072769165039, + 0.001920938491821289, + 0.0011796951293945312, + 0.0010952949523925781, + 0.0011339187622070312, + 0.0011200904846191406, + 0.0011241436004638672, + 0.0011141300201416016, + 0.0011074542999267578, + 0.001087188720703125, + 0.0010924339294433594, + 0.0012171268463134766, + 0.0011017322540283203, + 0.0023763179779052734, + 0.0028586387634277344, + 0.0016222000122070312, + 0.0011513233184814453, + 0.001096963882446289, + 0.0011010169982910156, + 0.0010843276977539062, + 0.001102447509765625, + 0.0010983943939208984, + 0.0012791156768798828, + 0.001100301742553711, + 0.0014934539794921875, + 0.0012981891632080078, + 0.0011355876922607422, + 0.0010914802551269531, + 0.001119375228881836, + 0.0011246204376220703, + 0.001178741455078125, + 0.00110626220703125, + 0.0011425018310546875, + 0.0011031627655029297, + 0.0011286735534667969, + 0.001140594482421875, + 0.00116729736328125, + 0.0011746883392333984, + 0.0019061565399169922, + 0.0020551681518554688, + 0.0011572837829589844, + 0.0012259483337402344, + 0.0011684894561767578, + 0.0014827251434326172, + 0.0012373924255371094, + 0.001163482666015625, + 0.0012021064758300781, + 0.0011737346649169922, + 0.0012547969818115234, + 0.0014731884002685547, + 0.0012049674987792969, + 0.0024213790893554688, + 0.004858970642089844, + 0.0024149417877197266, + 0.0022039413452148438, + 0.0036211013793945312, + 0.004363059997558594, + 0.003587961196899414, + 0.002411365509033203, + 0.002049684524536133, + 0.0013275146484375, + 0.0019190311431884766, + 0.0017485618591308594, + 0.0022776126861572266, + 0.0017979145050048828, + 0.001201629638671875, + 0.001146078109741211, + 0.0011701583862304688, + 0.0014028549194335938, + 0.0017714500427246094, + 0.0017528533935546875, + 0.0016891956329345703, + 0.0018167495727539062, + 0.0020859241485595703, + 0.001967191696166992, + 0.0030815601348876953, + 0.002385377883911133, + 0.0017194747924804688, + 0.0023539066314697266, + 0.001661539077758789, + 0.0014624595642089844, + 0.003152608871459961, + 0.0017206668853759766, + 0.0012080669403076172, + 0.001134634017944336, + 0.001123189926147461, + 0.0011556148529052734, + 0.0011820793151855469, + 0.0012240409851074219, + 0.001220703125, + 0.0012235641479492188, + 0.0011703968048095703, + 0.0023729801177978516, + 0.001981973648071289, + 0.0016298294067382812, + 0.0024132728576660156, + 0.0012955665588378906, + 0.0011703968048095703, + 0.0011630058288574219, + 0.0011799335479736328, + 0.0011568069458007812, + 0.001163482666015625, + 0.001153707504272461, + 0.0011451244354248047, + 0.0034151077270507812, + 0.001607656478881836, + 0.0012624263763427734, + 0.0011239051818847656, + 0.0011413097381591797, + 0.00112152099609375, + 0.0011644363403320312, + 0.0012590885162353516, + 0.0011873245239257812, + 0.001116037368774414, + 0.0011115074157714844, + 0.0010886192321777344, + 0.001123189926147461, + 0.0010917186737060547, + 0.0010886192321777344, + 0.0012183189392089844, + 0.0013568401336669922, + 0.0011577606201171875, + 0.0011565685272216797, + 0.0011415481567382812, + 0.0011374950408935547, + 0.0011234283447265625, + 0.0011258125305175781, + 0.0011184215545654297, + 0.0011615753173828125, + 0.0011515617370605469, + 0.001211404800415039, + 0.0011317729949951172, + 0.0013098716735839844, + 0.0012331008911132812, + 0.001108407974243164, + 0.0010797977447509766, + 0.0010874271392822266, + 0.0010776519775390625, + 0.0010852813720703125, + 0.0011038780212402344, + 0.001138925552368164, + 0.0011053085327148438, + 0.001188516616821289, + 0.0011017322540283203, + 0.0010905265808105469, + 0.0014882087707519531, + 0.0013189315795898438, + 0.0010936260223388672, + 0.0010821819305419922, + 0.0010852813720703125, + 0.0010905265808105469, + 0.0010693073272705078, + 0.0010898113250732422, + 0.0010933876037597656, + 0.0011479854583740234, + 0.0011031627655029297, + 0.0010898113250732422, + 0.0010821819305419922, + 0.0010862350463867188, + 0.0010762214660644531, + 0.001790761947631836, + 0.001232147216796875, + 0.001132965087890625, + 0.0011069774627685547, + 0.0010991096496582031, + 0.0010824203491210938, + 0.0010981559753417969, + 0.001102447509765625, + 0.0011153221130371094, + 0.001140594482421875, + 0.0011260509490966797, + 0.0019578933715820312, + 0.0027954578399658203, + 0.001470804214477539, + 0.0012218952178955078, + 0.0010895729064941406, + 0.0011005401611328125, + 0.0010869503021240234, + 0.0010914802551269531, + 0.0010793209075927734, + 0.0011091232299804688, + 0.0011417865753173828, + 0.0011205673217773438, + 0.0010819435119628906, + 0.001088857650756836, + 0.0010752677917480469, + 0.0012841224670410156, + 0.0014388561248779297, + 0.0012018680572509766, + 0.0011069774627685547, + 0.003856658935546875, + 0.0021882057189941406, + 0.0011744499206542969, + 0.0010976791381835938, + 0.001094818115234375, + 0.0011086463928222656, + 0.0011410713195800781, + 0.0019423961639404297, + 0.001657247543334961, + 0.002398967742919922, + 0.0012192726135253906, + 0.0011203289031982422, + 0.0011861324310302734, + 0.0011086463928222656, + 0.0011096000671386719, + 0.001077890396118164, + 0.0010919570922851562, + 0.0010857582092285156, + 0.0010955333709716797, + 0.0010747909545898438, + 0.0027523040771484375, + 0.0011532306671142578, + 0.001094818115234375, + 0.0011165142059326172, + 0.0010974407196044922, + 0.001079559326171875, + 0.001085042953491211, + 0.0011725425720214844, + 0.0011310577392578125, + 0.0011293888092041016, + 0.0011026859283447266, + 0.0010766983032226562, + 0.0010890960693359375, + 0.0035543441772460938, + 0.0013790130615234375, + 0.0016644001007080078, + 0.0011091232299804688, + 0.001108407974243164, + 0.0010912418365478516, + 0.0010821819305419922, + 0.0010869503021240234, + 0.0010826587677001953, + 0.0010919570922851562, + 0.0021390914916992188, + 0.0033197402954101562, + 0.0011858940124511719, + 0.0011250972747802734, + 0.0011267662048339844, + 0.0011396408081054688, + 0.0011224746704101562, + 0.0011403560638427734, + 0.0010862350463867188, + 0.001096963882446289, + 0.0010781288146972656, + 0.0010912418365478516, + 0.0014522075653076172, + 0.001195669174194336, + 0.0014090538024902344, + 0.001529693603515625, + 0.0013744831085205078, + 0.0011458396911621094, + 0.0011241436004638672, + 0.001123189926147461, + 0.00112152099609375, + 0.0011439323425292969, + 0.0011060237884521484, + 0.0011212825775146484, + 0.0011005401611328125, + 0.0011115074157714844, + 0.0040857791900634766, + 0.0012354850769042969, + 0.001119375228881836, + 0.0011320114135742188, + 0.0012278556823730469, + 0.0012373924255371094, + 0.0011644363403320312, + 0.0011529922485351562, + 0.0011568069458007812, + 0.0011515617370605469, + 0.0011169910430908203, + 0.0011246204376220703, + 0.0010955333709716797, + 0.0011086463928222656, + 0.0018832683563232422, + 0.0016787052154541016, + 0.0013883113861083984, + 0.0012362003326416016, + 0.0011603832244873047, + 0.0013892650604248047, + 0.0012004375457763672, + 0.0011038780212402344, + 0.0010836124420166016, + 0.001125335693359375, + 0.0010886192321777344, + 0.0010972023010253906, + 0.0010783672332763672, + 0.0016660690307617188, + 0.00131988525390625, + 0.001112222671508789, + 0.001085042953491211, + 0.0011096000671386719, + 0.0011341571807861328, + 0.0011055469512939453, + 0.001085519790649414, + 0.001077890396118164, + 0.0010807514190673828, + 0.001094818115234375, + 0.0010704994201660156, + 0.0010852813720703125, + 0.0010678768157958984, + 0.0013527870178222656, + 0.001730203628540039, + 0.0016455650329589844, + 0.0013585090637207031, + 0.0011055469512939453, + 0.0010876655578613281, + 0.0011174678802490234, + 0.0010933876037597656, + 0.0010957717895507812, + 0.0010764598846435547, + 0.0010955333709716797, + 0.0010790824890136719, + 0.00107574462890625, + 0.0019028186798095703, + 0.0017538070678710938, + 0.0011589527130126953, + 0.0011060237884521484, + 0.001081705093383789, + 0.0011208057403564453, + 0.0011377334594726562, + 0.0011043548583984375, + 0.001077890396118164, + 0.0010852813720703125, + 0.0010831356048583984, + 0.001094818115234375, + 0.0010764598846435547, + 0.0010867118835449219, + 0.0010716915130615234, + 0.002593517303466797, + 0.00122833251953125, + 0.001115560531616211, + 0.0011012554168701172, + 0.0011248588562011719, + 0.0011532306671142578, + 0.0011031627655029297, + 0.0010786056518554688, + 0.0010838508605957031, + 0.0010685920715332031, + 0.0010879039764404297, + 0.001108407974243164, + 0.001115560531616211, + 0.0013682842254638672, + 0.0015168190002441406, + 0.0011801719665527344, + 0.0011138916015625, + 0.0010867118835449219, + 0.0011060237884521484, + 0.0011332035064697266, + 0.001107931137084961, + 0.0010790824890136719, + 0.0010957717895507812, + 0.0010917186737060547, + 0.0010783672332763672, + 0.0010704994201660156, + 0.001949310302734375, + 0.0013890266418457031, + 0.001310586929321289, + 0.0012617111206054688, + 0.001132965087890625, + 0.0012164115905761719, + 0.0017762184143066406, + 0.0013129711151123047, + 0.0011348724365234375, + 0.0011069774627685547, + 0.001092672348022461, + 0.0011339187622070312, + 0.0010991096496582031, + 0.0010995864868164062, + 0.0011415481567382812, + 0.002924680709838867, + 0.0021066665649414062, + 0.0015676021575927734, + 0.00159454345703125, + 0.0014965534210205078, + 0.0011682510375976562, + 0.0011210441589355469, + 0.0011336803436279297, + 0.0010960102081298828, + 0.001100778579711914, + 0.0010845661163330078, + 0.0020055770874023438, + 0.0015158653259277344, + 0.0011544227600097656, + 0.0024945735931396484, + 0.003144979476928711, + 0.001310586929321289, + 0.001184701919555664, + 0.0010895729064941406, + 0.0011138916015625, + 0.0011162757873535156, + 0.0014793872833251953, + 0.0014357566833496094, + 0.001149892807006836, + 0.0010933876037597656, + 0.0011243820190429688, + 0.0011112689971923828, + 0.0010955333709716797, + 0.0014998912811279297, + 0.0011355876922607422, + 0.0011107921600341797, + 0.0011131763458251953, + 0.0011012554168701172, + 0.0011019706726074219, + 0.0010945796966552734, + 0.0013306140899658203, + 0.0017383098602294922, + 0.0018002986907958984, + 0.0028214454650878906, + 0.0017268657684326172, + 0.0012307167053222656, + 0.0014598369598388672, + 0.0011506080627441406, + 0.0011229515075683594, + 0.0011181831359863281, + 0.0012140274047851562, + 0.0013952255249023438, + 0.0011365413665771484, + 0.0010950565338134766, + 0.0020973682403564453, + 0.0012352466583251953, + 0.0014336109161376953, + 0.0011496543884277344, + 0.0011169910430908203, + 0.0010921955108642578, + 0.001149892807006836, + 0.0011005401611328125, + 0.0011119842529296875, + 0.002541780471801758, + 0.0016026496887207031, + 0.0013556480407714844, + 0.002689361572265625, + 0.0012042522430419922, + 0.0011243820190429688, + 0.0011258125305175781, + 0.0011067390441894531, + 0.0010845661163330078, + 0.0010800361633300781, + 0.0010733604431152344, + 0.001100778579711914, + 0.0010707378387451172, + 0.0016901493072509766, + 0.0011928081512451172, + 0.0011324882507324219, + 0.0010814666748046875, + 0.0011241436004638672, + 0.0016248226165771484, + 0.0011327266693115234, + 0.0010807514190673828, + 0.0010836124420166016, + 0.0010738372802734375, + 0.0010852813720703125, + 0.0010738372802734375, + 0.0010900497436523438, + 0.0010676383972167969, + 0.0013360977172851562, + 0.0017473697662353516, + 0.00122833251953125, + 0.0012621879577636719, + 0.0013184547424316406, + 0.001138448715209961, + 0.0011076927185058594, + 0.0011589527130126953, + 0.0011196136474609375, + 0.0010902881622314453, + 0.0011048316955566406, + 0.0012805461883544922, + 0.0011317729949951172, + 0.0012664794921875, + 0.001590728759765625, + 0.0011720657348632812, + 0.0011081695556640625, + 0.001085519790649414, + 0.0011746883392333984, + 0.0011112689971923828, + 0.0011048316955566406, + 0.0010786056518554688, + 0.0011000633239746094, + 0.0010781288146972656, + 0.0010941028594970703, + 0.0011887550354003906, + 0.0012640953063964844, + 0.0010967254638671875, + 0.0013740062713623047, + 0.0020647048950195312, + 0.0011806488037109375, + 0.0010972023010253906, + 0.0010998249053955078, + 0.0011289119720458984, + 0.001129150390625, + 0.0010898113250732422, + 0.0010919570922851562, + 0.00107574462890625, + 0.0010886192321777344, + 0.0015151500701904297, + 0.00113677978515625, + 0.0018165111541748047, + 0.0013432502746582031, + 0.0012199878692626953, + 0.0011124610900878906, + 0.0010824203491210938, + 0.0011188983917236328, + 0.0011191368103027344, + 0.0010995864868164062, + 0.0010786056518554688, + 0.0011088848114013672, + 0.0010802745819091797, + 0.001094818115234375, + 0.0010766983032226562, + 0.0010895729064941406, + 0.00107574462890625, + 0.001348257064819336, + 0.0012331008911132812, + 0.0014750957489013672, + 0.0011990070343017578, + 0.0011432170867919922, + 0.0011153221130371094, + 0.0012383460998535156, + 0.0011358261108398438, + 0.0011153221130371094, + 0.0011022090911865234, + 0.0010960102081298828, + 0.0010879039764404297, + 0.0010843276977539062, + 0.0010843276977539062, + 0.0014505386352539062, + 0.0011796951293945312, + 0.0013971328735351562, + 0.0011620521545410156, + 0.0015239715576171875, + 0.0011515617370605469, + 0.0010988712310791016, + 0.0011348724365234375, + 0.0011205673217773438, + 0.0011227130889892578, + 0.0010986328125, + 0.0010759830474853516, + 0.0010898113250732422, + 0.001077890396118164, + 0.001547098159790039, + 0.0011615753173828125, + 0.0011112689971923828, + 0.0010876655578613281, + 0.0011951923370361328 + ], + "average": 0.0014057674407958985, + "minimum": 0.001066446304321289, + "maximum": 0.03485107421875 +} \ No newline at end of file From e47f94213f7ad935512598f9df9515a4b9e22692 Mon Sep 17 00:00:00 2001 From: Kenko LI Date: Sat, 7 Feb 2026 15:02:03 +0800 Subject: [PATCH 12/12] Delete runtime comparison files --- lectures/markov_asset.ipynb | 356 ---------- lectures/markov_asset_numpy.ipynb | 265 ------- lectures/runtime_comparison.ipynb | 213 ------ lectures/timer_results_jax_cpu.json | 1007 --------------------------- lectures/timer_results_jax_gpu.json | 1007 --------------------------- lectures/timer_results_numpy.json | 1007 --------------------------- 6 files changed, 3855 deletions(-) delete mode 100644 lectures/markov_asset.ipynb delete mode 100644 lectures/markov_asset_numpy.ipynb delete mode 100644 lectures/runtime_comparison.ipynb delete mode 100644 lectures/timer_results_jax_cpu.json delete mode 100644 lectures/timer_results_jax_gpu.json delete mode 100644 lectures/timer_results_numpy.json diff --git a/lectures/markov_asset.ipynb b/lectures/markov_asset.ipynb deleted file mode 100644 index 8420ada2b..000000000 --- a/lectures/markov_asset.ipynb +++ /dev/null @@ -1,356 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "view-in-github" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "ce7fce98", - "metadata": { - "id": "ce7fce98" - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import quantecon as qe\n", - "import jax\n", - "import jax.numpy as jnp\n", - "from jax.numpy.linalg import eigvals, solve\n", - "from jax.experimental import checkify\n", - "from typing import NamedTuple" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "50d12e94", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[CpuDevice(id=0)]\n" - ] - } - ], - "source": [ - "print(jax.devices())" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "b7bcf31f", - "metadata": { - "id": "b7bcf31f" - }, - "outputs": [], - "source": [ - "class MarkovChain(NamedTuple):\n", - " \"\"\"\n", - " A class that stores the primitives of a Markov chain.\n", - " Parameters\n", - " ----------\n", - " P : jnp.ndarray\n", - " Transition matrix\n", - " state_values : jnp.ndarray\n", - " The values associated with each state\n", - " \"\"\"\n", - " P: jax.Array\n", - " state_values: jax.Array\n", - "\n", - "\n", - "class AssetPriceModel(NamedTuple):\n", - " \"\"\"\n", - " A class that stores the primitives of the asset pricing model.\n", - "\n", - " Parameters\n", - " ----------\n", - " mc : MarkovChain\n", - " Contains the transition matrix and set of state values\n", - " G : jax.Array\n", - " The vector form of the function mapping states to growth rates\n", - " β : float\n", - " Discount factor\n", - " γ : float\n", - " Coefficient of risk aversion\n", - " \"\"\"\n", - " mc: MarkovChain\n", - " G: jax.Array\n", - " β: float\n", - " γ: float\n", - "\n", - "\n", - "def create_ap_model(g=jnp.exp, β=0.96, γ=2.0):\n", - " \"\"\"Create an AssetPriceModel class using standard Markov chain.\"\"\"\n", - " n, ρ, σ = 25, 0.9, 0.02\n", - " qe_mc = qe.tauchen(n, ρ, σ)\n", - " P = jnp.array(qe_mc.P)\n", - " state_values = jnp.array(qe_mc.state_values)\n", - " G = g(state_values)\n", - " mc = MarkovChain(P=P, state_values=state_values)\n", - "\n", - " return AssetPriceModel(mc=mc, G=G, β=β, γ=γ)\n", - "\n", - "\n", - "def create_customized_ap_model(mc: MarkovChain, g=jnp.exp, β=0.96, γ=2.0):\n", - " \"\"\"Create an AssetPriceModel class using a customized Markov chain.\"\"\"\n", - " G = g(mc.state_values)\n", - " return AssetPriceModel(mc=mc, G=G, β=β, γ=γ)\n", - "\n", - "\n", - "def test_stability(Q, β):\n", - " \"\"\"Stability test for a given matrix Q.\"\"\"\n", - " sr = jnp.max(jnp.abs(eigvals(Q)))\n", - " checkify.check(\n", - " sr < 1 / β,\n", - " \"Spectral radius condition failed with radius = {sr}\", sr=sr\n", - " )\n", - " return sr\n", - "\n", - "\n", - "def tree_price(ap):\n", - " \"\"\"\n", - " Computes the price-dividend ratio of the Lucas tree.\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - "\n", - " Returns\n", - " -------\n", - " v : array_like(float)\n", - " Lucas tree price-dividend ratio\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", - " J = P * G**(1 - γ)\n", - "\n", - " # Make sure that a unique solution exists\n", - " test_stability(J, β)\n", - "\n", - " # Compute v\n", - " n = J.shape[0]\n", - " I = jnp.identity(n)\n", - " Ones = jnp.ones(n)\n", - " v = solve(I - β * J, β * J @ Ones)\n", - "\n", - " return v\n", - "\n", - "# Wrap the function to be safely jitted\n", - "tree_price_jit = jax.jit(checkify.checkify(tree_price))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "29a2f7a6", - "metadata": { - "id": "29a2f7a6" - }, - "outputs": [], - "source": [ - "def consol_price(ap, ζ):\n", - " \"\"\"\n", - " Computes price of a consol bond with payoff ζ\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - "\n", - " ζ : scalar(float)\n", - " Coupon of the console\n", - "\n", - " Returns\n", - " -------\n", - " p : array_like(float)\n", - " Console bond prices\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", - " M = P * G**(- γ)\n", - "\n", - " # Make sure that a unique solution exists\n", - " test_stability(M, β)\n", - "\n", - " # Compute price\n", - " n = M.shape[0]\n", - " I = jnp.identity(n)\n", - " Ones = jnp.ones(n)\n", - " p = solve(I - β * M, β * ζ * M @ Ones)\n", - "\n", - " return p\n", - "\n", - "# Wrap the function to be safely jitted\n", - "consol_price_jit = jax.jit(checkify.checkify(consol_price))" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "8cfa0f41", - "metadata": { - "id": "8cfa0f41" - }, - "outputs": [], - "source": [ - "def call_option(ap, ζ, p_s, ϵ=1e-7):\n", - " \"\"\"\n", - " Computes price of a call option on a consol bond.\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - "\n", - " ζ : scalar(float)\n", - " Coupon of the console\n", - "\n", - " p_s : scalar(float)\n", - " Strike price\n", - "\n", - " ϵ : scalar(float), optional(default=1e-7)\n", - " Tolerance for infinite horizon problem\n", - "\n", - " Returns\n", - " -------\n", - " w : array_like(float)\n", - " Infinite horizon call option prices\n", - "\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, G = ap.β, ap.γ, ap.mc.P, ap.G\n", - " M = P * G**(- γ)\n", - "\n", - " # Make sure that a unique consol price exists\n", - " test_stability(M, β)\n", - "\n", - " # Compute option price\n", - " p = consol_price(ap, ζ)\n", - " n = M.shape[0]\n", - " w = jnp.zeros(n)\n", - " error = ϵ + 1\n", - "\n", - " def step(state):\n", - " w, _ = state\n", - " # Maximize across columns\n", - " w_new = jnp.maximum(β * M @ w, p - p_s)\n", - " # Find maximal difference of each component and update\n", - " error_new = jnp.amax(jnp.abs(w - w_new))\n", - " return (w_new, error_new)\n", - "\n", - " # Check whether converged\n", - " def cond(state):\n", - " _, error = state\n", - " return error > ϵ\n", - "\n", - " final_w, _ = jax.lax.while_loop(cond, step, (w, error))\n", - "\n", - " return final_w\n", - "\n", - "call_option_jit = jax.jit(checkify.checkify(call_option))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "7179ea30", - "metadata": { - "id": "7179ea30", - "mystnb": { - "figure": { - "caption": "Consol price and call option value\n", - "name": "fig_consol_call" - } - } - }, - "outputs": [], - "source": [ - "ap = create_ap_model(β=0.9)\n", - "ζ = 1.0\n", - "strike_price = 40\n", - "x = ap.mc.state_values\n", - "\n", - "def timer_function():\n", - " err, p = consol_price_jit(ap, ζ)\n", - " err, w = call_option_jit(ap, ζ, strike_price)\n", - "\n", - "result = qe.timeit(\n", - " timer_function, runs=1000, verbose=False, \n", - " results=True, unit=\"milliseconds\"\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "1ec35c54", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Results saved to timer_results_jax_cpu.json\n" - ] - } - ], - "source": [ - "import json\n", - "\n", - "# result is already a dictionary, no need to call _asdict()\n", - "result_dict = result\n", - "\n", - "# Define the filename\n", - "filename = 'timer_results_jax_cpu.json'\n", - "\n", - "# Save the dictionary to a JSON file\n", - "with open(filename, 'w') as f:\n", - " json.dump(result_dict, f, indent=4)\n", - "\n", - "print(f\"Results saved to {filename}\")" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "gpuType": "T4", - "include_colab_link": true, - "provenance": [] - }, - "jupytext": { - "default_lexer": "ipython" - }, - "kernelspec": { - "display_name": "quantecon", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/lectures/markov_asset_numpy.ipynb b/lectures/markov_asset_numpy.ipynb deleted file mode 100644 index 44240ff35..000000000 --- a/lectures/markov_asset_numpy.ipynb +++ /dev/null @@ -1,265 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 6, - "id": "143dede4", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import quantecon as qe\n", - "from numpy.linalg import eigvals, solve" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0c89899c", - "metadata": {}, - "outputs": [], - "source": [ - "class AssetPriceModel:\n", - " \"\"\"\n", - " A class that stores the primitives of the asset pricing model.\n", - "\n", - " Parameters\n", - " ----------\n", - " β : scalar, float\n", - " Discount factor\n", - " mc : MarkovChain\n", - " Contains the transition matrix and set of state values for the state\n", - " process\n", - " γ : scalar(float)\n", - " Coefficient of risk aversion\n", - " g : callable\n", - " The function mapping states to growth rates\n", - "\n", - " \"\"\"\n", - " def __init__(self, β=0.96, mc=None, γ=2.0, g=np.exp):\n", - " self.β, self.γ = β, γ\n", - " self.g = g\n", - "\n", - " # A default process for the Markov chain\n", - " if mc is None:\n", - " self.ρ = 0.9\n", - " self.σ = 0.02\n", - " self.mc = qe.tauchen(n, self.ρ, self.σ)\n", - " else:\n", - " self.mc = mc\n", - "\n", - " self.n = self.mc.P.shape[0]\n", - "\n", - " def test_stability(self, Q):\n", - " \"\"\"\n", - " Stability test for a given matrix Q.\n", - " \"\"\"\n", - " sr = np.max(np.abs(eigvals(Q)))\n", - " if not sr < 1 / self.β:\n", - " msg = f\"Spectral radius condition failed with radius = {sr}\"\n", - " raise ValueError(msg)\n", - "\n", - "\n", - "def tree_price(ap):\n", - " \"\"\"\n", - " Computes the price-dividend ratio of the Lucas tree.\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - "\n", - " Returns\n", - " -------\n", - " v : array_like(float)\n", - " Lucas tree price-dividend ratio\n", - "\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values\n", - " J = P * ap.g(y)**(1 - γ)\n", - "\n", - " # Make sure that a unique solution exists\n", - " ap.test_stability(J)\n", - "\n", - " # Compute v\n", - " I = np.identity(ap.n)\n", - " Ones = np.ones(ap.n)\n", - " v = solve(I - β * J, β * J @ Ones)\n", - "\n", - " return v" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "00ec6099", - "metadata": {}, - "outputs": [], - "source": [ - "def consol_price(ap, ζ):\n", - " \"\"\"\n", - " Computes price of a consol bond with payoff ζ\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - "\n", - " ζ : scalar(float)\n", - " Coupon of the console\n", - "\n", - " Returns\n", - " -------\n", - " p : array_like(float)\n", - " Console bond prices\n", - "\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values\n", - " M = P * ap.g(y)**(- γ)\n", - "\n", - " # Make sure that a unique solution exists\n", - " ap.test_stability(M)\n", - "\n", - " # Compute price\n", - " I = np.identity(ap.n)\n", - " Ones = np.ones(ap.n)\n", - " p = solve(I - β * M, β * ζ * M @ Ones)\n", - "\n", - " return p" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "57f42de4", - "metadata": {}, - "outputs": [], - "source": [ - "def call_option(ap, ζ, p_s, ϵ=1e-7):\n", - " \"\"\"\n", - " Computes price of a call option on a consol bond.\n", - "\n", - " Parameters\n", - " ----------\n", - " ap: AssetPriceModel\n", - " An instance of AssetPriceModel containing primitives\n", - "\n", - " ζ : scalar(float)\n", - " Coupon of the console\n", - "\n", - " p_s : scalar(float)\n", - " Strike price\n", - "\n", - " ϵ : scalar(float), optional(default=1e-8)\n", - " Tolerance for infinite horizon problem\n", - "\n", - " Returns\n", - " -------\n", - " w : array_like(float)\n", - " Infinite horizon call option prices\n", - "\n", - " \"\"\"\n", - " # Simplify names, set up matrices\n", - " β, γ, P, y = ap.β, ap.γ, ap.mc.P, ap.mc.state_values\n", - " M = P * ap.g(y)**(- γ)\n", - "\n", - " # Make sure that a unique consol price exists\n", - " ap.test_stability(M)\n", - "\n", - " # Compute option price\n", - " p = consol_price(ap, ζ)\n", - " w = np.zeros(ap.n)\n", - " error = ϵ + 1\n", - " while error > ϵ:\n", - " # Maximize across columns\n", - " w_new = np.maximum(β * M @ w, p - p_s)\n", - " # Find maximal difference of each component and update\n", - " error = np.amax(np.abs(w - w_new))\n", - " w = w_new\n", - "\n", - " return w" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "6bc6db6f", - "metadata": {}, - "outputs": [], - "source": [ - "n = 25\n", - "ap = AssetPriceModel(β=0.9)\n", - "ζ = 1.0\n", - "strike_price = 40\n", - "\n", - "x = ap.mc.state_values\n", - "\n", - "def timer_function():\n", - " p = consol_price(ap, ζ)\n", - " w = call_option(ap, ζ, strike_price)\n", - "\n", - "result = qe.timeit(\n", - " timer_function, runs=1000, verbose=False, \n", - " results=True, unit=\"milliseconds\"\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "d4b6a2e3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Results saved to timer_results_numpy.json\n" - ] - } - ], - "source": [ - "import json\n", - "\n", - "# result is already a dictionary, no need to call _asdict()\n", - "result_dict = result\n", - "\n", - "# Define the filename\n", - "filename = 'timer_results_numpy.json'\n", - "\n", - "# Save the dictionary to a JSON file\n", - "with open(filename, 'w') as f:\n", - " json.dump(result_dict, f, indent=4)\n", - "\n", - "print(f\"Results saved to {filename}\")" - ] - } - ], - "metadata": { - "jupytext": { - "default_lexer": "ipython" - }, - "kernelspec": { - "display_name": "quantecon", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/lectures/runtime_comparison.ipynb b/lectures/runtime_comparison.ipynb deleted file mode 100644 index b9e018f4b..000000000 --- a/lectures/runtime_comparison.ipynb +++ /dev/null @@ -1,213 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "62d7892a", - "metadata": {}, - "source": [ - "# Runtime Comparison of Asset Pricing Implementations\n", - "\n", - "This notebook compares the execution times of various implementations (NumPy, JAX CPU, JAX GPU) of asset pricing models." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "6fddc1fc", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import json\n", - "import os\n", - "\n", - "# Define file paths\n", - "files = {\n", - " 'NumPy': 'timer_results_numpy.json',\n", - " 'JAX (CPU)': 'timer_results_jax_cpu.json',\n", - " 'JAX (GPU)': 'timer_results_jax_gpu.json'\n", - "}\n", - "\n", - "# Load the timing data\n", - "results = {}\n", - "for name, filename in files.items():\n", - " if os.path.exists(filename):\n", - " with open(filename, 'r') as f:\n", - " results[name] = json.load(f)\n", - " else:\n", - " print(f\"Warning: {filename} not found.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e70b0221", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NumPy: 0.0014 ms\n", - "JAX (CPU): 0.0003 ms\n", - "JAX (GPU): 0.0078 ms\n" - ] - } - ], - "source": [ - "# Process Simulation Results\n", - "averages = {}\n", - "\n", - "for name, data in results.items():\n", - " if 'average' in data:\n", - " averages[name] = data['average']\n", - " elif 'elapsed' in data:\n", - " # Calculate average if not explicitly provided\n", - " averages[name] = np.mean(data['elapsed'])\n", - "\n", - "# Display averages\n", - "for name, avg in averages.items():\n", - " print(f\"{name}: {avg:.4f} ms\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0eb86cb1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualize Runtime Performance\n", - "if averages:\n", - " labels = list(averages.keys())\n", - " values = list(averages.values())\n", - "\n", - " fig, ax = plt.subplots(figsize=(10, 6))\n", - " bars = ax.bar(labels, values, color=['skyblue', 'orange', 'lightgreen'])\n", - "\n", - " ax.set_ylabel('Time (milliseconds)')\n", - " ax.set_title('Average Execution Time Comparison (n=25 states)')\n", - " \n", - " # Add labels on top of bars\n", - " for bar in bars:\n", - " height = bar.get_height()\n", - " ax.text(bar.get_x() + bar.get_width()/2., height,\n", - " f'{height:.4f} ms', ha='center', va='bottom')\n", - "\n", - " plt.show()\n", - "else:\n", - " print(\"No data available to plot.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "7c3e9b95", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\edwar\\AppData\\Local\\Temp\\ipykernel_5116\\2208887528.py:14: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", - " ax.boxplot(plot_data, labels=plot_labels)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualize Runtime Distribution with Box Plot\n", - "if results:\n", - " plot_data = []\n", - " plot_labels = []\n", - " \n", - " for name, data in results.items():\n", - " if 'elapsed' in data:\n", - " plot_data.append(data['elapsed'])\n", - " plot_labels.append(name)\n", - " \n", - " if plot_data:\n", - " fig, ax = plt.subplots(figsize=(10, 6))\n", - " # Use 'labels' for broader compatibility\n", - " ax.boxplot(plot_data, labels=plot_labels)\n", - " ax.set_ylabel('Time (milliseconds)')\n", - " ax.set_title('Distribution of Execution Times')\n", - " ax.set_yscale('log')\n", - " plt.show()\n", - " else:\n", - " print(\"No 'elapsed' time sequences available for box plots.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "fb7c5ad0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Relative Speedup (vs NumPy):\n", - "- JAX (CPU): 4.15x faster\n", - "- JAX (GPU): 0.18x faster\n" - ] - } - ], - "source": [ - "# Calculate Performance Speedup\n", - "if 'NumPy' in averages:\n", - " t_base = averages['NumPy']\n", - " print(\"Relative Speedup (vs NumPy):\")\n", - " for name, t_opt in averages.items():\n", - " if name != 'NumPy':\n", - " speedup = t_base / t_opt\n", - " print(f\"- {name}: {speedup:.2f}x faster\")\n", - "else:\n", - " print(\"NumPy results not found to calculate speedup.\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "quantecon", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/lectures/timer_results_jax_cpu.json b/lectures/timer_results_jax_cpu.json deleted file mode 100644 index f18d2966d..000000000 --- a/lectures/timer_results_jax_cpu.json +++ /dev/null @@ -1,1007 +0,0 @@ -{ - "elapsed": [ - 0.1983966827392578, - 9.870529174804688e-05, - 4.2438507080078125e-05, - 4.00543212890625e-05, - 4.00543212890625e-05, - 4.267692565917969e-05, - 3.600120544433594e-05, - 3.8623809814453125e-05, - 4.076957702636719e-05, - 3.7670135498046875e-05, - 4.1484832763671875e-05, - 3.457069396972656e-05, - 3.600120544433594e-05, - 3.409385681152344e-05, - 3.457069396972656e-05, - 3.2901763916015625e-05, - 5.841255187988281e-05, - 3.62396240234375e-05, - 9.655952453613281e-05, - 8.511543273925781e-05, - 0.0001938343048095703, - 0.0002701282501220703, - 6.747245788574219e-05, - 0.00013136863708496094, - 0.0001270771026611328, - 0.00015163421630859375, - 0.0001456737518310547, - 0.00012922286987304688, - 0.0001277923583984375, - 0.00012993812561035156, - 0.00013256072998046875, - 0.00013303756713867188, - 0.00012826919555664062, - 0.000141143798828125, - 0.0001270771026611328, - 0.00012755393981933594, - 0.00019311904907226562, - 0.00010895729064941406, - 0.0001773834228515625, - 0.00014662742614746094, - 9.632110595703125e-05, - 0.00031495094299316406, - 0.000164031982421875, - 0.0001583099365234375, - 0.0003082752227783203, - 0.00018095970153808594, - 7.939338684082031e-05, - 0.00012421607971191406, - 0.0001709461212158203, - 0.00013637542724609375, - 0.0001423358917236328, - 0.00013899803161621094, - 0.00013637542724609375, - 0.00017213821411132812, - 0.00012135505676269531, - 0.0001227855682373047, - 0.0001544952392578125, - 0.0001423358917236328, - 0.00013875961303710938, - 0.0001385211944580078, - 0.0001392364501953125, - 0.0001399517059326172, - 0.00013709068298339844, - 0.0001373291015625, - 0.0001430511474609375, - 0.0001380443572998047, - 0.00014209747314453125, - 0.00014257431030273438, - 0.00013637542724609375, - 0.00013947486877441406, - 0.00014066696166992188, - 0.0001392364501953125, - 0.00013780593872070312, - 0.00013971328735351562, - 0.00013756752014160156, - 0.0001399517059326172, - 0.00013637542724609375, - 0.00013709068298339844, - 0.0001361370086669922, - 0.00014066696166992188, - 0.000141143798828125, - 0.00013780593872070312, - 0.00013756752014160156, - 0.00013709068298339844, - 0.0001366138458251953, - 0.0001385211944580078, - 0.00013637542724609375, - 0.0001366138458251953, - 0.0001366138458251953, - 0.00013780593872070312, - 0.0001354217529296875, - 0.00013828277587890625, - 0.00013589859008789062, - 0.00013566017150878906, - 0.00013685226440429688, - 0.00013685226440429688, - 0.0001366138458251953, - 0.0001366138458251953, - 0.0001361370086669922, - 0.00013756752014160156, - 0.0001354217529296875, - 0.00013899803161621094, - 0.0001366138458251953, - 0.00013780593872070312, - 0.00013756752014160156, - 0.00013637542724609375, - 0.0001361370086669922, - 0.00013756752014160156, - 0.0001366138458251953, - 0.00013566017150878906, - 0.00013756752014160156, - 0.0001366138458251953, - 0.0001366138458251953, - 0.00013637542724609375, - 0.0001373291015625, - 0.0001392364501953125, - 0.00013875961303710938, - 0.00013828277587890625, - 0.00013875961303710938, - 0.00013566017150878906, - 0.0001361370086669922, - 0.00013709068298339844, - 0.00013709068298339844, - 0.00013875961303710938, - 0.00013756752014160156, - 0.0001385211944580078, - 0.00013589859008789062, - 0.00013709068298339844, - 0.00013637542724609375, - 0.0001354217529296875, - 0.00013709068298339844, - 0.0001380443572998047, - 0.00013518333435058594, - 0.00018405914306640625, - 0.0003001689910888672, - 0.00013113021850585938, - 0.00017833709716796875, - 0.0001518726348876953, - 0.0001304149627685547, - 0.00013780593872070312, - 0.00013685226440429688, - 0.0001380443572998047, - 0.0001366138458251953, - 0.0001366138458251953, - 0.00013589859008789062, - 0.00013685226440429688, - 0.00013518333435058594, - 0.00013566017150878906, - 0.00013709068298339844, - 0.0001354217529296875, - 0.00013828277587890625, - 0.0001373291015625, - 0.0003345012664794922, - 0.0002722740173339844, - 0.00013518333435058594, - 0.0001327991485595703, - 0.00021457672119140625, - 0.0001544952392578125, - 0.00019359588623046875, - 0.00011420249938964844, - 0.00014710426330566406, - 0.000110626220703125, - 0.00016617774963378906, - 0.00013113021850585938, - 0.00013875961303710938, - 0.00011920928955078125, - 0.0001475811004638672, - 0.0001270771026611328, - 0.00012445449829101562, - 0.00014352798461914062, - 0.00010800361633300781, - 0.0001773834228515625, - 0.00022864341735839844, - 0.00022292137145996094, - 0.0001862049102783203, - 0.00016164779663085938, - 0.0001678466796875, - 0.00015044212341308594, - 0.00017523765563964844, - 9.369850158691406e-05, - 0.0001251697540283203, - 0.00015497207641601562, - 0.00015854835510253906, - 0.0001373291015625, - 0.00014448165893554688, - 0.0001430511474609375, - 0.0001494884490966797, - 0.00014138221740722656, - 0.00014138221740722656, - 0.00014352798461914062, - 0.0002734661102294922, - 0.0001533031463623047, - 0.00010776519775390625, - 0.00010418891906738281, - 0.00010156631469726562, - 9.298324584960938e-05, - 0.0001647472381591797, - 0.0001270771026611328, - 0.00014138221740722656, - 0.00013828277587890625, - 0.00013756752014160156, - 0.0001354217529296875, - 0.00013828277587890625, - 0.00013518333435058594, - 0.00013709068298339844, - 0.00013685226440429688, - 0.0001392364501953125, - 0.00013637542724609375, - 0.00013756752014160156, - 0.00013828277587890625, - 0.00013518333435058594, - 0.00013828277587890625, - 0.00013637542724609375, - 0.00013780593872070312, - 0.00013756752014160156, - 0.00013637542724609375, - 0.0001361370086669922, - 0.0001354217529296875, - 0.00013756752014160156, - 0.0001347064971923828, - 0.00013685226440429688, - 0.0001385211944580078, - 0.00013828277587890625, - 0.0001373291015625, - 0.0001392364501953125, - 0.00013303756713867188, - 0.00013637542724609375, - 0.00013566017150878906, - 0.0001347064971923828, - 0.00013566017150878906, - 0.0001373291015625, - 0.00013685226440429688, - 0.00013494491577148438, - 0.00013375282287597656, - 0.00013589859008789062, - 0.00013637542724609375, - 0.00013756752014160156, - 0.00013518333435058594, - 0.00017833709716796875, - 0.00012373924255371094, - 0.0001316070556640625, - 0.0001246929168701172, - 0.00021505355834960938, - 0.00015163421630859375, - 0.00010728836059570312, - 0.0001461505889892578, - 0.00014352798461914062, - 0.00013828277587890625, - 0.0001392364501953125, - 0.0001380443572998047, - 0.0001380443572998047, - 0.00013685226440429688, - 0.00013780593872070312, - 0.00013756752014160156, - 0.0001385211944580078, - 0.00013709068298339844, - 0.00013828277587890625, - 0.00013780593872070312, - 0.00013709068298339844, - 0.00013566017150878906, - 0.0001373291015625, - 0.00013685226440429688, - 0.00017452239990234375, - 0.0001468658447265625, - 0.00018286705017089844, - 0.0002701282501220703, - 4.8160552978515625e-05, - 0.00021910667419433594, - 0.0001289844512939453, - 0.00016188621520996094, - 0.00020956993103027344, - 4.6253204345703125e-05, - 0.00014519691467285156, - 0.0001220703125, - 0.00011181831359863281, - 0.0001285076141357422, - 0.0001842975616455078, - 0.00015234947204589844, - 0.0001544952392578125, - 0.0001239776611328125, - 0.0001285076141357422, - 0.00012874603271484375, - 0.00012731552124023438, - 0.0001277923583984375, - 0.00013589859008789062, - 0.00011897087097167969, - 0.00012063980102539062, - 0.00015497207641601562, - 0.0001723766326904297, - 0.00013899803161621094, - 0.0001404285430908203, - 0.00013709068298339844, - 0.00013685226440429688, - 0.0001366138458251953, - 0.00013637542724609375, - 0.00015282630920410156, - 0.00013685226440429688, - 0.0002186298370361328, - 0.00012922286987304688, - 0.0001251697540283203, - 0.0001266002655029297, - 0.0001277923583984375, - 0.00011920928955078125, - 0.00012540817260742188, - 0.00012683868408203125, - 0.00012922286987304688, - 0.00013017654418945312, - 0.00013256072998046875, - 0.00013017654418945312, - 0.0001270771026611328, - 0.00012969970703125, - 0.00013875961303710938, - 0.00012564659118652344, - 0.00012636184692382812, - 0.00012612342834472656, - 0.00012564659118652344, - 0.000125885009765625, - 0.00012612342834472656, - 0.00012731552124023438, - 0.0001251697540283203, - 0.0001266002655029297, - 0.00012540817260742188, - 0.0001251697540283203, - 0.00012683868408203125, - 0.0001251697540283203, - 0.000125885009765625, - 0.00012445449829101562, - 0.00012922286987304688, - 0.00012731552124023438, - 0.00012540817260742188, - 0.00012683868408203125, - 0.0001270771026611328, - 0.0001735687255859375, - 8.606910705566406e-05, - 0.00012493133544921875, - 0.00012803077697753906, - 0.0001270771026611328, - 0.00015544891357421875, - 0.00014352798461914062, - 0.00013780593872070312, - 0.00014066696166992188, - 0.00014209747314453125, - 0.0001366138458251953, - 0.00013589859008789062, - 0.00013256072998046875, - 0.00013589859008789062, - 0.0001380443572998047, - 0.00013566017150878906, - 0.00013899803161621094, - 0.0001366138458251953, - 0.00014925003051757812, - 0.00012350082397460938, - 0.0001277923583984375, - 0.00012373924255371094, - 0.00012803077697753906, - 0.00012564659118652344, - 0.0001266002655029297, - 0.00012564659118652344, - 0.0001289844512939453, - 0.00013899803161621094, - 0.00012493133544921875, - 0.00012683868408203125, - 0.0001246929168701172, - 0.0001308917999267578, - 0.000125885009765625, - 0.00012540817260742188, - 0.0001266002655029297, - 0.00012683868408203125, - 0.00012445449829101562, - 0.00012445449829101562, - 0.00012540817260742188, - 0.00013208389282226562, - 0.00011920928955078125, - 0.00012493133544921875, - 0.0001251697540283203, - 0.0001342296600341797, - 0.00011348724365234375, - 0.00012564659118652344, - 0.00014638900756835938, - 0.00014543533325195312, - 0.00013303756713867188, - 0.0001354217529296875, - 0.0001361370086669922, - 0.0001404285430908203, - 0.00013756752014160156, - 0.00014090538024902344, - 0.0001418590545654297, - 0.0003788471221923828, - 9.274482727050781e-05, - 4.4345855712890625e-05, - 0.0001533031463623047, - 0.0001404285430908203, - 0.00014543533325195312, - 0.00015974044799804688, - 0.00011277198791503906, - 0.000148773193359375, - 0.00010704994201660156, - 0.0001232624053955078, - 0.00013184547424316406, - 0.0001316070556640625, - 0.00013184547424316406, - 0.0001285076141357422, - 0.00013065338134765625, - 0.00014328956604003906, - 0.00013303756713867188, - 0.00013065338134765625, - 0.00013184547424316406, - 0.00013446807861328125, - 0.000133514404296875, - 0.00012922286987304688, - 0.00016355514526367188, - 0.00013971328735351562, - 0.00019598007202148438, - 0.0003581047058105469, - 7.987022399902344e-05, - 0.0001418590545654297, - 0.00012969970703125, - 0.00012803077697753906, - 0.00012922286987304688, - 0.0001323223114013672, - 0.00013208389282226562, - 0.00013136863708496094, - 0.0001285076141357422, - 0.00012636184692382812, - 0.00012803077697753906, - 0.00015735626220703125, - 0.00010085105895996094, - 0.00012302398681640625, - 0.0001461505889892578, - 0.00012040138244628906, - 0.00012874603271484375, - 0.00012683868408203125, - 0.00012969970703125, - 0.0002593994140625, - 0.00011301040649414062, - 9.083747863769531e-05, - 8.511543273925781e-05, - 8.463859558105469e-05, - 0.0001537799835205078, - 9.369850158691406e-05, - 0.0001266002655029297, - 0.00012922286987304688, - 0.0001266002655029297, - 0.00013446807861328125, - 0.0001289844512939453, - 0.0001270771026611328, - 0.00013017654418945312, - 0.00012755393981933594, - 0.00012803077697753906, - 0.00013113021850585938, - 0.0002148151397705078, - 0.0001461505889892578, - 0.00015783309936523438, - 0.0001518726348876953, - 0.00013136863708496094, - 0.00012803077697753906, - 0.00012755393981933594, - 0.00012731552124023438, - 0.00012826919555664062, - 0.0001277923583984375, - 0.00012874603271484375, - 0.0001277923583984375, - 0.0001285076141357422, - 0.000125885009765625, - 0.0001270771026611328, - 0.0001285076141357422, - 0.0001323223114013672, - 0.00012803077697753906, - 0.0001277923583984375, - 0.0001304149627685547, - 0.00012564659118652344, - 0.0001304149627685547, - 0.00012612342834472656, - 0.00012612342834472656, - 0.00012683868408203125, - 0.0001289844512939453, - 0.0001285076141357422, - 0.00012683868408203125, - 0.00012683868408203125, - 0.00012755393981933594, - 0.00012636184692382812, - 0.0001316070556640625, - 0.00012636184692382812, - 0.00012969970703125, - 0.00012731552124023438, - 0.0001285076141357422, - 0.00012731552124023438, - 0.0001556873321533203, - 0.00015211105346679688, - 0.0001289844512939453, - 0.00012636184692382812, - 0.00012922286987304688, - 0.00013184547424316406, - 0.00012922286987304688, - 0.0001270771026611328, - 0.00012922286987304688, - 0.0001285076141357422, - 0.00012683868408203125, - 0.00012826919555664062, - 0.00012731552124023438, - 0.00013065338134765625, - 0.00013327598571777344, - 0.00012969970703125, - 0.00012540817260742188, - 0.00012922286987304688, - 0.00012874603271484375, - 0.00012803077697753906, - 0.00012731552124023438, - 0.0001270771026611328, - 0.00025844573974609375, - 0.0005631446838378906, - 0.0001468658447265625, - 0.00013017654418945312, - 0.00013375282287597656, - 0.0001316070556640625, - 0.0001342296600341797, - 0.00013113021850585938, - 0.00012731552124023438, - 0.00013113021850585938, - 0.00012755393981933594, - 0.0001285076141357422, - 0.000125885009765625, - 0.00012993812561035156, - 0.0001392364501953125, - 0.00013136863708496094, - 0.00012969970703125, - 0.0001308917999267578, - 0.00012683868408203125, - 0.0001499652862548828, - 0.00010848045349121094, - 0.0001246929168701172, - 0.00012683868408203125, - 0.00012612342834472656, - 0.00013017654418945312, - 0.00012993812561035156, - 0.0001304149627685547, - 0.0001289844512939453, - 0.0001308917999267578, - 0.0001246929168701172, - 0.00013375282287597656, - 0.00013184547424316406, - 0.00012612342834472656, - 0.0001289844512939453, - 0.00012874603271484375, - 0.00013136863708496094, - 0.0001323223114013672, - 0.00012826919555664062, - 0.00012993812561035156, - 0.0001289844512939453, - 0.00012874603271484375, - 0.0001270771026611328, - 0.0002155303955078125, - 0.0001571178436279297, - 0.0001571178436279297, - 0.00015401840209960938, - 0.0001289844512939453, - 0.00012111663818359375, - 0.0001277923583984375, - 0.0001277923583984375, - 0.00012731552124023438, - 0.0001277923583984375, - 0.0001304149627685547, - 0.00012540817260742188, - 0.00012683868408203125, - 0.00012731552124023438, - 0.00012946128845214844, - 0.000125885009765625, - 0.00017070770263671875, - 0.00013256072998046875, - 0.00013136863708496094, - 0.0001304149627685547, - 0.00012969970703125, - 0.00012946128845214844, - 0.0001277923583984375, - 0.00012826919555664062, - 0.00013017654418945312, - 0.00012826919555664062, - 0.0001277923583984375, - 0.0001277923583984375, - 0.00012636184692382812, - 0.00017213821411132812, - 0.0001506805419921875, - 0.000133514404296875, - 0.00013113021850585938, - 0.00013327598571777344, - 0.00012731552124023438, - 0.0001270771026611328, - 0.00012731552124023438, - 0.00012874603271484375, - 0.0001277923583984375, - 0.00012683868408203125, - 0.0001289844512939453, - 0.0001285076141357422, - 0.00012755393981933594, - 0.0001304149627685547, - 0.00012946128845214844, - 0.00012993812561035156, - 0.0001266002655029297, - 0.00012826919555664062, - 0.00012683868408203125, - 0.00012803077697753906, - 0.00012993812561035156, - 0.00012612342834472656, - 0.0001304149627685547, - 0.00012636184692382812, - 0.0001289844512939453, - 0.00012612342834472656, - 0.0001266002655029297, - 0.00012946128845214844, - 0.00013303756713867188, - 0.00012922286987304688, - 0.0001266002655029297, - 0.00012636184692382812, - 0.00012636184692382812, - 0.000125885009765625, - 0.00012803077697753906, - 0.0001270771026611328, - 0.00012969970703125, - 0.0001246929168701172, - 0.00012922286987304688, - 0.00012946128845214844, - 0.0001285076141357422, - 0.0001285076141357422, - 0.00012731552124023438, - 0.0001277923583984375, - 0.0001327991485595703, - 0.0001327991485595703, - 0.0001270771026611328, - 0.00012302398681640625, - 0.0001399517059326172, - 0.0004208087921142578, - 0.00013756752014160156, - 0.00043964385986328125, - 0.00018024444580078125, - 0.0003104209899902344, - 0.0001652240753173828, - 0.00010251998901367188, - 0.00012063980102539062, - 0.00015234947204589844, - 0.00012969970703125, - 0.00018405914306640625, - 0.00012946128845214844, - 0.000156402587890625, - 0.00013828277587890625, - 0.0001316070556640625, - 0.00013828277587890625, - 0.0001354217529296875, - 0.00014400482177734375, - 0.0001590251922607422, - 0.00011777877807617188, - 0.00014638900756835938, - 0.00010824203491210938, - 0.00014638900756835938, - 0.00013875961303710938, - 0.00011968612670898438, - 0.0002548694610595703, - 0.000125885009765625, - 3.62396240234375e-05, - 6.222724914550781e-05, - 0.00015854835510253906, - 0.00013375282287597656, - 0.00013375282287597656, - 0.00013399124145507812, - 0.00012826919555664062, - 0.0001327991485595703, - 0.00013208389282226562, - 0.00013303756713867188, - 0.00013208389282226562, - 0.00013113021850585938, - 0.00012803077697753906, - 0.00017786026000976562, - 0.00014710426330566406, - 0.0001308917999267578, - 0.0001246929168701172, - 0.00013208389282226562, - 0.0001289844512939453, - 0.00013065338134765625, - 0.00012922286987304688, - 0.00015163421630859375, - 0.00012946128845214844, - 0.00013065338134765625, - 0.0001277923583984375, - 0.00012946128845214844, - 0.0001266002655029297, - 0.0001239776611328125, - 0.00012803077697753906, - 0.00012803077697753906, - 0.00012874603271484375, - 0.0001316070556640625, - 0.00012993812561035156, - 0.00017070770263671875, - 0.0001475811004638672, - 0.0001323223114013672, - 0.0001285076141357422, - 0.00012731552124023438, - 0.0001289844512939453, - 0.00013256072998046875, - 0.00012946128845214844, - 0.0001308917999267578, - 0.00012874603271484375, - 0.00012826919555664062, - 0.00012731552124023438, - 0.00012993812561035156, - 0.00012803077697753906, - 0.0001354217529296875, - 0.00013065338134765625, - 0.0001366138458251953, - 0.000152587890625, - 0.00012993812561035156, - 0.00012874603271484375, - 0.00013065338134765625, - 0.00012969970703125, - 0.00013017654418945312, - 0.00013327598571777344, - 0.00013256072998046875, - 0.0001456737518310547, - 0.00012493133544921875, - 0.0001289844512939453, - 0.00012993812561035156, - 0.00013303756713867188, - 0.00013256072998046875, - 0.0001316070556640625, - 0.00012731552124023438, - 0.0001289844512939453, - 0.00014090538024902344, - 0.00015234947204589844, - 0.0001285076141357422, - 0.0001277923583984375, - 0.0001289844512939453, - 0.00013136863708496094, - 0.00012755393981933594, - 0.00012683868408203125, - 0.00012755393981933594, - 0.00012826919555664062, - 0.0001671314239501953, - 0.00014591217041015625, - 0.00013113021850585938, - 0.00012612342834472656, - 0.00013017654418945312, - 0.00012826919555664062, - 0.00019860267639160156, - 0.0003211498260498047, - 0.00012564659118652344, - 0.00013208389282226562, - 0.0004520416259765625, - 0.00011301040649414062, - 0.00023794174194335938, - 0.00017452239990234375, - 0.00012540817260742188, - 0.00020265579223632812, - 0.00013828277587890625, - 0.00011229515075683594, - 0.00013113021850585938, - 0.00013113021850585938, - 0.0001342296600341797, - 0.00013017654418945312, - 0.00013113021850585938, - 0.0001316070556640625, - 0.0001289844512939453, - 0.00012969970703125, - 0.00012969970703125, - 0.0001361370086669922, - 0.0001285076141357422, - 0.00019621849060058594, - 0.00016832351684570312, - 9.34600830078125e-05, - 0.00014019012451171875, - 0.00013017654418945312, - 0.00012874603271484375, - 0.00013065338134765625, - 0.00012803077697753906, - 0.00012969970703125, - 0.00012731552124023438, - 0.00012993812561035156, - 0.0001270771026611328, - 0.00012874603271484375, - 0.0001289844512939453, - 0.00013399124145507812, - 0.00013017654418945312, - 0.0001304149627685547, - 0.00017571449279785156, - 0.0001518726348876953, - 0.0001347064971923828, - 0.00015115737915039062, - 0.0001308917999267578, - 0.00012993812561035156, - 0.00013017654418945312, - 0.0001304149627685547, - 0.00012683868408203125, - 0.00012969970703125, - 0.0001285076141357422, - 0.0001270771026611328, - 0.0001270771026611328, - 0.0001289844512939453, - 0.0001697540283203125, - 0.00023627281188964844, - 4.076957702636719e-05, - 0.0002281665802001953, - 9.083747863769531e-05, - 0.00012969970703125, - 0.00010895729064941406, - 0.00012922286987304688, - 0.0001308917999267578, - 0.0001304149627685547, - 0.0001304149627685547, - 0.00012946128845214844, - 0.00013065338134765625, - 0.00012993812561035156, - 0.00013184547424316406, - 0.00013303756713867188, - 0.00013113021850585938, - 0.00013589859008789062, - 0.00012111663818359375, - 0.0001308917999267578, - 0.00013065338134765625, - 0.0001316070556640625, - 0.00012946128845214844, - 0.00012969970703125, - 0.00012946128845214844, - 0.00012922286987304688, - 0.0001304149627685547, - 0.00012993812561035156, - 0.00013017654418945312, - 0.00012969970703125, - 0.00012946128845214844, - 0.00012993812561035156, - 0.0001347064971923828, - 0.00013256072998046875, - 0.00012946128845214844, - 0.00012969970703125, - 0.00012969970703125, - 0.00012922286987304688, - 0.0001304149627685547, - 0.00012946128845214844, - 0.00012874603271484375, - 0.0001289844512939453, - 0.00012993812561035156, - 0.00012969970703125, - 0.00012946128845214844, - 0.000133514404296875, - 0.00013017654418945312, - 0.00013065338134765625, - 0.00012993812561035156, - 0.00012922286987304688, - 0.0001308917999267578, - 0.0001289844512939453, - 0.0001289844512939453, - 0.0001308917999267578, - 0.00012755393981933594, - 0.00012922286987304688, - 0.00013017654418945312, - 0.00012874603271484375, - 0.0001304149627685547, - 0.0001289844512939453, - 0.00013113021850585938, - 0.0002384185791015625, - 8.893013000488281e-05, - 0.00011301040649414062, - 0.00011682510375976562, - 0.00012826919555664062, - 0.0001385211944580078, - 0.00011610984802246094, - 0.0001285076141357422, - 0.00012946128845214844, - 0.00012755393981933594, - 0.0004611015319824219, - 0.0002624988555908203, - 0.0001513957977294922, - 0.0001919269561767578, - 0.000213623046875, - 0.00020885467529296875, - 0.0002079010009765625, - 0.00018906593322753906, - 0.00023889541625976562, - 0.0001506805419921875, - 0.0002067089080810547, - 9.393692016601562e-05, - 0.00012874603271484375, - 0.00012373924255371094, - 0.00013136863708496094, - 0.00013303756713867188, - 0.00013136863708496094, - 0.00013017654418945312, - 0.0001316070556640625, - 0.0001289844512939453, - 0.00017404556274414062, - 0.0001327991485595703, - 0.00014090538024902344, - 0.00012946128845214844, - 0.00015091896057128906, - 0.00015974044799804688, - 7.581710815429688e-05, - 0.00045013427734375, - 0.0002474784851074219, - 0.0001399517059326172, - 0.00013208389282226562, - 0.00013113021850585938, - 0.0001323223114013672, - 0.00013113021850585938, - 0.00012969970703125, - 0.0001308917999267578, - 0.0001308917999267578, - 0.0001289844512939453, - 0.00012969970703125, - 0.00012969970703125, - 0.00012946128845214844, - 0.00013875961303710938, - 0.00012946128845214844, - 0.00013065338134765625, - 0.00012922286987304688, - 0.00012683868408203125, - 0.0001285076141357422, - 0.00012993812561035156, - 0.00012993812561035156, - 0.0001308917999267578, - 0.00012826919555664062, - 0.00013017654418945312, - 0.00013065338134765625, - 0.0001304149627685547, - 0.0001277923583984375, - 0.0001304149627685547, - 0.0001347064971923828, - 0.0001316070556640625, - 0.00012946128845214844, - 0.0001285076141357422, - 0.00012993812561035156, - 0.00012922286987304688, - 0.0001285076141357422, - 0.0001304149627685547, - 0.0001304149627685547, - 0.00012874603271484375, - 0.00012969970703125, - 0.0001289844512939453, - 0.00012993812561035156, - 0.0001304149627685547, - 0.00012969970703125, - 0.00013566017150878906, - 0.00012826919555664062, - 0.0003554821014404297, - 0.00012445449829101562, - 0.00011181831359863281, - 0.00011086463928222656, - 0.00011777877807617188, - 0.00012040138244628906, - 0.0001308917999267578, - 0.00012874603271484375, - 0.0001304149627685547, - 0.0001289844512939453, - 0.0001277923583984375, - 0.00012803077697753906, - 0.00012731552124023438, - 0.00012946128845214844, - 0.0001289844512939453, - 0.00012803077697753906, - 0.00013184547424316406, - 0.00012969970703125, - 0.0001277923583984375, - 0.00012826919555664062, - 0.0001289844512939453, - 0.00012803077697753906, - 0.00047135353088378906, - 0.0004661083221435547, - 0.00016164779663085938, - 0.0001251697540283203, - 0.00032520294189453125, - 0.00015735626220703125, - 0.00011348724365234375, - 0.00011014938354492188, - 0.00010991096496582031, - 0.00010848045349121094, - 0.00010967254638671875, - 0.00010728836059570312, - 0.0012195110321044922, - 4.553794860839844e-05, - 3.4332275390625e-05, - 3.218650817871094e-05, - 3.0517578125e-05, - 3.337860107421875e-05, - 3.0994415283203125e-05, - 0.0005459785461425781, - 0.0004143714904785156, - 4.696846008300781e-05, - 7.724761962890625e-05, - 0.00016999244689941406, - 0.0006077289581298828, - 0.0001556873321533203, - 0.00011801719665527344, - 0.00011301040649414062, - 0.00010919570922851562, - 0.00010824203491210938, - 0.00011038780212402344, - 0.0001087188720703125, - 0.00010848045349121094, - 0.00010776519775390625, - 0.00011110305786132812, - 0.00023651123046875, - 0.00017333030700683594, - 0.00014448165893554688, - 0.0002624988555908203, - 0.00013327598571777344 - ], - "average": 0.0003386068344116211, - "minimum": 3.0517578125e-05, - "maximum": 0.1983966827392578 -} \ No newline at end of file diff --git a/lectures/timer_results_jax_gpu.json b/lectures/timer_results_jax_gpu.json deleted file mode 100644 index 7384a8045..000000000 --- a/lectures/timer_results_jax_gpu.json +++ /dev/null @@ -1,1007 +0,0 @@ -{ - "elapsed": [ - 0.00894927978515625, - 0.0077893733978271484, - 0.00783848762512207, - 0.007742881774902344, - 0.008021831512451172, - 0.008403778076171875, - 0.00877690315246582, - 0.009249448776245117, - 0.009325742721557617, - 0.007759571075439453, - 0.007692813873291016, - 0.007470369338989258, - 0.007610321044921875, - 0.0074825286865234375, - 0.007505655288696289, - 0.0074405670166015625, - 0.007567882537841797, - 0.00752568244934082, - 0.0075266361236572266, - 0.007463932037353516, - 0.007449626922607422, - 0.007368564605712891, - 0.00751948356628418, - 0.00741267204284668, - 0.00746464729309082, - 0.0075054168701171875, - 0.007444858551025391, - 0.007678985595703125, - 0.007574796676635742, - 0.0077114105224609375, - 0.007683753967285156, - 0.007571220397949219, - 0.007487297058105469, - 0.007385969161987305, - 0.0072841644287109375, - 0.007334232330322266, - 0.007352590560913086, - 0.0076525211334228516, - 0.0078277587890625, - 0.007426261901855469, - 0.00733184814453125, - 0.007588863372802734, - 0.007337093353271484, - 0.0075054168701171875, - 0.007489919662475586, - 0.007448434829711914, - 0.0073969364166259766, - 0.007444143295288086, - 0.007250070571899414, - 0.0072324275970458984, - 0.007323741912841797, - 0.007349252700805664, - 0.007457256317138672, - 0.007370948791503906, - 0.007367849349975586, - 0.0073642730712890625, - 0.007434844970703125, - 0.007540225982666016, - 0.007413148880004883, - 0.0073719024658203125, - 0.007552385330200195, - 0.007336854934692383, - 0.007337808609008789, - 0.00720977783203125, - 0.0071849822998046875, - 0.0072689056396484375, - 0.0072247982025146484, - 0.00731968879699707, - 0.007339000701904297, - 0.007465362548828125, - 0.0072269439697265625, - 0.007188320159912109, - 0.0072040557861328125, - 0.0072863101959228516, - 0.00837850570678711, - 0.007498025894165039, - 0.00730443000793457, - 0.007451534271240234, - 0.007972478866577148, - 0.007239341735839844, - 0.007331132888793945, - 0.007318973541259766, - 0.007255077362060547, - 0.007398128509521484, - 0.007372140884399414, - 0.007241010665893555, - 0.007323741912841797, - 0.007458686828613281, - 0.007277250289916992, - 0.0073163509368896484, - 0.007129192352294922, - 0.007196664810180664, - 0.0072786808013916016, - 0.00723576545715332, - 0.007236480712890625, - 0.007346391677856445, - 0.0072672367095947266, - 0.007182121276855469, - 0.007494211196899414, - 0.0073699951171875, - 0.00756072998046875, - 0.007221221923828125, - 0.00718998908996582, - 0.0072324275970458984, - 0.007302284240722656, - 0.00754857063293457, - 0.009068489074707031, - 0.00790715217590332, - 0.008527755737304688, - 0.008210182189941406, - 0.011906623840332031, - 0.008292913436889648, - 0.007605791091918945, - 0.009207487106323242, - 0.009471654891967773, - 0.01461935043334961, - 0.00813436508178711, - 0.008111238479614258, - 0.008356332778930664, - 0.00919795036315918, - 0.016668319702148438, - 0.008682012557983398, - 0.00827646255493164, - 0.007841110229492188, - 0.008556842803955078, - 0.008398294448852539, - 0.007370948791503906, - 0.00728297233581543, - 0.007416486740112305, - 0.007297039031982422, - 0.007281303405761719, - 0.0071566104888916016, - 0.007378578186035156, - 0.007262468338012695, - 0.007253885269165039, - 0.0070972442626953125, - 0.007194042205810547, - 0.0071675777435302734, - 0.007120847702026367, - 0.008023262023925781, - 0.0075702667236328125, - 0.007699489593505859, - 0.007712841033935547, - 0.0075261592864990234, - 0.007371664047241211, - 0.0071218013763427734, - 0.007317066192626953, - 0.0071985721588134766, - 0.007280111312866211, - 0.007114887237548828, - 0.00730586051940918, - 0.007183074951171875, - 0.007381439208984375, - 0.007197141647338867, - 0.00724339485168457, - 0.0071756839752197266, - 0.007266998291015625, - 0.007156848907470703, - 0.007177591323852539, - 0.007179975509643555, - 0.007282257080078125, - 0.0071506500244140625, - 0.007104396820068359, - 0.0071065425872802734, - 0.007241010665893555, - 0.007120847702026367, - 0.0071485042572021484, - 0.007211923599243164, - 0.00720524787902832, - 0.007305145263671875, - 0.007249116897583008, - 0.006999969482421875, - 0.007219076156616211, - 0.007281064987182617, - 0.0072383880615234375, - 0.007224559783935547, - 0.0070989131927490234, - 0.007096290588378906, - 0.007146358489990234, - 0.007042646408081055, - 0.0071811676025390625, - 0.007082223892211914, - 0.007155895233154297, - 0.007238149642944336, - 0.007129192352294922, - 0.007277488708496094, - 0.007277965545654297, - 0.007107257843017578, - 0.007270336151123047, - 0.007373332977294922, - 0.0073740482330322266, - 0.008176803588867188, - 0.007331371307373047, - 0.007120370864868164, - 0.007020473480224609, - 0.007232189178466797, - 0.007283687591552734, - 0.007192850112915039, - 0.0072231292724609375, - 0.007257223129272461, - 0.0071871280670166016, - 0.007084369659423828, - 0.007172346115112305, - 0.007170438766479492, - 0.007084369659423828, - 0.007151365280151367, - 0.007338047027587891, - 0.007124900817871094, - 0.007176399230957031, - 0.00713038444519043, - 0.007172584533691406, - 0.0071201324462890625, - 0.00712895393371582, - 0.007082223892211914, - 0.007166862487792969, - 0.007182598114013672, - 0.007147073745727539, - 0.007116556167602539, - 0.007161617279052734, - 0.007193088531494141, - 0.0070667266845703125, - 0.0070574283599853516, - 0.007298946380615234, - 0.007250070571899414, - 0.007103919982910156, - 0.00710606575012207, - 0.00718235969543457, - 0.007061958312988281, - 0.0072252750396728516, - 0.007208824157714844, - 0.007238149642944336, - 0.0073795318603515625, - 0.009131669998168945, - 0.00827479362487793, - 0.008715391159057617, - 0.008734703063964844, - 0.007229328155517578, - 0.007062435150146484, - 0.00708770751953125, - 0.007140636444091797, - 0.007266044616699219, - 0.007165193557739258, - 0.007125377655029297, - 0.007047414779663086, - 0.00720524787902832, - 0.006979227066040039, - 0.0071620941162109375, - 0.007021427154541016, - 0.0076291561126708984, - 0.007161378860473633, - 0.007355928421020508, - 0.007161140441894531, - 0.0072782039642333984, - 0.007496356964111328, - 0.00710606575012207, - 0.00709843635559082, - 0.007381439208984375, - 0.009734630584716797, - 0.012171030044555664, - 0.00762486457824707, - 0.007074594497680664, - 0.0070955753326416016, - 0.0072171688079833984, - 0.007250070571899414, - 0.007467985153198242, - 0.00722503662109375, - 0.0073277950286865234, - 0.0071620941162109375, - 0.007193803787231445, - 0.007155179977416992, - 0.0071675777435302734, - 0.007237672805786133, - 0.00711369514465332, - 0.007418155670166016, - 0.007233381271362305, - 0.007153034210205078, - 0.0071218013763427734, - 0.0070683956146240234, - 0.0071222782135009766, - 0.007197141647338867, - 0.0070476531982421875, - 0.01286935806274414, - 0.00999140739440918, - 0.007722616195678711, - 0.008667707443237305, - 0.007975578308105469, - 0.007681846618652344, - 0.007479429244995117, - 0.007181882858276367, - 0.015595674514770508, - 0.014226436614990234, - 0.009690999984741211, - 0.007378339767456055, - 0.0071947574615478516, - 0.007163524627685547, - 0.007230281829833984, - 0.007164716720581055, - 0.007239341735839844, - 0.007156848907470703, - 0.007259845733642578, - 0.007276058197021484, - 0.007372140884399414, - 0.007281780242919922, - 0.0072078704833984375, - 0.007158041000366211, - 0.007188081741333008, - 0.0071294307708740234, - 0.0072438716888427734, - 0.007301807403564453, - 0.007174968719482422, - 0.00709223747253418, - 0.0071222782135009766, - 0.007420778274536133, - 0.0071086883544921875, - 0.007596254348754883, - 0.0073740482330322266, - 0.007146596908569336, - 0.00709986686706543, - 0.007021188735961914, - 0.007097959518432617, - 0.007472515106201172, - 0.007132291793823242, - 0.007207155227661133, - 0.0071489810943603516, - 0.007122039794921875, - 0.007085084915161133, - 0.007021188735961914, - 0.007106781005859375, - 0.007116079330444336, - 0.0071735382080078125, - 0.007048130035400391, - 0.007073640823364258, - 0.00713801383972168, - 0.007075071334838867, - 0.007047176361083984, - 0.007024288177490234, - 0.007042884826660156, - 0.007042884826660156, - 0.007111310958862305, - 0.007592439651489258, - 0.007111787796020508, - 0.0070383548736572266, - 0.0071010589599609375, - 0.007037639617919922, - 0.007018566131591797, - 0.007133960723876953, - 0.007188081741333008, - 0.007060527801513672, - 0.007207393646240234, - 0.007055759429931641, - 0.007146120071411133, - 0.007066965103149414, - 0.007110595703125, - 0.006989002227783203, - 0.007099628448486328, - 0.007232666015625, - 0.007322788238525391, - 0.0072917938232421875, - 0.007248878479003906, - 0.00720524787902832, - 0.007298946380615234, - 0.0073261260986328125, - 0.007050514221191406, - 0.007036685943603516, - 0.00727534294128418, - 0.0071926116943359375, - 0.00737452507019043, - 0.007292270660400391, - 0.036690711975097656, - 0.03507518768310547, - 0.0381016731262207, - 0.03814864158630371, - 0.03513336181640625, - 0.030566692352294922, - 0.02220940589904785, - 0.02411055564880371, - 0.023044347763061523, - 0.02397012710571289, - 0.010378122329711914, - 0.008206844329833984, - 0.00722813606262207, - 0.00736689567565918, - 0.007264375686645508, - 0.0073015689849853516, - 0.007363557815551758, - 0.007221698760986328, - 0.007307291030883789, - 0.00713038444519043, - 0.007215023040771484, - 0.007846355438232422, - 0.008081436157226562, - 0.008908271789550781, - 0.008430242538452148, - 0.0072231292724609375, - 0.007277250289916992, - 0.007365226745605469, - 0.0072095394134521484, - 0.007120847702026367, - 0.007192134857177734, - 0.007294178009033203, - 0.00725102424621582, - 0.007162809371948242, - 0.007226467132568359, - 0.007110118865966797, - 0.007241725921630859, - 0.007134437561035156, - 0.0073430538177490234, - 0.007382392883300781, - 0.007411479949951172, - 0.007285118103027344, - 0.007201671600341797, - 0.00712132453918457, - 0.007196903228759766, - 0.007291316986083984, - 0.007220268249511719, - 0.007147073745727539, - 0.007172346115112305, - 0.0071027278900146484, - 0.007306814193725586, - 0.007319927215576172, - 0.00712275505065918, - 0.0071811676025390625, - 0.007083892822265625, - 0.007180452346801758, - 0.0071833133697509766, - 0.0072100162506103516, - 0.007221698760986328, - 0.007248401641845703, - 0.007070302963256836, - 0.00718998908996582, - 0.007283210754394531, - 0.0072934627532958984, - 0.007147073745727539, - 0.007178544998168945, - 0.0073394775390625, - 0.0074236392974853516, - 0.007506608963012695, - 0.007380008697509766, - 0.007401466369628906, - 0.007271766662597656, - 0.007142305374145508, - 0.007149457931518555, - 0.007284402847290039, - 0.007195234298706055, - 0.0072021484375, - 0.007145881652832031, - 0.007225751876831055, - 0.00707697868347168, - 0.007158994674682617, - 0.007176637649536133, - 0.015395879745483398, - 0.038988351821899414, - 0.03654766082763672, - 0.04114723205566406, - 0.013225555419921875, - 0.015584230422973633, - 0.01636052131652832, - 0.016962766647338867, - 0.022106409072875977, - 0.0225677490234375, - 0.011452913284301758, - 0.015201330184936523, - 0.01706695556640625, - 0.016536235809326172, - 0.013992547988891602, - 0.016102313995361328, - 0.017148494720458984, - 0.008769512176513672, - 0.007285356521606445, - 0.007350444793701172, - 0.0072290897369384766, - 0.007119894027709961, - 0.007043361663818359, - 0.00720977783203125, - 0.007189750671386719, - 0.0071926116943359375, - 0.007196903228759766, - 0.0070953369140625, - 0.007021427154541016, - 0.007518291473388672, - 0.007029056549072266, - 0.007181644439697266, - 0.0071680545806884766, - 0.007202863693237305, - 0.007090330123901367, - 0.007100105285644531, - 0.007136821746826172, - 0.007125377655029297, - 0.007145881652832031, - 0.00711822509765625, - 0.0070803165435791016, - 0.00703120231628418, - 0.007002353668212891, - 0.00706028938293457, - 0.0072405338287353516, - 0.007262229919433594, - 0.007168769836425781, - 0.007116556167602539, - 0.007226705551147461, - 0.007029056549072266, - 0.007934331893920898, - 0.007883310317993164, - 0.008924484252929688, - 0.0084075927734375, - 0.007273674011230469, - 0.007206439971923828, - 0.007546424865722656, - 0.007191658020019531, - 0.007179737091064453, - 0.00713348388671875, - 0.0071904659271240234, - 0.007225513458251953, - 0.0071010589599609375, - 0.0071561336517333984, - 0.007140398025512695, - 0.007100820541381836, - 0.0070955753326416016, - 0.0071489810943603516, - 0.007231950759887695, - 0.007233619689941406, - 0.00713348388671875, - 0.007120847702026367, - 0.007150173187255859, - 0.007075071334838867, - 0.0070421695709228516, - 0.007173776626586914, - 0.007164478302001953, - 0.00716710090637207, - 0.007169008255004883, - 0.007172584533691406, - 0.007130861282348633, - 0.007195949554443359, - 0.0072784423828125, - 0.007217884063720703, - 0.007241964340209961, - 0.0071659088134765625, - 0.0070149898529052734, - 0.007053375244140625, - 0.007044792175292969, - 0.007116794586181641, - 0.007135629653930664, - 0.0071811676025390625, - 0.007134675979614258, - 0.007124662399291992, - 0.0072479248046875, - 0.007128715515136719, - 0.0071604251861572266, - 0.007094621658325195, - 0.007096529006958008, - 0.00700688362121582, - 0.007084369659423828, - 0.007156848907470703, - 0.0077974796295166016, - 0.007052421569824219, - 0.007349729537963867, - 0.007244110107421875, - 0.0072422027587890625, - 0.007025957107543945, - 0.007237434387207031, - 0.0070688724517822266, - 0.0071790218353271484, - 0.007050514221191406, - 0.007236480712890625, - 0.0071506500244140625, - 0.0071258544921875, - 0.007107973098754883, - 0.007052421569824219, - 0.007144451141357422, - 0.007294893264770508, - 0.007196903228759766, - 0.007056713104248047, - 0.00723576545715332, - 0.007178544998168945, - 0.007122993469238281, - 0.007153511047363281, - 0.007272958755493164, - 0.007138252258300781, - 0.00717616081237793, - 0.007378339767456055, - 0.007242918014526367, - 0.007092475891113281, - 0.007117033004760742, - 0.007160663604736328, - 0.0070002079010009766, - 0.0070912837982177734, - 0.007106304168701172, - 0.007125139236450195, - 0.007132291793823242, - 0.007134914398193359, - 0.007076740264892578, - 0.007161140441894531, - 0.007189512252807617, - 0.007228374481201172, - 0.0071032047271728516, - 0.007415771484375, - 0.007195472717285156, - 0.00735020637512207, - 0.007052898406982422, - 0.007218360900878906, - 0.0070765018463134766, - 0.0070497989654541016, - 0.007172107696533203, - 0.007299184799194336, - 0.007365703582763672, - 0.0076482295989990234, - 0.007239341735839844, - 0.007136106491088867, - 0.007231235504150391, - 0.007045745849609375, - 0.007025718688964844, - 0.007126569747924805, - 0.0070421695709228516, - 0.0071430206298828125, - 0.007035732269287109, - 0.007105827331542969, - 0.007145404815673828, - 0.007191658020019531, - 0.0071828365325927734, - 0.007086753845214844, - 0.0072476863861083984, - 0.007150173187255859, - 0.007384538650512695, - 0.007229804992675781, - 0.007169246673583984, - 0.007285356521606445, - 0.007492780685424805, - 0.007581233978271484, - 0.007402896881103516, - 0.007477760314941406, - 0.007331371307373047, - 0.007441997528076172, - 0.0074253082275390625, - 0.007195472717285156, - 0.007241964340209961, - 0.007444620132446289, - 0.007351875305175781, - 0.007686614990234375, - 0.0072307586669921875, - 0.007142305374145508, - 0.0073451995849609375, - 0.0074689388275146484, - 0.00755620002746582, - 0.007530689239501953, - 0.008685827255249023, - 0.008925437927246094, - 0.008840560913085938, - 0.007294893264770508, - 0.007278919219970703, - 0.0072612762451171875, - 0.00737452507019043, - 0.007315158843994141, - 0.007302522659301758, - 0.0072879791259765625, - 0.0073888301849365234, - 0.00799703598022461, - 0.0077250003814697266, - 0.00764775276184082, - 0.007357120513916016, - 0.007331132888793945, - 0.007336616516113281, - 0.0075681209564208984, - 0.007628679275512695, - 0.007318735122680664, - 0.007242918014526367, - 0.007186174392700195, - 0.007077455520629883, - 0.007136344909667969, - 0.007271528244018555, - 0.007079362869262695, - 0.007128238677978516, - 0.007114887237548828, - 0.0072476863861083984, - 0.00727534294128418, - 0.007117748260498047, - 0.007132053375244141, - 0.007356405258178711, - 0.007401704788208008, - 0.007226705551147461, - 0.007290363311767578, - 0.007416963577270508, - 0.007323265075683594, - 0.007319927215576172, - 0.007511138916015625, - 0.007473945617675781, - 0.007165431976318359, - 0.0074024200439453125, - 0.007239103317260742, - 0.007195472717285156, - 0.007264852523803711, - 0.007269382476806641, - 0.007307767868041992, - 0.0074176788330078125, - 0.007481098175048828, - 0.007256984710693359, - 0.007292985916137695, - 0.007086753845214844, - 0.0071887969970703125, - 0.00728917121887207, - 0.007111310958862305, - 0.007231235504150391, - 0.007248640060424805, - 0.007193565368652344, - 0.007417201995849609, - 0.007409811019897461, - 0.007180929183959961, - 0.0072901248931884766, - 0.007146596908569336, - 0.007241487503051758, - 0.007174253463745117, - 0.0073850154876708984, - 0.007271528244018555, - 0.007237672805786133, - 0.0071904659271240234, - 0.007299661636352539, - 0.007189273834228516, - 0.007267951965332031, - 0.007172346115112305, - 0.007173061370849609, - 0.00710296630859375, - 0.007326602935791016, - 0.007146120071411133, - 0.00716710090637207, - 0.0071163177490234375, - 0.007300615310668945, - 0.007239818572998047, - 0.0071141719818115234, - 0.007052183151245117, - 0.007256984710693359, - 0.007191658020019531, - 0.007061958312988281, - 0.007135868072509766, - 0.007170677185058594, - 0.007138490676879883, - 0.007999181747436523, - 0.007155418395996094, - 0.00705409049987793, - 0.0071294307708740234, - 0.007147789001464844, - 0.0073528289794921875, - 0.007322549819946289, - 0.007256746292114258, - 0.007194042205810547, - 0.007086992263793945, - 0.007074832916259766, - 0.007119178771972656, - 0.0071985721588134766, - 0.007056236267089844, - 0.0071315765380859375, - 0.007068157196044922, - 0.007128238677978516, - 0.007146120071411133, - 0.007163524627685547, - 0.007356882095336914, - 0.007458925247192383, - 0.007225513458251953, - 0.007533550262451172, - 0.00732111930847168, - 0.0073854923248291016, - 0.007178544998168945, - 0.0074520111083984375, - 0.007168769836425781, - 0.007752895355224609, - 0.007218122482299805, - 0.0071794986724853516, - 0.0075206756591796875, - 0.007381439208984375, - 0.007287740707397461, - 0.007125377655029297, - 0.007395505905151367, - 0.007150888442993164, - 0.007214546203613281, - 0.007455348968505859, - 0.00728154182434082, - 0.0073909759521484375, - 0.007367372512817383, - 0.007147789001464844, - 0.0071599483489990234, - 0.0073130130767822266, - 0.0072705745697021484, - 0.007393360137939453, - 0.007477521896362305, - 0.007273674011230469, - 0.007323503494262695, - 0.007313251495361328, - 0.00823521614074707, - 0.008041620254516602, - 0.008969783782958984, - 0.00760197639465332, - 0.007387638092041016, - 0.007260322570800781, - 0.00745844841003418, - 0.007386207580566406, - 0.007304191589355469, - 0.007154941558837891, - 0.007363319396972656, - 0.007093191146850586, - 0.007223606109619141, - 0.0072994232177734375, - 0.007231235504150391, - 0.007204771041870117, - 0.007123470306396484, - 0.007284402847290039, - 0.007292032241821289, - 0.007462978363037109, - 0.007276296615600586, - 0.007123708724975586, - 0.00725865364074707, - 0.007309913635253906, - 0.0072078704833984375, - 0.007454872131347656, - 0.0072438716888427734, - 0.007119655609130859, - 0.007180452346801758, - 0.007284402847290039, - 0.0072154998779296875, - 0.0073070526123046875, - 0.00728297233581543, - 0.007113933563232422, - 0.007186174392700195, - 0.007155179977416992, - 0.007164478302001953, - 0.007027864456176758, - 0.007130146026611328, - 0.007166624069213867, - 0.007083415985107422, - 0.007088184356689453, - 0.0070836544036865234, - 0.007821321487426758, - 0.00718998908996582, - 0.00799560546875, - 0.007227182388305664, - 0.007270097732543945, - 0.007042646408081055, - 0.007171630859375, - 0.0070953369140625, - 0.007112741470336914, - 0.007110595703125, - 0.007214069366455078, - 0.0071866512298583984, - 0.00708770751953125, - 0.007089376449584961, - 0.007304668426513672, - 0.0072345733642578125, - 0.007218122482299805, - 0.00712132453918457, - 0.007215261459350586, - 0.0071773529052734375, - 0.007208347320556641, - 0.007088422775268555, - 0.007086038589477539, - 0.007353782653808594, - 0.007260799407958984, - 0.007149934768676758, - 0.007184028625488281, - 0.007379770278930664, - 0.007238864898681641, - 0.007335186004638672, - 0.007430553436279297, - 0.0072536468505859375, - 0.007124662399291992, - 0.007223606109619141, - 0.007154226303100586, - 0.0072019100189208984, - 0.007083415985107422, - 0.007090091705322266, - 0.007143974304199219, - 0.007209062576293945, - 0.007422685623168945, - 0.007337808609008789, - 0.007189035415649414, - 0.007152557373046875, - 0.008496761322021484, - 0.007238864898681641, - 0.007299184799194336, - 0.007205009460449219, - 0.007345676422119141, - 0.00833749771118164, - 0.007983207702636719, - 0.007524728775024414, - 0.007230997085571289, - 0.0071790218353271484, - 0.007154941558837891, - 0.007254362106323242, - 0.007234334945678711, - 0.0073931217193603516, - 0.007142305374145508, - 0.0070989131927490234, - 0.007216215133666992, - 0.007016420364379883, - 0.007245779037475586, - 0.007132530212402344, - 0.007158041000366211, - 0.0072934627532958984, - 0.0071599483489990234, - 0.007133960723876953, - 0.007160663604736328, - 0.007138729095458984, - 0.007099628448486328, - 0.007422208786010742, - 0.007198333740234375, - 0.007178783416748047, - 0.0071713924407958984, - 0.007174015045166016, - 0.00722813606262207, - 0.007526397705078125, - 0.007518291473388672, - 0.007188558578491211, - 0.007365703582763672, - 0.00729060173034668, - 0.0072078704833984375, - 0.00713658332824707, - 0.007208347320556641, - 0.0072174072265625, - 0.007230281829833984, - 0.007161617279052734, - 0.007280826568603516, - 0.007099628448486328, - 0.007163047790527344, - 0.007094860076904297, - 0.00709986686706543, - 0.0072367191314697266, - 0.007139682769775391, - 0.007180213928222656, - 0.007390737533569336, - 0.007216215133666992, - 0.007736921310424805, - 0.007616758346557617, - 0.00797414779663086, - 0.008023738861083984, - 0.007673501968383789, - 0.007364511489868164, - 0.007250308990478516, - 0.0072536468505859375, - 0.007231950759887695, - 0.0071032047271728516, - 0.00719904899597168, - 0.007136821746826172, - 0.0072133541107177734, - 0.007206916809082031, - 0.007127046585083008, - 0.007119178771972656, - 0.007170677185058594, - 0.0070972442626953125, - 0.0071332454681396484, - 0.007318258285522461, - 0.007112979888916016, - 0.007292747497558594, - 0.007104158401489258, - 0.007124900817871094, - 0.007070302963256836, - 0.007134914398193359, - 0.007099628448486328, - 0.007174253463745117, - 0.007185220718383789, - 0.007096052169799805, - 0.007190704345703125, - 0.00719451904296875, - 0.00709843635559082, - 0.0071849822998046875, - 0.007086753845214844, - 0.007205486297607422, - 0.007114887237548828, - 0.007155895233154297, - 0.007160186767578125, - 0.0071790218353271484, - 0.007619619369506836, - 0.007390260696411133, - 0.0071904659271240234, - 0.0072002410888671875, - 0.0071811676025390625, - 0.0070400238037109375, - 0.007214546203613281, - 0.007096290588378906, - 0.0071713924407958984, - 0.0070722103118896484, - 0.00741887092590332, - 0.00718998908996582, - 0.007219552993774414, - 0.0071277618408203125, - 0.007262229919433594, - 0.007213592529296875, - 0.00712895393371582, - 0.007136106491088867, - 0.007175922393798828, - 0.007081747055053711, - 0.0073206424713134766, - 0.007332324981689453, - 0.0071637630462646484, - 0.007120370864868164, - 0.007072925567626953, - 0.007289409637451172, - 0.007253170013427734, - 0.00730443000793457, - 0.0072100162506103516, - 0.007387399673461914, - 0.007208347320556641, - 0.007140398025512695, - 0.00722050666809082, - 0.0072858333587646484, - 0.007251739501953125 - ], - "average": 0.007824363708496094, - "minimum": 0.006979227066040039, - "maximum": 0.04114723205566406 -} \ No newline at end of file diff --git a/lectures/timer_results_numpy.json b/lectures/timer_results_numpy.json deleted file mode 100644 index 7d2369741..000000000 --- a/lectures/timer_results_numpy.json +++ /dev/null @@ -1,1007 +0,0 @@ -{ - "elapsed": [ - 0.03485107421875, - 0.003374338150024414, - 0.003468036651611328, - 0.002163410186767578, - 0.0011875629425048828, - 0.0011622905731201172, - 0.0011417865753173828, - 0.0011415481567382812, - 0.001125335693359375, - 0.002493619918823242, - 0.002718687057495117, - 0.0011758804321289062, - 0.0011055469512939453, - 0.0010995864868164062, - 0.0010933876037597656, - 0.0010962486267089844, - 0.0010788440704345703, - 0.001089334487915039, - 0.00107574462890625, - 0.0010952949523925781, - 0.0010874271392822266, - 0.0011005401611328125, - 0.0010809898376464844, - 0.0010881423950195312, - 0.0011265277862548828, - 0.0016629695892333984, - 0.001201629638671875, - 0.0017817020416259766, - 0.0011317729949951172, - 0.0011172294616699219, - 0.0010972023010253906, - 0.0010762214660644531, - 0.0010726451873779297, - 0.0010776519775390625, - 0.0010678768157958984, - 0.0010905265808105469, - 0.0011107921600341797, - 0.0010836124420166016, - 0.0012850761413574219, - 0.004054069519042969, - 0.00261688232421875, - 0.002283811569213867, - 0.0017521381378173828, - 0.001451730728149414, - 0.0011775493621826172, - 0.001119375228881836, - 0.0010952949523925781, - 0.0015110969543457031, - 0.0013339519500732422, - 0.0011794567108154297, - 0.0012125968933105469, - 0.006528377532958984, - 0.0027506351470947266, - 0.0012350082397460938, - 0.001255035400390625, - 0.0023221969604492188, - 0.0027480125427246094, - 0.002214670181274414, - 0.0012836456298828125, - 0.0011167526245117188, - 0.0011019706726074219, - 0.0011043548583984375, - 0.0010876655578613281, - 0.0011811256408691406, - 0.001074075698852539, - 0.0010907649993896484, - 0.001669168472290039, - 0.0013208389282226562, - 0.0010991096496582031, - 0.001107931137084961, - 0.0015621185302734375, - 0.0012485980987548828, - 0.0012073516845703125, - 0.0012302398681640625, - 0.0011057853698730469, - 0.0011129379272460938, - 0.0011508464813232422, - 0.001092672348022461, - 0.0010809898376464844, - 0.001085042953491211, - 0.0014019012451171875, - 0.0012331008911132812, - 0.0011157989501953125, - 0.0011129379272460938, - 0.0011093616485595703, - 0.0013425350189208984, - 0.001112222671508789, - 0.0011036396026611328, - 0.0010762214660644531, - 0.0010907649993896484, - 0.0011146068572998047, - 0.0010983943939208984, - 0.0010802745819091797, - 0.0010797977447509766, - 0.0012552738189697266, - 0.0018649101257324219, - 0.0011777877807617188, - 0.001600027084350586, - 0.001104593276977539, - 0.0010929107666015625, - 0.0010874271392822266, - 0.0010917186737060547, - 0.0010838508605957031, - 0.0010750293731689453, - 0.002599954605102539, - 0.002160310745239258, - 0.0033898353576660156, - 0.0012593269348144531, - 0.0011372566223144531, - 0.0011277198791503906, - 0.0010848045349121094, - 0.0011012554168701172, - 0.001073598861694336, - 0.0010945796966552734, - 0.0012166500091552734, - 0.001135110855102539, - 0.001386880874633789, - 0.0018775463104248047, - 0.002843141555786133, - 0.0029516220092773438, - 0.0054209232330322266, - 0.003277301788330078, - 0.0019173622131347656, - 0.006273746490478516, - 0.0031821727752685547, - 0.004769086837768555, - 0.0036094188690185547, - 0.005305767059326172, - 0.0020737648010253906, - 0.002979278564453125, - 0.0019860267639160156, - 0.0015826225280761719, - 0.0015387535095214844, - 0.00213623046875, - 0.0018558502197265625, - 0.0017545223236083984, - 0.0013089179992675781, - 0.001171112060546875, - 0.0010981559753417969, - 0.0011479854583740234, - 0.0011234283447265625, - 0.0011322498321533203, - 0.0011093616485595703, - 0.001089334487915039, - 0.0010955333709716797, - 0.0026907920837402344, - 0.0034983158111572266, - 0.0022728443145751953, - 0.0011992454528808594, - 0.001135110855102539, - 0.0011093616485595703, - 0.0010917186737060547, - 0.0011806488037109375, - 0.0011382102966308594, - 0.001186370849609375, - 0.0014882087707519531, - 0.0012843608856201172, - 0.0011796951293945312, - 0.0012350082397460938, - 0.0014605522155761719, - 0.0012030601501464844, - 0.0012226104736328125, - 0.0011637210845947266, - 0.0011091232299804688, - 0.00113677978515625, - 0.0011341571807861328, - 0.0011179447174072266, - 0.0011196136474609375, - 0.001123189926147461, - 0.0017898082733154297, - 0.0014731884002685547, - 0.0012710094451904297, - 0.001168966293334961, - 0.0011610984802246094, - 0.001905202865600586, - 0.0015821456909179688, - 0.0011708736419677734, - 0.0011119842529296875, - 0.0011129379272460938, - 0.0011630058288574219, - 0.0010981559753417969, - 0.0015418529510498047, - 0.001329660415649414, - 0.0011489391326904297, - 0.0011410713195800781, - 0.0015134811401367188, - 0.0011663436889648438, - 0.0015668869018554688, - 0.0012280941009521484, - 0.001154184341430664, - 0.0011296272277832031, - 0.0011692047119140625, - 0.0011096000671386719, - 0.001104593276977539, - 0.0010900497436523438, - 0.001363515853881836, - 0.0019228458404541016, - 0.0014526844024658203, - 0.0012683868408203125, - 0.0011360645294189453, - 0.0011208057403564453, - 0.0011715888977050781, - 0.0011522769927978516, - 0.0011277198791503906, - 0.0010824203491210938, - 0.0010952949523925781, - 0.00109100341796875, - 0.0014541149139404297, - 0.0022759437561035156, - 0.0013744831085205078, - 0.0012292861938476562, - 0.0011408329010009766, - 0.0011076927185058594, - 0.0011737346649169922, - 0.001088857650756836, - 0.0010905265808105469, - 0.0011258125305175781, - 0.0010938644409179688, - 0.0011327266693115234, - 0.001176595687866211, - 0.0015702247619628906, - 0.0012874603271484375, - 0.0012617111206054688, - 0.0016891956329345703, - 0.0011794567108154297, - 0.001123189926147461, - 0.001108407974243164, - 0.0012135505676269531, - 0.0012946128845214844, - 0.0014042854309082031, - 0.0011398792266845703, - 0.0011072158813476562, - 0.0010898113250732422, - 0.0011153221130371094, - 0.0016431808471679688, - 0.001604318618774414, - 0.001382589340209961, - 0.0011534690856933594, - 0.0011034011840820312, - 0.0011341571807861328, - 0.001325845718383789, - 0.0012369155883789062, - 0.0012214183807373047, - 0.0011260509490966797, - 0.0011248588562011719, - 0.0011436939239501953, - 0.0012674331665039062, - 0.0011260509490966797, - 0.0015482902526855469, - 0.0015690326690673828, - 0.001687765121459961, - 0.0015020370483398438, - 0.0011398792266845703, - 0.0011250972747802734, - 0.0011072158813476562, - 0.0012257099151611328, - 0.0012774467468261719, - 0.0011703968048095703, - 0.0011057853698730469, - 0.0010921955108642578, - 0.0011513233184814453, - 0.0027730464935302734, - 0.001512289047241211, - 0.002217531204223633, - 0.0011916160583496094, - 0.0016875267028808594, - 0.0011909008026123047, - 0.0011324882507324219, - 0.0012011528015136719, - 0.0011668205261230469, - 0.0011556148529052734, - 0.0011324882507324219, - 0.0025482177734375, - 0.002037525177001953, - 0.0014679431915283203, - 0.001256704330444336, - 0.0012514591217041016, - 0.0012922286987304688, - 0.002262115478515625, - 0.001550912857055664, - 0.0011663436889648438, - 0.0011281967163085938, - 0.0014116764068603516, - 0.0027217864990234375, - 0.0015273094177246094, - 0.0012850761413574219, - 0.001110076904296875, - 0.0010957717895507812, - 0.0010972023010253906, - 0.00109100341796875, - 0.0010769367218017578, - 0.0010771751403808594, - 0.0010738372802734375, - 0.0011832714080810547, - 0.0010986328125, - 0.0015099048614501953, - 0.0012195110321044922, - 0.0012102127075195312, - 0.001119852066040039, - 0.0011377334594726562, - 0.0010876655578613281, - 0.00122833251953125, - 0.0010809898376464844, - 0.0010924339294433594, - 0.0010707378387451172, - 0.0010867118835449219, - 0.0010733604431152344, - 0.0011065006256103516, - 0.0010769367218017578, - 0.0010814666748046875, - 0.002773761749267578, - 0.0012412071228027344, - 0.001115560531616211, - 0.0010924339294433594, - 0.0011150836944580078, - 0.0011487007141113281, - 0.001110076904296875, - 0.0011010169982910156, - 0.0010738372802734375, - 0.00121307373046875, - 0.001119852066040039, - 0.0011501312255859375, - 0.0010933876037597656, - 0.0015344619750976562, - 0.0013275146484375, - 0.0011837482452392578, - 0.0038280487060546875, - 0.0015041828155517578, - 0.0019593238830566406, - 0.0011684894561767578, - 0.0011365413665771484, - 0.0011358261108398438, - 0.001132965087890625, - 0.0011615753173828125, - 0.0030193328857421875, - 0.002869844436645508, - 0.0023860931396484375, - 0.0011920928955078125, - 0.001132965087890625, - 0.0011353492736816406, - 0.0011186599731445312, - 0.0011181831359863281, - 0.0010941028594970703, - 0.0011172294616699219, - 0.002175569534301758, - 0.0016019344329833984, - 0.0014064311981201172, - 0.0011987686157226562, - 0.00116729736328125, - 0.0011382102966308594, - 0.0011150836944580078, - 0.0011379718780517578, - 0.0011141300201416016, - 0.001131296157836914, - 0.0011098384857177734, - 0.001100778579711914, - 0.0010876655578613281, - 0.0016396045684814453, - 0.0013239383697509766, - 0.0011415481567382812, - 0.001104116439819336, - 0.0011191368103027344, - 0.0011243820190429688, - 0.0011181831359863281, - 0.0010786056518554688, - 0.0010874271392822266, - 0.0011096000671386719, - 0.0012176036834716797, - 0.0011348724365234375, - 0.0011060237884521484, - 0.0010986328125, - 0.001445770263671875, - 0.0014176368713378906, - 0.0013298988342285156, - 0.0025441646575927734, - 0.0016999244689941406, - 0.0015535354614257812, - 0.0019559860229492188, - 0.0033566951751708984, - 0.004685401916503906, - 0.0023102760314941406, - 0.001222372055053711, - 0.0011165142059326172, - 0.0011799335479736328, - 0.0011107921600341797, - 0.0011067390441894531, - 0.0010867118835449219, - 0.001089334487915039, - 0.0010726451873779297, - 0.0010895729064941406, - 0.0010864734649658203, - 0.0014777183532714844, - 0.0016598701477050781, - 0.001230478286743164, - 0.0011143684387207031, - 0.0011124610900878906, - 0.0011394023895263672, - 0.0011174678802490234, - 0.0010831356048583984, - 0.001092672348022461, - 0.0010731220245361328, - 0.0010876655578613281, - 0.0010766983032226562, - 0.0010826587677001953, - 0.0010728836059570312, - 0.0013573169708251953, - 0.0014412403106689453, - 0.0011451244354248047, - 0.0011248588562011719, - 0.0011115074157714844, - 0.001096963882446289, - 0.0011200904846191406, - 0.0022706985473632812, - 0.0027997493743896484, - 0.0023980140686035156, - 0.0014758110046386719, - 0.0018415451049804688, - 0.001226663589477539, - 0.0011239051818847656, - 0.0011324882507324219, - 0.0011413097381591797, - 0.0011208057403564453, - 0.0013346672058105469, - 0.0011341571807861328, - 0.001123189926147461, - 0.0011239051818847656, - 0.0011031627655029297, - 0.0011105537414550781, - 0.0010814666748046875, - 0.0010945796966552734, - 0.0014829635620117188, - 0.0011434555053710938, - 0.0011355876922607422, - 0.0011217594146728516, - 0.00121307373046875, - 0.002201080322265625, - 0.0012233257293701172, - 0.0011258125305175781, - 0.0011186599731445312, - 0.0011496543884277344, - 0.0010967254638671875, - 0.0010919570922851562, - 0.0010874271392822266, - 0.0021915435791015625, - 0.0012462139129638672, - 0.0011827945709228516, - 0.0011017322540283203, - 0.0011546611785888672, - 0.001085519790649414, - 0.0010933876037597656, - 0.0010867118835449219, - 0.0010976791381835938, - 0.001066446304321289, - 0.001096963882446289, - 0.0010833740234375, - 0.0010762214660644531, - 0.0014264583587646484, - 0.002371072769165039, - 0.001920938491821289, - 0.0011796951293945312, - 0.0010952949523925781, - 0.0011339187622070312, - 0.0011200904846191406, - 0.0011241436004638672, - 0.0011141300201416016, - 0.0011074542999267578, - 0.001087188720703125, - 0.0010924339294433594, - 0.0012171268463134766, - 0.0011017322540283203, - 0.0023763179779052734, - 0.0028586387634277344, - 0.0016222000122070312, - 0.0011513233184814453, - 0.001096963882446289, - 0.0011010169982910156, - 0.0010843276977539062, - 0.001102447509765625, - 0.0010983943939208984, - 0.0012791156768798828, - 0.001100301742553711, - 0.0014934539794921875, - 0.0012981891632080078, - 0.0011355876922607422, - 0.0010914802551269531, - 0.001119375228881836, - 0.0011246204376220703, - 0.001178741455078125, - 0.00110626220703125, - 0.0011425018310546875, - 0.0011031627655029297, - 0.0011286735534667969, - 0.001140594482421875, - 0.00116729736328125, - 0.0011746883392333984, - 0.0019061565399169922, - 0.0020551681518554688, - 0.0011572837829589844, - 0.0012259483337402344, - 0.0011684894561767578, - 0.0014827251434326172, - 0.0012373924255371094, - 0.001163482666015625, - 0.0012021064758300781, - 0.0011737346649169922, - 0.0012547969818115234, - 0.0014731884002685547, - 0.0012049674987792969, - 0.0024213790893554688, - 0.004858970642089844, - 0.0024149417877197266, - 0.0022039413452148438, - 0.0036211013793945312, - 0.004363059997558594, - 0.003587961196899414, - 0.002411365509033203, - 0.002049684524536133, - 0.0013275146484375, - 0.0019190311431884766, - 0.0017485618591308594, - 0.0022776126861572266, - 0.0017979145050048828, - 0.001201629638671875, - 0.001146078109741211, - 0.0011701583862304688, - 0.0014028549194335938, - 0.0017714500427246094, - 0.0017528533935546875, - 0.0016891956329345703, - 0.0018167495727539062, - 0.0020859241485595703, - 0.001967191696166992, - 0.0030815601348876953, - 0.002385377883911133, - 0.0017194747924804688, - 0.0023539066314697266, - 0.001661539077758789, - 0.0014624595642089844, - 0.003152608871459961, - 0.0017206668853759766, - 0.0012080669403076172, - 0.001134634017944336, - 0.001123189926147461, - 0.0011556148529052734, - 0.0011820793151855469, - 0.0012240409851074219, - 0.001220703125, - 0.0012235641479492188, - 0.0011703968048095703, - 0.0023729801177978516, - 0.001981973648071289, - 0.0016298294067382812, - 0.0024132728576660156, - 0.0012955665588378906, - 0.0011703968048095703, - 0.0011630058288574219, - 0.0011799335479736328, - 0.0011568069458007812, - 0.001163482666015625, - 0.001153707504272461, - 0.0011451244354248047, - 0.0034151077270507812, - 0.001607656478881836, - 0.0012624263763427734, - 0.0011239051818847656, - 0.0011413097381591797, - 0.00112152099609375, - 0.0011644363403320312, - 0.0012590885162353516, - 0.0011873245239257812, - 0.001116037368774414, - 0.0011115074157714844, - 0.0010886192321777344, - 0.001123189926147461, - 0.0010917186737060547, - 0.0010886192321777344, - 0.0012183189392089844, - 0.0013568401336669922, - 0.0011577606201171875, - 0.0011565685272216797, - 0.0011415481567382812, - 0.0011374950408935547, - 0.0011234283447265625, - 0.0011258125305175781, - 0.0011184215545654297, - 0.0011615753173828125, - 0.0011515617370605469, - 0.001211404800415039, - 0.0011317729949951172, - 0.0013098716735839844, - 0.0012331008911132812, - 0.001108407974243164, - 0.0010797977447509766, - 0.0010874271392822266, - 0.0010776519775390625, - 0.0010852813720703125, - 0.0011038780212402344, - 0.001138925552368164, - 0.0011053085327148438, - 0.001188516616821289, - 0.0011017322540283203, - 0.0010905265808105469, - 0.0014882087707519531, - 0.0013189315795898438, - 0.0010936260223388672, - 0.0010821819305419922, - 0.0010852813720703125, - 0.0010905265808105469, - 0.0010693073272705078, - 0.0010898113250732422, - 0.0010933876037597656, - 0.0011479854583740234, - 0.0011031627655029297, - 0.0010898113250732422, - 0.0010821819305419922, - 0.0010862350463867188, - 0.0010762214660644531, - 0.001790761947631836, - 0.001232147216796875, - 0.001132965087890625, - 0.0011069774627685547, - 0.0010991096496582031, - 0.0010824203491210938, - 0.0010981559753417969, - 0.001102447509765625, - 0.0011153221130371094, - 0.001140594482421875, - 0.0011260509490966797, - 0.0019578933715820312, - 0.0027954578399658203, - 0.001470804214477539, - 0.0012218952178955078, - 0.0010895729064941406, - 0.0011005401611328125, - 0.0010869503021240234, - 0.0010914802551269531, - 0.0010793209075927734, - 0.0011091232299804688, - 0.0011417865753173828, - 0.0011205673217773438, - 0.0010819435119628906, - 0.001088857650756836, - 0.0010752677917480469, - 0.0012841224670410156, - 0.0014388561248779297, - 0.0012018680572509766, - 0.0011069774627685547, - 0.003856658935546875, - 0.0021882057189941406, - 0.0011744499206542969, - 0.0010976791381835938, - 0.001094818115234375, - 0.0011086463928222656, - 0.0011410713195800781, - 0.0019423961639404297, - 0.001657247543334961, - 0.002398967742919922, - 0.0012192726135253906, - 0.0011203289031982422, - 0.0011861324310302734, - 0.0011086463928222656, - 0.0011096000671386719, - 0.001077890396118164, - 0.0010919570922851562, - 0.0010857582092285156, - 0.0010955333709716797, - 0.0010747909545898438, - 0.0027523040771484375, - 0.0011532306671142578, - 0.001094818115234375, - 0.0011165142059326172, - 0.0010974407196044922, - 0.001079559326171875, - 0.001085042953491211, - 0.0011725425720214844, - 0.0011310577392578125, - 0.0011293888092041016, - 0.0011026859283447266, - 0.0010766983032226562, - 0.0010890960693359375, - 0.0035543441772460938, - 0.0013790130615234375, - 0.0016644001007080078, - 0.0011091232299804688, - 0.001108407974243164, - 0.0010912418365478516, - 0.0010821819305419922, - 0.0010869503021240234, - 0.0010826587677001953, - 0.0010919570922851562, - 0.0021390914916992188, - 0.0033197402954101562, - 0.0011858940124511719, - 0.0011250972747802734, - 0.0011267662048339844, - 0.0011396408081054688, - 0.0011224746704101562, - 0.0011403560638427734, - 0.0010862350463867188, - 0.001096963882446289, - 0.0010781288146972656, - 0.0010912418365478516, - 0.0014522075653076172, - 0.001195669174194336, - 0.0014090538024902344, - 0.001529693603515625, - 0.0013744831085205078, - 0.0011458396911621094, - 0.0011241436004638672, - 0.001123189926147461, - 0.00112152099609375, - 0.0011439323425292969, - 0.0011060237884521484, - 0.0011212825775146484, - 0.0011005401611328125, - 0.0011115074157714844, - 0.0040857791900634766, - 0.0012354850769042969, - 0.001119375228881836, - 0.0011320114135742188, - 0.0012278556823730469, - 0.0012373924255371094, - 0.0011644363403320312, - 0.0011529922485351562, - 0.0011568069458007812, - 0.0011515617370605469, - 0.0011169910430908203, - 0.0011246204376220703, - 0.0010955333709716797, - 0.0011086463928222656, - 0.0018832683563232422, - 0.0016787052154541016, - 0.0013883113861083984, - 0.0012362003326416016, - 0.0011603832244873047, - 0.0013892650604248047, - 0.0012004375457763672, - 0.0011038780212402344, - 0.0010836124420166016, - 0.001125335693359375, - 0.0010886192321777344, - 0.0010972023010253906, - 0.0010783672332763672, - 0.0016660690307617188, - 0.00131988525390625, - 0.001112222671508789, - 0.001085042953491211, - 0.0011096000671386719, - 0.0011341571807861328, - 0.0011055469512939453, - 0.001085519790649414, - 0.001077890396118164, - 0.0010807514190673828, - 0.001094818115234375, - 0.0010704994201660156, - 0.0010852813720703125, - 0.0010678768157958984, - 0.0013527870178222656, - 0.001730203628540039, - 0.0016455650329589844, - 0.0013585090637207031, - 0.0011055469512939453, - 0.0010876655578613281, - 0.0011174678802490234, - 0.0010933876037597656, - 0.0010957717895507812, - 0.0010764598846435547, - 0.0010955333709716797, - 0.0010790824890136719, - 0.00107574462890625, - 0.0019028186798095703, - 0.0017538070678710938, - 0.0011589527130126953, - 0.0011060237884521484, - 0.001081705093383789, - 0.0011208057403564453, - 0.0011377334594726562, - 0.0011043548583984375, - 0.001077890396118164, - 0.0010852813720703125, - 0.0010831356048583984, - 0.001094818115234375, - 0.0010764598846435547, - 0.0010867118835449219, - 0.0010716915130615234, - 0.002593517303466797, - 0.00122833251953125, - 0.001115560531616211, - 0.0011012554168701172, - 0.0011248588562011719, - 0.0011532306671142578, - 0.0011031627655029297, - 0.0010786056518554688, - 0.0010838508605957031, - 0.0010685920715332031, - 0.0010879039764404297, - 0.001108407974243164, - 0.001115560531616211, - 0.0013682842254638672, - 0.0015168190002441406, - 0.0011801719665527344, - 0.0011138916015625, - 0.0010867118835449219, - 0.0011060237884521484, - 0.0011332035064697266, - 0.001107931137084961, - 0.0010790824890136719, - 0.0010957717895507812, - 0.0010917186737060547, - 0.0010783672332763672, - 0.0010704994201660156, - 0.001949310302734375, - 0.0013890266418457031, - 0.001310586929321289, - 0.0012617111206054688, - 0.001132965087890625, - 0.0012164115905761719, - 0.0017762184143066406, - 0.0013129711151123047, - 0.0011348724365234375, - 0.0011069774627685547, - 0.001092672348022461, - 0.0011339187622070312, - 0.0010991096496582031, - 0.0010995864868164062, - 0.0011415481567382812, - 0.002924680709838867, - 0.0021066665649414062, - 0.0015676021575927734, - 0.00159454345703125, - 0.0014965534210205078, - 0.0011682510375976562, - 0.0011210441589355469, - 0.0011336803436279297, - 0.0010960102081298828, - 0.001100778579711914, - 0.0010845661163330078, - 0.0020055770874023438, - 0.0015158653259277344, - 0.0011544227600097656, - 0.0024945735931396484, - 0.003144979476928711, - 0.001310586929321289, - 0.001184701919555664, - 0.0010895729064941406, - 0.0011138916015625, - 0.0011162757873535156, - 0.0014793872833251953, - 0.0014357566833496094, - 0.001149892807006836, - 0.0010933876037597656, - 0.0011243820190429688, - 0.0011112689971923828, - 0.0010955333709716797, - 0.0014998912811279297, - 0.0011355876922607422, - 0.0011107921600341797, - 0.0011131763458251953, - 0.0011012554168701172, - 0.0011019706726074219, - 0.0010945796966552734, - 0.0013306140899658203, - 0.0017383098602294922, - 0.0018002986907958984, - 0.0028214454650878906, - 0.0017268657684326172, - 0.0012307167053222656, - 0.0014598369598388672, - 0.0011506080627441406, - 0.0011229515075683594, - 0.0011181831359863281, - 0.0012140274047851562, - 0.0013952255249023438, - 0.0011365413665771484, - 0.0010950565338134766, - 0.0020973682403564453, - 0.0012352466583251953, - 0.0014336109161376953, - 0.0011496543884277344, - 0.0011169910430908203, - 0.0010921955108642578, - 0.001149892807006836, - 0.0011005401611328125, - 0.0011119842529296875, - 0.002541780471801758, - 0.0016026496887207031, - 0.0013556480407714844, - 0.002689361572265625, - 0.0012042522430419922, - 0.0011243820190429688, - 0.0011258125305175781, - 0.0011067390441894531, - 0.0010845661163330078, - 0.0010800361633300781, - 0.0010733604431152344, - 0.001100778579711914, - 0.0010707378387451172, - 0.0016901493072509766, - 0.0011928081512451172, - 0.0011324882507324219, - 0.0010814666748046875, - 0.0011241436004638672, - 0.0016248226165771484, - 0.0011327266693115234, - 0.0010807514190673828, - 0.0010836124420166016, - 0.0010738372802734375, - 0.0010852813720703125, - 0.0010738372802734375, - 0.0010900497436523438, - 0.0010676383972167969, - 0.0013360977172851562, - 0.0017473697662353516, - 0.00122833251953125, - 0.0012621879577636719, - 0.0013184547424316406, - 0.001138448715209961, - 0.0011076927185058594, - 0.0011589527130126953, - 0.0011196136474609375, - 0.0010902881622314453, - 0.0011048316955566406, - 0.0012805461883544922, - 0.0011317729949951172, - 0.0012664794921875, - 0.001590728759765625, - 0.0011720657348632812, - 0.0011081695556640625, - 0.001085519790649414, - 0.0011746883392333984, - 0.0011112689971923828, - 0.0011048316955566406, - 0.0010786056518554688, - 0.0011000633239746094, - 0.0010781288146972656, - 0.0010941028594970703, - 0.0011887550354003906, - 0.0012640953063964844, - 0.0010967254638671875, - 0.0013740062713623047, - 0.0020647048950195312, - 0.0011806488037109375, - 0.0010972023010253906, - 0.0010998249053955078, - 0.0011289119720458984, - 0.001129150390625, - 0.0010898113250732422, - 0.0010919570922851562, - 0.00107574462890625, - 0.0010886192321777344, - 0.0015151500701904297, - 0.00113677978515625, - 0.0018165111541748047, - 0.0013432502746582031, - 0.0012199878692626953, - 0.0011124610900878906, - 0.0010824203491210938, - 0.0011188983917236328, - 0.0011191368103027344, - 0.0010995864868164062, - 0.0010786056518554688, - 0.0011088848114013672, - 0.0010802745819091797, - 0.001094818115234375, - 0.0010766983032226562, - 0.0010895729064941406, - 0.00107574462890625, - 0.001348257064819336, - 0.0012331008911132812, - 0.0014750957489013672, - 0.0011990070343017578, - 0.0011432170867919922, - 0.0011153221130371094, - 0.0012383460998535156, - 0.0011358261108398438, - 0.0011153221130371094, - 0.0011022090911865234, - 0.0010960102081298828, - 0.0010879039764404297, - 0.0010843276977539062, - 0.0010843276977539062, - 0.0014505386352539062, - 0.0011796951293945312, - 0.0013971328735351562, - 0.0011620521545410156, - 0.0015239715576171875, - 0.0011515617370605469, - 0.0010988712310791016, - 0.0011348724365234375, - 0.0011205673217773438, - 0.0011227130889892578, - 0.0010986328125, - 0.0010759830474853516, - 0.0010898113250732422, - 0.001077890396118164, - 0.001547098159790039, - 0.0011615753173828125, - 0.0011112689971923828, - 0.0010876655578613281, - 0.0011951923370361328 - ], - "average": 0.0014057674407958985, - "minimum": 0.001066446304321289, - "maximum": 0.03485107421875 -} \ No newline at end of file