Merge pull request #208 from QuantEcon/solution-position

Moving All Solutions Below Corresponding Exercises

Author: jstac

lectures/matplotlib.md

@@ -301,8 +301,6 @@ The output should look like this
 ```{exercise-end}
 ```
 
-## Solutions
-
 ```{solution-start} mpl_ex1
 :class: dropdown
 ```

lectures/numba.md

@@ -486,50 +486,6 @@ Use the same idea here, but make the code efficient using Numba.
 Compare speed with and without Numba when the sample size is large.
 ```
 
-
-```{exercise-start}
-:label: speed_ex2
-```
-
-In the [Introduction to Quantitative Economics with Python](https://python-intro.quantecon.org) lecture series you can
-learn all about finite-state Markov chains.
-
-For now, let's just concentrate on simulating a very simple example of such a chain.
-
-Suppose that the volatility of returns on an asset can be in one of two regimes --- high or low.
-
-The transition probabilities across states are as follows
-
-```{figure} /_static/lecture_specific/sci_libs/nfs_ex1.png
-```
-
-For example, let the period length be one day, and suppose the current state is high.
-
-We see from the graph that the state tomorrow will be
-
-* high with probability 0.8
-* low with probability 0.2
-
-Your task is to simulate a sequence of daily volatility states according to this rule.
-
-Set the length of the sequence to `n = 1_000_000` and start in the high state.
-
-Implement a pure Python version and a Numba version, and compare speeds.
-
-To test your code, evaluate the fraction of time that the chain spends in the low state.
-
-If your code is correct, it should be about 2/3.
-
-Hints:
-
-* Represent the low state as 0 and the high state as 1.
-* If you want to store integers in a NumPy array and then apply JIT compilation, use `x = np.empty(n, dtype=np.int_)`.
-
-```{exercise-end}
-```
-
-## Solutions
-
 ```{solution-start} speed_ex1
 :class: dropdown
 ```
@@ -571,6 +527,46 @@ characters.
 ```{solution-end}
 ```
 
+```{exercise-start}
+:label: speed_ex2
+```
+
+In the [Introduction to Quantitative Economics with Python](https://python-intro.quantecon.org) lecture series you can
+learn all about finite-state Markov chains.
+
+For now, let's just concentrate on simulating a very simple example of such a chain.
+
+Suppose that the volatility of returns on an asset can be in one of two regimes --- high or low.
+
+The transition probabilities across states are as follows
+
+```{figure} /_static/lecture_specific/sci_libs/nfs_ex1.png
+```
+
+For example, let the period length be one day, and suppose the current state is high.
+
+We see from the graph that the state tomorrow will be
+
+* high with probability 0.8
+* low with probability 0.2
+
+Your task is to simulate a sequence of daily volatility states according to this rule.
+
+Set the length of the sequence to `n = 1_000_000` and start in the high state.
+
+Implement a pure Python version and a Numba version, and compare speeds.
+
+To test your code, evaluate the fraction of time that the chain spends in the low state.
+
+If your code is correct, it should be about 2/3.
+
+Hints:
+
+* Represent the low state as 0 and the high state as 1.
+* If you want to store integers in a NumPy array and then apply JIT compilation, use `x = np.empty(n, dtype=np.int_)`.
+
+```{exercise-end}
+```
 
 ```{solution-start} speed_ex2
 :class: dropdown

lectures/numpy.md

@@ -710,6 +710,12 @@ For a comprehensive list of what's available in NumPy see [this documentation](h
 
 ## Exercises
 
+```{code-cell} ipython
+%matplotlib inline
+import matplotlib.pyplot as plt
+plt.rcParams['figure.figsize'] = (10,6)
+```
+
 ```{exercise-start}
 :label: np_ex1
 ```
@@ -733,6 +739,35 @@ Now write a new function that does the same job, but uses NumPy arrays and array
 ```{exercise-end}
 ```
 
