Pass rng as explicit argument in monte_carlo.md functions

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Chihiro2000GitHub

lectures/monte_carlo.md

@@ -181,7 +181,9 @@ S / n
 We can also construct a function that contains these operations:
 
 ```{code-cell} ipython3
-def compute_mean(n=1_000_000):
+def compute_mean(n=1_000_000, rng=None):
+    if rng is None:
+        rng = np.random.default_rng()
     S = 0.0
     for i in range(n):
         X_1 = np.exp(μ_1 + σ_1 * rng.standard_normal())
@@ -196,7 +198,7 @@ def compute_mean(n=1_000_000):
 Now let's call it.
 
 ```{code-cell} ipython3
-compute_mean()
+compute_mean(rng=rng)
 ```
 
 
@@ -210,7 +212,9 @@ But the code above runs quite slowly.
 To make it faster, let's implement a vectorized routine using NumPy.
 
 ```{code-cell} ipython3
-def compute_mean_vectorized(n=1_000_000):
+def compute_mean_vectorized(n=1_000_000, rng=None):
+    if rng is None:
+        rng = np.random.default_rng()
     X_1 = np.exp(μ_1 + σ_1 * rng.standard_normal(n))
     X_2 = np.exp(μ_2 + σ_2 * rng.standard_normal(n))
     X_3 = np.exp(μ_3 + σ_3 * rng.standard_normal(n))
@@ -221,7 +225,7 @@ def compute_mean_vectorized(n=1_000_000):
 ```{code-cell} ipython3
 %%time
 
-compute_mean_vectorized()
+compute_mean_vectorized(rng=rng)
 ```
 
 
@@ -233,7 +237,7 @@ We can increase $n$ to get more accuracy and still have reasonable speed:
 ```{code-cell} ipython3
 %%time
 
-compute_mean_vectorized(n=10_000_000)
+compute_mean_vectorized(n=10_000_000, rng=rng)
 ```
 
 
@@ -515,7 +519,9 @@ $$ s_{t+1} = s_t + \mu + \exp(h_t) \xi_{t+1} $$
 Here is a function to simulate a path using this equation:
 
 ```{code-cell} ipython3
-def simulate_asset_price_path(μ=default_μ, S0=default_S0, h0=default_h0, n=default_n, ρ=default_ρ, ν=default_ν):
+def simulate_asset_price_path(μ=default_μ, S0=default_S0, h0=default_h0, n=default_n, ρ=default_ρ, ν=default_ν, rng=None):
+    if rng is None:
+        rng = np.random.default_rng()
     s = np.empty(n+1)
     s[0] = np.log(S0)
 
@@ -538,7 +544,7 @@ titles = 'log paths', 'paths'
 transforms = np.log, lambda x: x
 for ax, transform, title in zip(axes, transforms, titles):
     for i in range(50):
-        path = simulate_asset_price_path()
+        path = simulate_asset_price_path(rng=rng)
         ax.plot(transform(path))
     ax.set_title(title)
 
@@ -576,7 +582,10 @@ def compute_call_price(β=default_β,
                        n=default_n,
                        ρ=default_ρ,
                        ν=default_ν,
-                       M=10_000):
+                       M=10_000,
+                       rng=None):
+    if rng is None:
+        rng = np.random.default_rng()
     current_sum = 0.0
     # For each sample path
     for m in range(M):
@@ -594,7 +603,7 @@ def compute_call_price(β=default_β,
 
 ```{code-cell} ipython3
 %%time
-compute_call_price()
+compute_call_price(rng=rng)
 ```
 
 
@@ -625,8 +634,10 @@ def compute_call_price_vector(β=default_β,
                        n=default_n,
                        ρ=default_ρ,
                        ν=default_ν,
-                       M=10_000):
-
+                       M=10_000,
+                       rng=None):
+    if rng is None:
+        rng = np.random.default_rng()
     s = np.full(M, np.log(S0))
     h = np.full(M, h0)
     for t in range(n):
@@ -640,7 +651,7 @@ def compute_call_price_vector(β=default_β,
 
 ```{code-cell} ipython3
 %%time
-compute_call_price_vector()
+compute_call_price_vector(rng=rng)
 ```
 
 
@@ -651,7 +662,7 @@ Now let's try with larger $M$ to get a more accurate calculation.
 
 ```{code-cell} ipython3
 %%time
-compute_call_price(M=10_000_000)
+compute_call_price(M=10_000_000, rng=rng)
 ```
 
 
@@ -697,7 +708,10 @@ def compute_call_price_with_barrier(β=default_β,
                                     ρ=default_ρ,
                                     ν=default_ν,
                                     bp=default_bp,
-                                    M=50_000):
+                                    M=50_000,
+                                    rng=None):
+    if rng is None:
+        rng = np.random.default_rng()
     current_sum = 0.0
     # For each sample path
     for m in range(M):
@@ -723,7 +737,7 @@ def compute_call_price_with_barrier(β=default_β,
 ```
 
 ```{code-cell} ipython3
-%time compute_call_price_with_barrier()
+%time compute_call_price_with_barrier(rng=rng)
 ```
 
 
@@ -740,7 +754,10 @@ def compute_call_price_with_barrier_vector(β=default_β,
                                            ρ=default_ρ,
                                            ν=default_ν,
                                            bp=default_bp,
-                                           M=50_000):
+                                           M=50_000,
+                                           rng=None):
+    if rng is None:
+        rng = np.random.default_rng()
     s = np.full(M, np.log(S0))
     h = np.full(M, h0)
     option_is_null = np.full(M, False)
@@ -758,7 +775,7 @@ def compute_call_price_with_barrier_vector(β=default_β,
 ```
 
 ```{code-cell} ipython3
-%time compute_call_price_with_barrier_vector()
+%time compute_call_price_with_barrier_vector(rng=rng)
 ```
 
 ```{solution-end}