diff --git a/README.md b/README.md index 183e14e..2cc6623 100644 --- a/README.md +++ b/README.md @@ -18,3 +18,4 @@ add https://github.com/QuantEcon/ContinuousDPs.jl * [Stochastic optimal growth model](http://nbviewer.jupyter.org/github/QuantEcon/ContinuousDPs.jl/blob/main/examples/cdp_ex_optgrowth_jl.ipynb) * [Examples from Miranda and Fackler 2002, Chapter 9](http://nbviewer.jupyter.org/github/QuantEcon/ContinuousDPs.jl/blob/main/examples/cdp_ex_MF_jl.ipynb) +* [Santos (1999) Section 7.3 multidimensional-state stochastic growth model (with analytical benchmark)](http://nbviewer.jupyter.org/github/QuantEcon/ContinuousDPs.jl/blob/main/examples/cdp_ex_santos1999_s73_jl.ipynb) diff --git a/examples/cdp_ex_santos1999_s73_jl.ipynb b/examples/cdp_ex_santos1999_s73_jl.ipynb new file mode 100644 index 0000000..11f0be5 --- /dev/null +++ b/examples/cdp_ex_santos1999_s73_jl.ipynb @@ -0,0 +1,7414 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ccfad8f4", + "metadata": {}, + "source": [ + "## 0. Settings" + ] + }, + { + "cell_type": "markdown", + "id": "1ec6aef4", + "metadata": {}, + "source": [ + "### How to run\n", + "From the repository root:\n", + "\n", + "```bash\n", + "julia --project -e 'using Pkg; Pkg.instantiate()'\n", + "julia --project -e 'using IJulia; notebook(dir=pwd())'" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "05ba8b70", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "SYSTEM: caught exception of type :MethodError while trying to print a failed Task notice; giving up\n", + "\n", + "SYSTEM: caught exception of type :MethodError while trying to print a failed Task notice; giving up\n", + "\n", + "SYSTEM: caught exception of type :MethodError while trying to print a failed Task notice; giving up\n" + ] + } + ], + "source": [ + "# Import libraries\n", + "using QuantEcon\n", + "using BasisMatrices\n", + "using ContinuousDPs\n", + "using Random\n", + "using PythonPlot\n", + "const plt = PythonPlot.pyplot;" + ] + }, + { + "cell_type": "markdown", + "id": "1ee148c4", + "metadata": {}, + "source": [ + "## 1. Model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e9d610ca", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Params(0.95, 0.3333333333333333, 10.0, 0.34, 1.0, 0.9, 0.008)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Parameter Settings \n", + "struct Params\n", + " beta::Float64\n", + " lambda::Float64\n", + " A::Float64\n", + " alpha::Float64\n", + " delta::Float64\n", + " rho::Float64\n", + " sigma_epsilon::Float64\n", + "end\n", + "\n", + "# Model parameters (as in Santos, 1999, Sec. 7.3)\n", + "p = Params(0.95, 1/3, 10.0, 0.34, 1.0, 0.90, 0.008)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2b31c768", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "g (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Technology and production\n", + "y(k, z, l) = z * p.A * k^p.alpha * (1 - l)^(1 - p.alpha)\n", + "\n", + "# Calculate consumption and k prime based on Santos equation (7.4) (\"unidimensional maximization\")\n", + "function c_from_l(k, z, l)\n", + " return z * p.A * k^p.alpha * (1 - l)^(-p.alpha) * (p.lambda / (1 - p.lambda)) * (1 - p.alpha) * l\n", + "end\n", + "\n", + "function kprime_from_l(k, z, l)\n", + " return y(k, z, l) + (1 - p.delta) * k - c_from_l(k, z, l)\n", + "end\n", + "\n", + "# Reward and transition functions\n", + "function f(s, l) \n", + " k, logz = s\n", + " z = exp(logz)\n", + " if !(0 < l < 1)\n", + " return -Inf\n", + " end\n", + " c = c_from_l(k, z, l)\n", + " kp = kprime_from_l(k, z, l)\n", + " if c <= 0 || kp < 0\n", + " return -Inf\n", + " end\n", + " return p.lambda*log(c) + (1 - p.lambda)*log(l)\n", + "end\n", + "\n", + "function g(s, l, e)\n", + " k, logz = s\n", + " z = exp(logz)\n", + " kp = kprime_from_l(k, z, l)\n", + " logzp = p.rho*logz + e\n", + " return (kp, logzp)\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "414ea639", + "metadata": {}, + "source": [ + "## 2. Numerical Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b79b4a1c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([-0.03000351774180594, -0.01893407528587633, -0.009235243157919746, 0.0, 0.009235243157919746, 0.01893407528587633, 0.03000351774180594], [0.0005482688559722181, 0.030757123967586456, 0.24012317860501223, 0.4571428571428571, 0.24012317860501223, 0.030757123967586456, 0.0005482688559722181])" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# State domains (as in Santos, 1999, Sec. 7.3)\n", + "logz_min, logz_max = -0.32, 0.32\n", + "k_min, k_max = 0.10, 10.0\n", + "\n", + "# For numerical stability\n", + "x_lb(s), x_ub(s) = 1e-10, 1 - 1e-10\n", + "\n", + "# Shock discretization (Gauss-Hermite quadrature)\n", + "n_shocks = 7\n", + "shocks, weights = qnwnorm(n_shocks, 0.0, p.sigma_epsilon^2)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ef5b8365", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2 dimensional Basis on the hypercube formed by (0.1, -0.32) × (10.0, 0.32).\n", + "Basis families are Cheb × Cheb\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# interpolation (Chebyshev polynomial)\n", + "nk, nlogz = 5, 5\n", + "basis = Basis(\n", + " ChebParams(nk, k_min, k_max),\n", + " ChebParams(nlogz, logz_min, logz_max)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "54a54c43", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ContinuousDP{2, Vector{Float64}, Matrix{Float64}, typeof(f), typeof(g), typeof(x_lb), typeof(x_ub)}(Main.f, Main.g, 0.95, [-0.03000351774180594, -0.01893407528587633, -0.009235243157919746, 0.0, 0.009235243157919746, 0.01893407528587633, 0.03000351774180594], [0.0005482688559722181, 0.030757123967586456, 0.24012317860501223, 0.4571428571428571, 0.24012317860501223, 0.030757123967586456, 0.0005482688559722181], Main.x_lb, Main.x_ub, ContinuousDPs.Interp{2, Matrix{Float64}, Matrix{Float64}, LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}}(2 dimensional Basis on the hypercube formed by (0.1, -0.32) × (10.0, 0.32).\n", + "Basis families are Cheb × Cheb\n", + ", [0.34227024433899 -0.30433808521444916; 2.140463001152258 -0.30433808521444916; … ; 7.959536998847741 0.30433808521444916; 9.75772975566101 0.30433808521444916], ([0.34227024433899, 2.140463001152258, 5.05, 7.959536998847741, 9.75772975566101], [-0.30433808521444916, -0.1880912807335914, -1.959434878635765e-17, 0.18809128073359138, 0.30433808521444916]), 25, (5, 5), (0.1, -0.32), (10.0, 0.32), [1.0 -0.9510565162951535 … -0.18163563200134053 0.09549150281252637; 1.0 -0.5877852522924731 … 0.29389262614623723 -0.25000000000000056; … ; 1.0 0.587785252292473 … -0.29389262614623723 -0.25000000000000044; 1.0 0.9510565162951536 … 0.18163563200134078 0.09549150281252672], LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}([1.0 -0.9510565162951535 … -0.18163563200134053 0.09549150281252637; 1.0 1.9021130325903073 … 0.3632712640026813 3.469446951953614e-16; … ; 1.0 0.8090169943749473 … 4.0614962029113295 4.774575140626315; 1.0 0.19098300562505255 … -0.9999999999999998 9.549150281252626], [1, 5, 3, 4, 5, 21, 25, 23, 24, 22 … 16, 20, 18, 19, 20, 21, 22, 23, 24, 25], 0)))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ContinuousDP Construction\n", + "cdp = ContinuousDP(f, g, p.beta, shocks, weights, x_lb, x_ub, basis)" + ] + }, + { + "cell_type": "markdown", + "id": "91aa5b41", + "metadata": {}, + "source": [ + "## 3. Solution" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5e80dd42", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute iterate 50 with error 0.016279805077919374\n", + "Compute iterate 100 with error 0.0012526509178254486\n", + "Compute iterate 150 with error 9.638519390708922e-5\n", + "Compute iterate 200 with error 7.416356361922283e-6\n", + "Compute iterate 250 with error 5.706513563907833e-7\n", + "Compute iterate 300 with error 4.390875396609317e-8\n", + "Compute iterate 322 with error 1.4205955523038938e-8\n", + "Converged in 322 steps\n" + ] + }, + { + "data": { + "text/plain": [ + "ContinuousDPs.CDPSolveResult{VFI, 2, Vector{Float64}, Matrix{Float64}}(ContinuousDP{2, Vector{Float64}, Matrix{Float64}, typeof(f), typeof(g), typeof(x_lb), typeof(x_ub)}(Main.f, Main.g, 0.95, [-0.03000351774180594, -0.01893407528587633, -0.009235243157919746, 0.0, 0.009235243157919746, 0.01893407528587633, 0.03000351774180594], [0.0005482688559722181, 0.030757123967586456, 0.24012317860501223, 0.4571428571428571, 0.24012317860501223, 0.030757123967586456, 0.0005482688559722181], Main.x_lb, Main.x_ub, ContinuousDPs.Interp{2, Matrix{Float64}, Matrix{Float64}, LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}}(2 dimensional Basis on the hypercube formed by (0.1, -0.32) × (10.0, 0.32).\n", + "Basis families are Cheb × Cheb\n", + ", [0.34227024433899 -0.30433808521444916; 2.140463001152258 -0.30433808521444916; … ; 7.959536998847741 0.30433808521444916; 9.75772975566101 0.30433808521444916], ([0.34227024433899, 2.140463001152258, 5.05, 7.959536998847741, 9.75772975566101], [-0.30433808521444916, -0.1880912807335914, -1.959434878635765e-17, 0.18809128073359138, 0.30433808521444916]), 25, (5, 5), (0.1, -0.32), (10.0, 0.32), [1.0 -0.9510565162951535 … -0.18163563200134053 0.09549150281252637; 1.0 -0.5877852522924731 … 0.29389262614623723 -0.25000000000000056; … ; 1.0 0.587785252292473 … -0.29389262614623723 -0.25000000000000044; 1.0 0.9510565162951536 … 0.18163563200134078 0.09549150281252672], LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}([1.0 -0.9510565162951535 … -0.18163563200134053 0.09549150281252637; 1.0 1.9021130325903073 … 0.3632712640026813 3.469446951953614e-16; … ; 1.0 0.8090169943749473 … 4.0614962029113295 4.774575140626315; 1.0 0.19098300562505255 … -0.9999999999999998 9.549150281252626], [1, 5, 3, 4, 5, 21, 25, 23, 24, 22 … 16, 20, 18, 19, 20, 21, 22, 23, 24, 25], 0))), 1.4901161193847656e-8, 500, [4.21161487492617, 0.290135671904221, -0.11662623019910943, 0.05586876436020137, -0.02346325853367539, 1.1898454240361866, -0.01405962477762347, 0.002899108549012464, -0.0003133139825453007, -0.0001483585438136594 … -0.0006327306756350298, 0.0005464001930767071, -0.00029850732508373125, 0.0001585172634880088, -6.894973553197262e-5, 0.0001792813204134031, -6.329922855792093e-5, 2.7109669090790667e-5, -1.1681218512625375e-5, 4.3779171817291865e-6], true, 322, [0.34227024433899 -0.30433808521444916; 2.140463001152258 -0.30433808521444916; … ; 7.959536998847741 0.30433808521444916; 9.75772975566101 0.30433808521444916], ([0.34227024433899, 2.140463001152258, 5.05, 7.959536998847741, 9.75772975566101], [-0.30433808521444916, -0.1880912807335914, -1.959434878635765e-17, 0.18809128073359138, 0.30433808521444916]), [2.647383753725658, 2.999320777437582, 3.164010881387303, 3.2486261198935638, 3.2857763754395366, 3.0939987106058227, 3.4494027989341327, 3.611399046745797, 3.694106894526747, 3.7303530611007742 … 4.514253934172594, 4.8578486829760275, 5.007330600611515, 5.0831751792307704, 5.116405668805133, 4.938989512718134, 5.275447729539894, 5.420960783952578, 5.494849027011576, 5.5272541961991974], [0.6539902467362662, 0.6382902824039567, 0.6458556474771333, 0.6517211383960454, 0.654575378764242, 0.6457001331777936, 0.6407666089375499, 0.650684095106122, 0.6571891291175578, 0.6602174592484137 … 0.6407502754224127, 0.6573010218773715, 0.6699019072172715, 0.6765176868127885, 0.6793698802124021, 0.6433248493935828, 0.6632764006769559, 0.6757667593081624, 0.6820733189659822, 0.684742027610418], [1.3495657924522675e-8, 1.3495658812701095e-8, 1.3495657924522675e-8, 1.3495656592255045e-8, 1.3495658812701095e-8, 1.3495660144968724e-8, 1.3495657924522675e-8, 1.3495656592255045e-8, 1.3495657480433465e-8, 1.3495657924522675e-8 … 1.3495659700879514e-8, 1.3495657036344255e-8, 1.3495654371808996e-8, 1.3495653483630576e-8, 1.3495657924522675e-8, 1.3495657036344255e-8, 1.3495656148165835e-8, 1.3495658812701095e-8, 1.3495656148165835e-8, 1.3495652595452157e-8])" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Solve DP by VFI\n", + "res = solve(cdp, VFI; max_iter=500, tol = sqrt(eps()))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "be64df21", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "VFI converged: true in 322 iterations.\n" + ] + } + ], + "source": [ + "# Convergence\n", + "println(\"VFI converged: \", res.converged, \" in \", res.num_iter, \" iterations.\")" + ] + }, + { + "cell_type": "markdown", + "id": "aa0229cb", + "metadata": {}, + "source": [ + "## 4. Analytical Benchmark" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8c082d7f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "analytical_solution (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analytical solution (delta = 1)\n", + "function analytical_solution(params::Params)\n", + " @assert params.delta == 1.0 \"Analytical solution is only for delta = 1\"\n", + "\n", + " ab = params.alpha * params.beta\n", + "\n", + " # Optimal leisure (constant)\n", + " l_star = ((1 - params.lambda)*(1 - ab)) / (params.lambda*(1 - params.alpha) + ((1 - params.lambda)*(1 - ab)))\n", + " \n", + " # Value function: V(k, z) = B + C*log(k) + D*log(z)\n", + " C = params.lambda * params.alpha / (1 - ab)\n", + " D = params.lambda / ((1 - ab) * (1 - params.rho * params.beta))\n", + " \n", + " const_term = params.lambda * (log(1 - ab) + log(params.A) + (1 - params.alpha) * log(1 - l_star)) + (1 - params.lambda) * log(l_star) + params.beta * C * (log(ab) + log(params.A) + (1-params.alpha) * log(1 - l_star))\n", + " B = const_term / (1 - params.beta)\n", + "\n", + " # Policy function (consant fraction of production)\n", + " policy(k, logz) = ab * exp(logz) * params.A * k^params.alpha * (1 - l_star)^(1 - params.alpha)\n", + "\n", + " # Value function\n", + " v_star(k, logz) = B + C * log(k) + D * logz\n", + "\n", + " return B, C, D, l_star, policy, v_star\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ebdaf054", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "25-element Vector{Float64}:\n", + " 0.7923835123449829\n", + " 1.4778234295861785\n", + " 1.9786500465112982\n", + " 2.309679794243042\n", + " 2.475303798444655\n", + " 0.8900630579550834\n", + " 1.6599992558685037\n", + " 2.2225643057727673\n", + " 2.5944011056933824\n", + " 2.780442088820594\n", + " ⋮\n", + " 2.418142577634339\n", + " 3.2376384268362424\n", + " 3.779297945441814\n", + " 4.050306273243436\n", + " 1.4563981962468253\n", + " 2.7162344290217293\n", + " 3.636752044744886\n", + " 4.245183593344114\n", + " 4.549599948829042" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate analytical solution\n", + "B, C, D, l_star, policy, v_star = analytical_solution(p)\n", + "\n", + "# Analytical targets on interpolation nodes\n", + "S = cdp.interp.S\n", + "k_nodes = @view S[:, 1]\n", + "logz_nodes = @view S[:, 2]\n", + "v_star_on_S = v_star.(k_nodes, logz_nodes)\n", + "k_prime_star_on_S = policy.(k_nodes, logz_nodes)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "512a3677", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analytical l* = 0.6722939424031779\n", + "l_hat range on interpolation nodes: [0.6382902824039567, 0.684742027610418]\n", + "max |l_hat - l_star| = 0.03400365999922117\n", + "max |V_hat - V_star| = 0.18207578978585914\n" + ] + } + ], + "source": [ + "# Policy function benchmark check\n", + "l_hat = vec(res.X)\n", + "println(\"Analytical l* = \", l_star)\n", + "println(\"l_hat range on interpolation nodes: [\", minimum(l_hat), \", \", maximum(l_hat), \"]\" )\n", + "println(\"max |l_hat - l_star| = \", maximum(abs.(l_hat .- l_star)))\n", + "\n", + "# Value function benchmark check\n", + "v_hat = vec(res.V)\n", + "println(\"max |V_hat - V_star| = \", maximum(abs.(v_hat .- v_star_on_S)))" + ] + }, + { + "cell_type": "markdown", + "id": "9b2817ab", + "metadata": {}, + "source": [ + "## 5. Simulation and Figures" + ] + }, + { + "cell_type": "markdown", + "id": "fce28a1d", + "metadata": {}, + "source": [ + "### 5.1 Policy Function Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cb08c4d2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2026-02-17T03:34:52.094313\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.10.8, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "Python:
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2026-02-17T03:34:52.777565\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.10.8, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "Python:
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Figure legend\n", + "interp_name = \"Chebyshev\"\n", + "method_name = \"VFI\"\n", + "tag = \"$(interp_name) × $(method_name)\"\n", + "lbl_approx = \"numerical solution ($tag)\"\n", + "lbl_bench = \"analytical benchmark\"\n", + "\n", + "# Grids\n", + "k_grid = collect(range(k_min, k_max; length=300))\n", + "logz_slices = [logz_min, 0.0, logz_max]\n", + "\n", + "# Policy value on nodes\n", + "X_interp = Interpoland(basis, res.X)\n", + "\n", + "# Leisure policy across k for different logz slices\n", + "ncols = length(logz_slices)\n", + "fig = plt.figure(figsize=(4.8*ncols, 4.2))\n", + "\n", + "for (j, logz0) in enumerate(logz_slices)\n", + " ax = fig.add_subplot(1, ncols, j)\n", + "\n", + " l_hat = [X_interp([k, logz0]) for k in k_grid]\n", + "\n", + " ax.plot(k_grid, l_hat, lw=2, label=lbl_approx)\n", + " ax.axhline(l_star, lw=2, linestyle=\"--\", label=lbl_bench)\n", + "\n", + " ax.set_title(\"log z = $(round(logz0, digits=2))\")\n", + " ax.set_xlabel(\"k\")\n", + " if j == 1\n", + " ax.set_ylabel(\"leisure ℓ\")\n", + " end\n", + " ax.set_xlim(k_min, k_max)\n", + " ax.set_ylim(0.0, 1.0)\n", + " ax.grid(true, alpha=0.3)\n", + " ax.legend()\n", + "end\n", + "\n", + "fig.suptitle(\"Leisure policy l(k, logz)\")\n", + "fig.tight_layout(rect=[0, 0, 1, 0.92])\n", + "display(fig)\n", + "\n", + "# Implied k' policy across k for different logz slices\n", + "fig = plt.figure(figsize=(4.8*ncols, 4.2))\n", + "\n", + "for (j, logz0) in enumerate(logz_slices)\n", + " ax = fig.add_subplot(1, ncols, j)\n", + "\n", + " z0 = exp(logz0)\n", + "\n", + " l_hat = [X_interp([k, logz0]) for k in k_grid]\n", + " kp_hat = [kprime_from_l(k_grid[i], z0, l_hat[i]) for i in eachindex(k_grid)]\n", + " kp_bench = policy.(k_grid, logz0)\n", + "\n", + " ax.plot(k_grid, kp_hat, lw=2, label=lbl_approx)\n", + " ax.plot(k_grid, kp_bench, lw=2, linestyle=\"--\", label=lbl_bench)\n", + "\n", + " ax.set_title(\"log z = $(round(logz0, digits=2))\")\n", + " ax.set_xlabel(\"k\")\n", + " if j == 1\n", + " ax.set_ylabel(\"k'\")\n", + " end\n", + " ax.set_xlim(k_min, k_max)\n", + " ax.grid(true, alpha=0.3)\n", + " ax.legend()\n", + "end\n", + "\n", + "fig.suptitle(\"Capital policy k'(k, log z)\")\n", + "fig.tight_layout(rect=[0, 0, 1, 0.92])\n", + "display(fig)\n" + ] + }, + { + "cell_type": "markdown", + "id": "87f22a26", + "metadata": {}, + "source": [ + "### 5.2 Value Function Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a04490c9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2026-02-17T03:34:53.656626\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.10.8, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "Python:
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Figure legend\n", + "interp_name = \"Chebyshev\"\n", + "method_name = \"VFI\"\n", + "tag = \"$(interp_name) × $(method_name)\"\n", + "lbl_approx = \"numerical solution ($tag)\"\n", + "lbl_bench = \"analytical benchmark\"\n", + "\n", + "k_grid = collect(range(k_min, k_max; length=300))\n", + "logz_slices = [logz_min, 0.0, logz_max]\n", + "ncols = length(logz_slices)\n", + "\n", + "fig = plt.figure(figsize=(4.8*ncols, 4.2))\n", + "\n", + "for (j, logz0) in enumerate(logz_slices)\n", + " ax = fig.add_subplot(1, ncols, j)\n", + "\n", + " S_line = hcat(k_grid, fill(logz0, length(k_grid)))\n", + "\n", + " # Numerical V(k,logz)\n", + " V_hat = vec(funeval(res.C, cdp.interp.basis, S_line))\n", + "\n", + " # Analytic benchmark\n", + " V_bench = v_star.(k_grid, logz0)\n", + "\n", + " ax.plot(k_grid, V_hat, lw=2, label=lbl_approx)\n", + " ax.plot(k_grid, V_bench, lw=2, linestyle=\"--\", label=lbl_bench)\n", + "\n", + " ax.set_title(\"log z = $(round(logz0, digits=2))\")\n", + " ax.set_xlabel(\"k\")\n", + " if j == 1\n", + " ax.set_ylabel(\"V(k, logz)\")\n", + " end\n", + " ax.set_xlim(k_min, k_max)\n", + " ax.grid(true, alpha=0.3)\n", + " ax.legend()\n", + "end\n", + "\n", + "fig.suptitle(\"Value function V(k, logz)\")\n", + "fig.tight_layout(rect=[0, 0, 1, 0.92])\n", + "display(fig)\n" + ] + }, + { + "cell_type": "markdown", + "id": "5a810f5d", + "metadata": {}, + "source": [ + "### 5.3 Solutions & Errors with Multiple Methods and Interpolations" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "635eff84", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "build_basis (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# For interpolation settings\n", + "struct InterpType\n", + " type::Symbol\n", + " label::String\n", + " deg_k::Int\n", + " deg_z::Int\n", + "end\n", + "\n", + "interp_types = [\n", + " InterpType(:linear, \"Linear\", 0, 0),\n", + " InterpType(:spline, \"Spline\", 3, 1),\n", + " InterpType(:chebyshev, \"Chebyshev\", 0, 0)\n", + "]\n", + "\n", + "# Build interpolation basis\n", + "function build_basis(interp_type::Symbol, nk::Int, nlogz::Int;\n", + " kmin::Float64=k_min, kmax::Float64=k_max,\n", + " zmin::Float64=logz_min, zmax::Float64=logz_max,\n", + " deg_k::Int=3, deg_z::Int=1)\n", + " if interp_type == :linear\n", + " return Basis(LinParams(nk, kmin, kmax), LinParams(nlogz, zmin, zmax))\n", + "\n", + " elseif interp_type == :chebyshev\n", + " return Basis(ChebParams(nk, kmin, kmax), ChebParams(nlogz, zmin, zmax))\n", + "\n", + " elseif interp_type == :spline\n", + " dk = min(deg_k, nk - 1)\n", + " dz = min(deg_z, nlogz - 1)\n", + "\n", + " @assert nk >= 2 \"nk must be >= 2\"\n", + " @assert nlogz >= 2 \"nlogz must be >= 2\"\n", + " @assert dk >= 1 && dz >= 1\n", + "\n", + " breaks_k = nk - (dk - 1)\n", + " breaks_z = nlogz - (dz - 1)\n", + "\n", + " return Basis(SplineParams(breaks_k, kmin, kmax, dk), SplineParams(breaks_z, zmin, zmax, dz))\n", + " \n", + " else\n", + " error(\"Unknown interp_type == $interp_type\")\n", + " end\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ef2da705", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Dict{Any, Any}()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Grid setup\n", + "nk, nlogz = 3, 3\n", + "\n", + "# Method types\n", + "methods = [VFI, PFI]\n", + "method_names = [\"VFI\", \"PFI\"]\n", + "\n", + "# Test each combination\n", + "results = Dict()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "057b6929", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== VFI with Linear interpolation vs Santos(1999) analytical solution benchmark (delta = 1) ===\n", + "Converged in 314 iterations\n", + "Analytical l* = 0.6722939424031779\n", + "l_hat range on interpolation nodes: [0.4860037217238575, 0.7518796832142517]\n", + "max |l_hat - l_star| = 0.18629022067932038\n", + "max |V_hat - V_star| = 2.2915782176810966\n", + "\n", + "=== VFI with Spline interpolation vs Santos(1999) analytical solution benchmark (delta = 1) ===\n", + "Converged in 322 iterations\n", + "Analytical l* = 0.6722939424031779\n", + "l_hat range on interpolation nodes: [0.512654382037513, 0.7179384904943585]\n", + "max |l_hat - l_star| = 0.15963956036566485\n", + "max |V_hat - V_star| = 1.5024207707540684\n", + "\n", + "=== VFI with Chebyshev interpolation vs Santos(1999) analytical solution benchmark (delta = 1) ===\n", + "Converged in 319 iterations\n", + "Analytical l* = 0.6722939424031779\n", + "l_hat range on interpolation nodes: [0.6275505724999723, 0.7518796832142517]\n", + "max |l_hat - l_star| = 0.07958574081107384\n", + "max |V_hat - V_star| = 0.4203629692546711\n", + "\n", + "=== PFI with Linear interpolation vs Santos(1999) analytical solution benchmark (delta = 1) ===\n", + "Converged in 9 iterations\n", + "Analytical l* = 0.6722939424031779\n", + "l_hat range on interpolation nodes: [0.4860037144711569, 0.7518796832142517]\n", + "max |l_hat - l_star| = 0.18629022793202094\n", + "max |V_hat - V_star| = 2.2915779588424843\n", + "\n", + "=== PFI with Spline interpolation vs Santos(1999) analytical solution benchmark (delta = 1) ===\n", + "Converged in 7 iterations\n", + "Analytical l* = 0.6722939424031779\n", + "l_hat range on interpolation nodes: [0.5126543747158909, 0.7179384905138967]\n", + "max |l_hat - l_star| = 0.15963956768728693\n", + "max |V_hat - V_star| = 1.5024205055946562\n", + "\n", + "=== PFI with Chebyshev interpolation vs Santos(1999) analytical solution benchmark (delta = 1) ===\n", + "Converged in 6 iterations\n", + "Analytical l* = 0.6722939424031779\n", + "l_hat range on interpolation nodes: [0.6275505631472991, 0.7518796832142517]\n", + "max |l_hat - l_star| = 0.07958574081107384\n", + "max |V_hat - V_star| = 0.42036270440507373\n", + "\n" + ] + } + ], + "source": [ + "for (method, method_name) in zip(methods, method_names)\n", + " for interp_type in interp_types\n", + " simulation_name = \"$(method_name) with $(interp_type.label) interpolation\" \n", + " # Build interpolation basis\n", + " basis = build_basis(interp_type.type, nk, nlogz)\n", + " \n", + " # Build DP\n", + " cdp = ContinuousDP(f, g, p.beta, shocks, weights, x_lb, x_ub, basis)\n", + " \n", + " # Analytical targets on interpolation nodes\n", + " S = cdp.interp.S\n", + " k_nodes = @view S[:, 1]\n", + " logz_nodes = @view S[:, 2]\n", + " v_star_on_S = v_star.(k_nodes, logz_nodes)\n", + " k_prime_star_on_S = policy.(k_nodes, logz_nodes)\n", + " \n", + " # Solve DP\n", + " res = solve(cdp, method, max_iter=500, tol=sqrt(eps()), verbose=0)\n", + " results[simulation_name] = res\n", + " l_hat = vec(res.X)\n", + "\n", + " println(\"=== $simulation_name vs Santos(1999) analytical solution benchmark (delta = 1) ===\")\n", + " # Iteration number check\n", + " println(\"Converged in $(res.num_iter) iterations\")\n", + "\n", + " # Policy function benchmark check\n", + " println(\"Analytical l* = \", l_star)\n", + " println(\"l_hat range on interpolation nodes: [\", minimum(l_hat), \", \", maximum(l_hat), \"]\" )\n", + " println(\"max |l_hat - l_star| = \", maximum(abs.(l_hat .- l_star)))\n", + "\n", + " # Value function benchmark check\n", + " println(\"max |V_hat - V_star| = \", maximum(abs.(res.V .- v_star_on_S)), \"\\n\")\n", + " end\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "bc027156", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.12.4", + "language": "julia", + "name": "julia-1.12" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}