ENH: Use sphinx-exercise for Styled Exercises and Solutions (#176)

* [functions]Migrating exercise to use sphinx-exercise

* add sphinx-exercise

* pull out code-cell until supported

* TST: new gated directives

* Enable dropdown via sphinx-togglebutton

* TST: see if sphinx-togglebutton works in sphinx_book_theme

* Restore quantecon-book-theme

* Empty commit to trigger rebuild

* Update all solutions to be hidden by default

* Update for sphinx-exercise

* Migrate to sphinx-exercise

* migrate to sphinx-exercise

* fix numpy syntax issue

* fix broken label

* Enable dropdown toggle for solutions

* Enable dropdown toggle for solutions

* move to use pypi sphinx-exercise==0.4.1

* upgrade sphinx-tojupyter==0.2.1

Co-authored-by: Shu <[email protected]>

Author: mmcky

environment.yml

@@ -8,9 +8,10 @@ dependencies:
   - pip:
     - jupyter-book==0.12.1
     - quantecon-book-theme==0.3.0
-    - sphinx-tojupyter==0.2.0
+    - sphinx-tojupyter==0.2.1
     - sphinxext-rediraffe==0.2.7
-    - sphinx-exercise==0.2.1
+    - sphinx-exercise==0.4.0
+    - sphinx-togglebutton
     - ghp-import==1.1.0
     # Temporary Fixes
     - networkx==2.6.3

lectures/_config.yml

@@ -16,7 +16,7 @@ latex:
      targetname: quantecon-python-programming.tex
 
 sphinx:
-  extra_extensions: [sphinx_multitoc_numbering, sphinxext.rediraffe, sphinx_tojupyter]
+  extra_extensions: [sphinx_multitoc_numbering, sphinxext.rediraffe, sphinx_tojupyter, sphinx_exercise, sphinx_togglebutton]
   config:
     html_favicon: _static/lectures-favicon.ico
     html_theme: quantecon_book_theme

lectures/functions.md

@@ -313,7 +313,8 @@ function*---as we did above.
 
 ## Exercises
 
-### Exercise 1
+```{exercise}
+:label: exercise_1
 
 Recall that $n!$ is read as "$n$ factorial" and defined as
 $n! = n \times (n - 1) \times \cdots \times 2 \times 1$.
@@ -323,17 +324,21 @@ write our own version as an exercise.
 
 In particular, write a function `factorial` such that `factorial(n)` returns $n!$
 for any positive integer $n$.
+```
 
-### Exercise 2
+```{exercise}
+:label: exercise_2
 
 The [binomial random variable](https://en.wikipedia.org/wiki/Binomial_distribution) $Y \sim Bin(n, p)$ represents the number of successes in $n$ binary trials, where each trial succeeds with probability $p$.
 
 Without any import besides `from numpy.random import uniform`, write a function
 `binomial_rv` such that `binomial_rv(n, p)` generates one draw of $Y$.
 
 Hint: If $U$ is uniform on $(0, 1)$ and $p \in (0,1)$, then the expression `U < p` evaluates to `True` with probability $p$.
+```
 
-### Exercise 3
+```{exercise}
+:label: exercise_3
 
 First, write a function that returns one realization of the following random device
 
@@ -346,12 +351,16 @@ Second, write another function that does the same task except that the second ru
 - If a head occurs `k` or more times within this sequence, pay one dollar.
 
 Use no import besides `from numpy.random import uniform`.
+```
 
 ## Solutions
 
-### Exercise 1
+```{solution-start} exercise_1
+:label: solution_1
+:class: dropdown
 
 Here's one solution.
+```
 
 ```{code-cell} python3
 def factorial(n):
@@ -363,7 +372,13 @@ def factorial(n):
 factorial(4)
 ```
 
-### Exercise 2
+```{solution-end}
+```
+
+```{solution-start} exercise_2
+:label: solution_2
+:class: dropdown
+````
 
 ```{code-cell} python3
 from numpy.random import uniform
@@ -379,9 +394,16 @@ def binomial_rv(n, p):
 binomial_rv(10, 0.5)
 ```
 
-### Exercise 3
+```{solution-end}
+```
+
+
+```{solution-start} exercise_3
+:label: solution_3
+:class: dropdown
 
 Here's a function for the first random device.
+```
 
 ```{code-cell} python3
 from numpy.random import uniform
@@ -423,3 +445,5 @@ def draw_new(k):  # pays if k successes in a sequence
 draw_new(3)
 ```
 
+```{solution-end}
+```

lectures/getting_started.md

@@ -468,7 +468,9 @@ Alternatively, if you want an outstanding free text editor and don't mind a seem
 
 ## Exercises
 
-### Exercise 1
+```{exercise}
+:label: gs_ex1
+```
 
 If Jupyter is still running, quit by using `Ctrl-C` at the terminal where
 you started it.
@@ -488,8 +490,10 @@ You should now be able to run a standard Jupyter notebook session.
 
 This is an alternative way to start the notebook that can also be handy.
 
-(gs_ex2)=
-### Exercise 2
+
+```{exercise-start}
+:label: gs_ex2
+```
 
 ```{index} single: Git
 ```
@@ -547,3 +551,5 @@ For reading on these and other topics, try
 * [Pro Git Book](http://git-scm.com/book) by Scott Chacon and Ben Straub.
 * One of the thousands of Git tutorials on the Net.
 
+```{exercise-end}
+```

lectures/matplotlib.md

@@ -278,7 +278,9 @@ The custom `subplots` function
 
 ## Exercises
 
-### Exercise 1
+```{exercise-start}
+:label: mpl_ex1
+```
 
 Plot the function
 
@@ -296,9 +298,14 @@ The output should look like this
 :scale: 130
 ```
 
+```{exercise-end}
+```
+
 ## Solutions
 
-### Exercise 1
+```{solution-start} mpl_ex1
+:class: dropdown
+```
 
 Here's one solution
 
@@ -316,3 +323,5 @@ for θ in θ_vals:
 plt.show()
 ```
 
+```{solution-end}
+```

lectures/numba.md

@@ -475,18 +475,21 @@ When Numba compiles machine code for functions, it treats global variables as co
 
 ## Exercises
 
-(speed_ex1)=
-### Exercise 1
+```{exercise}
+:label: speed_ex1
 
 {ref}`Previously <pbe_ex3>` we considered how to approximate $\pi$ by
 Monte Carlo.
 
 Use the same idea here, but make the code efficient using Numba.
 
 Compare speed with and without Numba when the sample size is large.
+```
+
 
-(speed_ex2)=
-### Exercise 2
+```{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.
@@ -498,7 +501,6 @@ Suppose that the volatility of returns on an asset can be in one of two regimes
 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.
@@ -523,9 +525,14 @@ 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
 
-### Exercise 1
+```{solution-start} speed_ex1
+:class: dropdown
+```
 
 Here is one solution:
 
@@ -561,7 +568,13 @@ If we switch off JIT compilation by removing `@njit`, the code takes around
 So we get a speed gain of 2 orders of magnitude--which is huge--by adding four
 characters.
 
-### Exercise 2
+```{solution-end}
+```
+
+
+```{solution-start} speed_ex2
+:class: dropdown
+```
 
 We let
 
@@ -632,3 +645,5 @@ qe.toc()
 
 This is a nice speed improvement for one line of code!
 
+```{solution-end}
+```

lectures/numpy.md

@@ -710,8 +710,9 @@ For a comprehensive list of what's available in NumPy see [this documentation](h
 
 ## Exercises
 
-(np_ex1)=
-### Exercise 1
+```{exercise-start}
+:label: np_ex1
+```
 
 Consider the polynomial expression
 
@@ -729,8 +730,13 @@ Now write a new function that does the same job, but uses NumPy arrays and array
 
 * Hint: Use `np.cumprod()`
 
-(np_ex2)=
-### Exercise 2
+```{exercise-end}
+```
+
+
+```{exercise-start}
+:label: np_ex2
+```
 
 Let `q` be a NumPy array of length `n` with `q.sum() == 1`.
 
@@ -775,15 +781,20 @@ If you can, implement the functionality as a class called `DiscreteRV`, where
 
 If you can, write the method so that `draw(k)` returns `k` draws from `q`.
 
-(np_ex3)=
-### Exercise 3
+```{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
 
@@ -793,7 +804,9 @@ import matplotlib.pyplot as plt
 plt.rcParams['figure.figsize'] = (10,6)
 ```
 
-### Exercise 1
+```{solution-start} np_ex1
+:class: dropdown
+```
 
 This code does the job
 
@@ -817,7 +830,13 @@ q = np.poly1d(np.flip(coef))
 print(q(x))
 ```
 
-### Exercise 2
+```{solution-end}
+```
+
+
+```{solution-start} np_ex2
+:class: dropdown
+```
 
 Here's our first pass at a solution:
 
@@ -876,7 +895,13 @@ library](https://github.com/QuantEcon/QuantEcon.py/tree/master/quantecon)
 using descriptors that behaves as we desire can be found
 [here](https://github.com/QuantEcon/QuantEcon.py/blob/master/quantecon/discrete_rv.py).
 
-### Exercise 3
+```{solution-end}
+```
+
+
+```{solution-start} np_ex3
+:class: dropdown
+```
 
 An example solution is given below.
 
@@ -962,3 +987,5 @@ F = ECDF(X)
 F.plot(ax)
 ```
 
+```{solution-end}
+```