Merge branch 'main' into dependabot/github_actions/actions/checkout-6

Author: mmcky

environment.yml

@@ -7,7 +7,7 @@ dependencies:
   - pip
   - pip:
     - jupyter-book==1.0.4post1
-    - quantecon-book-theme==0.13.0
+    - quantecon-book-theme==0.13.2
     - sphinx-tojupyter==0.4.0
     - sphinxext-rediraffe==0.2.7
     - sphinx-exercise==1.2.0

lectures/_toc.yml

@@ -72,16 +72,21 @@ parts:
   - file: jv
   - file: odu
   - file: mccall_q
+- caption: Introduction to Optimal Savings
+  numbered: true
+  chapters:
+  - file: os
+  - file: os_numerical
+  - file: os_stochastic
+  - file: os_time_iter
+  - file: os_egm
+  - file: os_egm_jax
 - caption: Household Problems
   numbered: true
   chapters:
-  - file: cake_eating
-  - file: cake_eating_numerical
-  - file: cake_eating_stochastic
-  - file: cake_eating_time_iter
-  - file: cake_eating_egm
-  - file: cake_eating_egm_jax
-  - file: ifp
+  - file: ifp_discrete
+  - file: ifp_opi
+  - file: ifp_egm
   - file: ifp_advanced
 - caption: LQ Control
   numbered: true

lectures/finite_markov.md

@@ -212,11 +212,11 @@ One natural way to answer questions about Markov chains is to simulate them.
 
 (To approximate the probability of event $E$, we can simulate many times and count the fraction of times that $E$ occurs).
 