+```{solution-start} np_ex1
+:class: dropdown
+```
+
+This code does the job
+
+```{code-cell} python3
+def p(x, coef):
+    X = np.ones_like(coef)
+    X[1:] = x
+    y = np.cumprod(X)   # y = [1, x, x**2,...]
+    return coef @ y
+```
+
+Let's test it
+
+```{code-cell} python3
+x = 2
+coef = np.linspace(2, 4, 3)
+print(coef)
+print(p(x, coef))
+# For comparison
+q = np.poly1d(np.flip(coef))
+print(q(x))
+```
+
+```{solution-end}
+```
+
 
 ```{exercise-start}
 :label: np_ex2
@@ -784,56 +819,6 @@ If you can, write the method so that `draw(k)` returns `k` draws from `q`.
 ```{exercise-end}
 ```
 
-
-```{exercise}
-:label: np_ex3
-
-Recall our {ref}`earlier discussion <oop_ex1>` of the empirical cumulative distribution function.
-
-Your task is to
-
-1. Make the `__call__` method more efficient using NumPy.
-1. Add a method that plots the ECDF over $[a, b]$, where $a$ and $b$ are method parameters.
-```
-
-## Solutions
-
-```{code-cell} ipython
-%matplotlib inline
-import matplotlib.pyplot as plt
-plt.rcParams['figure.figsize'] = (10,6)
-```
-
-```{solution-start} np_ex1
-:class: dropdown
-```
-
-This code does the job
-
-```{code-cell} python3
-def p(x, coef):
-    X = np.ones_like(coef)
-    X[1:] = x
-    y = np.cumprod(X)   # y = [1, x, x**2,...]
-    return coef @ y
-```
-
-Let's test it
-
-```{code-cell} python3
-x = 2
-coef = np.linspace(2, 4, 3)
-print(coef)
-print(p(x, coef))
-# For comparison
-q = np.poly1d(np.flip(coef))
-print(q(x))
-```
-
-```{solution-end}
-```
-
-
 ```{solution-start} np_ex2
 :class: dropdown
 ```
@@ -899,6 +884,17 @@ using descriptors that behaves as we desire can be found
 ```
 
 
+```{exercise}
+:label: np_ex3
+
+Recall our {ref}`earlier discussion <oop_ex1>` of the empirical cumulative distribution function.
+
+Your task is to
+
+1. Make the `__call__` method more efficient using NumPy.
+1. Add a method that plots the ECDF over $[a, b]$, where $a$ and $b$ are method parameters.
+```
+
 ```{solution-start} np_ex3
 :class: dropdown
 ```

lectures/parallelization.md

@@ -442,8 +442,6 @@ For the size of the Monte Carlo simulation, use something substantial, such as
 `n = 100_000_000`.
 ```
 
-## Solutions
-
 ```{solution-start} parallel_ex1
 :class: dropdown
 ```

lectures/python_advanced_features.md

@@ -1667,6 +1667,31 @@ Write a function to recursively compute the $t$-th Fibonacci number for any $t$.
 ```{exercise-end}
 ```
 
+```{solution-start} paf_ex1
+:class: dropdown
+```
+
+Here's the standard solution
+
+```{code-cell} python3
+def x(t):
+    if t == 0:
+        return 0
+    if t == 1:
+        return 1
+    else:
+        return x(t-1) + x(t-2)
+```
+
+Let's test it
+
+```{code-cell} python3
+print([x(i) for i in range(10)])
+```
+
+```{solution-end}
+```
+
 
 ```{exercise-start}
 :label: paf_ex2
@@ -1695,58 +1720,6 @@ for date in dates:
 ```{exercise-end}
 ```
 
-
-```{exercise-start}
-:label: paf_ex3
-```
-
-Suppose we have a text file `numbers.txt` containing the following lines
-
-```{code-block} none
-:class: no-execute
-
-prices
-3
-8
-
-7
-21
-```
-
-Using `try` -- `except`, write a program to read in the contents of the file and sum the numbers, ignoring lines without numbers.
-
-```{exercise-end}
-```
-
-## Solutions
-
-
-```{solution-start} paf_ex1
-:class: dropdown
-```
-
-Here's the standard solution
-
-```{code-cell} python3
-def x(t):
-    if t == 0:
-        return 0
-    if t == 1:
-        return 1
-    else:
-        return x(t-1) + x(t-2)
-```
-
-Let's test it
-
-```{code-cell} python3
-print([x(i) for i in range(10)])
-```
-
-```{solution-end}
-```
-
-
 ```{solution-start} paf_ex2
 :class: dropdown
 ```
@@ -1781,6 +1754,29 @@ for date in dates:
 
 
 
+```{exercise-start}
+:label: paf_ex3
+```
+
+Suppose we have a text file `numbers.txt` containing the following lines
+
+```{code-block} none
+:class: no-execute
+
+prices
+3
+8
+
+7
+21
+```
+
+Using `try` -- `except`, write a program to read in the contents of the file and sum the numbers, ignoring lines without numbers.
+
+```{exercise-end}
+```
+
+
 ```{solution-start} paf_ex3
 :class: dropdown
 ```