-Nice functionality for simulating Markov chains exists in [QuantEcon.py](https://quantecon.org/quantecon-py).
+Nice functionality for simulating Markov chains exists in [QuantEcon.py](https://quantecon.org/quantecon-py/).
 
 * Efficient, bundled with lots of other useful routines for handling Markov chains.
 
-However, it's also a good exercise to roll our own routines --- let's do that first and then come back to the methods in [QuantEcon.py](https://quantecon.org/quantecon-py).
+However, it's also a good exercise to roll our own routines --- let's do that first and then come back to the methods in [QuantEcon.py](https://quantecon.org/quantecon-py/).
 
 In these exercises, we'll take the state space to be $S = 0,\ldots, n-1$.
 
@@ -231,7 +231,7 @@ The Markov chain is then constructed as discussed above.  To repeat:
 
 To implement this simulation procedure, we need a method for generating draws from a discrete distribution.
 
-For this task, we'll use `random.draw` from [QuantEcon](https://quantecon.org/quantecon-py), which works as follows:
+For this task, we'll use `random.draw` from [QuantEcon](https://quantecon.org/quantecon-py/), which works as follows:
 
 ```{code-cell} python3
 ψ = (0.3, 0.7)           # probabilities over {0, 1}
@@ -294,7 +294,7 @@ always close to 0.25, at least for the `P` matrix above.
 
 ### Using QuantEcon's Routines
 
-As discussed above, [QuantEcon.py](https://quantecon.org/quantecon-py) has routines for handling Markov chains, including simulation.
+As discussed above, [QuantEcon.py](https://quantecon.org/quantecon-py/) has routines for handling Markov chains, including simulation.
 
 Here's an illustration using the same P as the preceding example
 
@@ -306,7 +306,7 @@ X = mc.simulate(ts_length=1_000_000)
 np.mean(X == 0)
 ```
 
-The [QuantEcon.py](https://quantecon.org/quantecon-py) routine is [JIT compiled](https://python-programming.quantecon.org/numba.html#numba-link) and much faster.
+The [QuantEcon.py](https://quantecon.org/quantecon-py/) routine is [JIT compiled](https://python-programming.quantecon.org/numba.html#numba-link) and much faster.
 
 ```{code-cell} ipython
 %time mc_sample_path(P, sample_size=1_000_000) # Our homemade code version
@@ -556,7 +556,7 @@ $$
 It's clear from the graph that this stochastic matrix is irreducible: we can  eventually
 reach any state from any other state.
 
-We can also test this using [QuantEcon.py](https://quantecon.org/quantecon-py)'s MarkovChain class
+We can also test this using [QuantEcon.py](https://quantecon.org/quantecon-py/)'s MarkovChain class
 
 ```{code-cell} python3
 P = [[0.9, 0.1, 0.0],
@@ -775,7 +775,7 @@ One option is to regard solving system {eq}`eq:eqpsifixed`  as an eigenvector pr
 $\psi$ such that $\psi = \psi P$ is a left eigenvector associated
 with the unit eigenvalue $\lambda = 1$.
 
-A stable and sophisticated algorithm specialized for stochastic matrices is implemented in [QuantEcon.py](https://quantecon.org/quantecon-py).
+A stable and sophisticated algorithm specialized for stochastic matrices is implemented in [QuantEcon.py](https://quantecon.org/quantecon-py/).
 
 This is the one we recommend:
 
@@ -1322,7 +1322,7 @@ $$
 
 Tauchen's method {cite}`Tauchen1986` is the most common method for approximating this continuous state process with a finite state Markov chain.
 
-A routine for this already exists in [QuantEcon.py](https://quantecon.org/quantecon-py) but let's write our own version as an exercise.
+A routine for this already exists in [QuantEcon.py](https://quantecon.org/quantecon-py/) but let's write our own version as an exercise.
 
 As a first step, we choose
 
@@ -1363,13 +1363,13 @@ The exercise is to write a function `approx_markov(rho, sigma_u, m=3, n=7)` that
 $\{x_0, \ldots, x_{n-1}\} \subset \mathbb R$ and $n \times n$ matrix
 $P$ as described above.
 
-* Even better, write a function that returns an instance of [QuantEcon.py's](https://quantecon.org/quantecon-py) MarkovChain class.
+* Even better, write a function that returns an instance of [QuantEcon.py's](https://quantecon.org/quantecon-py/) MarkovChain class.
 ```
 
 ```{solution} fm_ex3
 :class: dropdown
 
-A solution from the [QuantEcon.py](https://quantecon.org/quantecon-py) library
+A solution from the [QuantEcon.py](https://quantecon.org/quantecon-py/) library
 can be found [here](https://github.com/QuantEcon/QuantEcon.py/blob/master/quantecon/markov/approximation.py).
 
 ```

lectures/ifp_advanced.md

@@ -17,7 +17,7 @@ kernelspec:
 </div>
 ```
 
-# {index}`The Income Fluctuation Problem II: Stochastic Returns on Assets <single: The Income Fluctuation Problem II: Stochastic Returns on Assets>`
+# {index}`The Income Fluctuation Problem IV: Stochastic Returns on Assets <single: The Income Fluctuation Problem IV: Stochastic Returns on Assets>`
 
 ```{contents} Contents
 :depth: 2
@@ -34,7 +34,7 @@ tags: [hide-output]
 
 ## Overview
 
-In this lecture, we continue our study of the {doc}`income fluctuation problem <ifp>`.
+In this lecture, we continue our study of the income fluctuation problem described in {doc}`ifp_egm`.
 
 While the interest rate was previously taken to be fixed, we now allow
 returns on assets to be state-dependent.
@@ -112,7 +112,7 @@ where
 
 Let $P$ represent the Markov matrix for the chain $\{Z_t\}_{t \geq 0}$.
 
-Our assumptions on preferences are the same as our {doc}`previous lecture <ifp>` on the income fluctuation problem.
+Our assumptions on preferences are the same as in {doc}`ifp_egm`.
 
 As before, $\mathbb E_z \hat X$ means expectation of next period value
 $\hat X$ given current value $Z = z$.
@@ -160,8 +160,7 @@ the IID and CRRA environment of {cite}`benhabib2015`.
 
 ### Optimality
 
-Let the class of candidate consumption policies $\mathscr C$ be defined
-{doc}`as before <ifp>`.
+Let the class of candidate consumption policies $\mathscr C$ be defined as in {doc}`ifp_egm`.
 
 In {cite}`ma2020income` it is shown that, under the stated assumptions,
 
@@ -182,8 +181,7 @@ In the present setting, the Euler equation takes the form
        \right\}
 ```
 
-(Intuition and derivation are similar to our {doc}`earlier lecture <ifp>` on
-the income fluctuation problem.)
+(Intuition and derivation are similar to {doc}`ifp_egm`.)
 
 We again solve the Euler equation using time iteration, iterating with a
 Coleman--Reffett operator $K$ defined to match the Euler equation
@@ -197,8 +195,7 @@ Coleman--Reffett operator $K$ defined to match the Euler equation
 ### A Time Iteration Operator
 
 Our definition of the candidate class $\sigma \in \mathscr C$ of consumption
-policies is the same as in our {doc}`earlier lecture <ifp>` on the income
-fluctuation problem.
+policies is the same as in {doc}`ifp_egm`.
 
 For fixed $\sigma \in \mathscr C$ and $(a,z) \in \mathbf S$, the value
 $K\sigma(a,z)$ of the function $K\sigma$ at $(a,z)$ is defined as the
@@ -251,7 +248,7 @@ convergence (as measured by the distance $\rho$).
 ### Using an Endogenous Grid
 
 In the study of that model we found that it was possible to further
-accelerate time iteration via the {doc}`endogenous grid method <cake_eating_egm>`.
+accelerate time iteration via the {doc}`endogenous grid method <os_egm>`.
 
 We will use the same method here.
 
@@ -578,7 +575,7 @@ In contrast, when $z=1$ (good state), higher expected future income allows the h
 Let's try to get some idea of what will happen to assets over the long run
 under this consumption policy.
 
-As with our {doc}`earlier lecture <ifp>` on the income fluctuation problem, we
+As in {doc}`ifp_egm`, we
 begin by producing a 45 degree diagram showing the law of motion for assets
 
 ```{code-cell} python3
@@ -911,7 +908,7 @@ The JAX implementation provides several advantages:
 ```{exercise}
 :label: ifpa_ex1
 
-Let's repeat our {ref}`earlier exercise <ifp_ex2>` on the long-run
+Let's repeat our {ref}`earlier exercise <ifp_egm_ex2>` on the long-run
 cross sectional distribution of assets.
 
 In that exercise, we used a relatively simple income fluctuation model.