feat: fill out more Python examples for multithreading

Signed-off-by: Henry Schreiner <henryschreineriii@gmail.com>

Author: henryiii

content/week11/fractalexample/single.py

@@ -0,0 +1,38 @@
+import contextlib
+import time
+
+import numpy as np
+
+
+@contextlib.contextmanager
+def timer():
+    start = time.monotonic()
+    yield
+    print(f"Took {time.monotonic() - start}s to run")
+
+
+def prepare(height, width):
+    c = np.sum(
+        np.broadcast_arrays(*np.ogrid[-1j : 0j : height * 1j, -1.5 : 0 : width * 1j]),
+        axis=0,
+    )
+    fractal = np.zeros_like(c, dtype=np.int32)
+    return c, fractal
+
+
+@timer()
+def run(c, fractal, maxiterations=20):
+    z = c
+
+    for i in range(1, maxiterations + 1):
+        z = z**2 + c  # Compute z
+        diverge = abs(z) > 2  # Divergence criteria
+
+        z[diverge] = 2  # Keep number size small
+        fractal[~diverge] = i  # Fill in non-diverged iteration number
+
+
+size = 4000, 3000
+
+c, fractal = prepare(*size)
+fractal = run(c, fractal)

content/week11/piexample/asyncpi.py

@@ -0,0 +1,45 @@
+import contextlib
+import random
+import statistics
+import threading
+import time
+import asyncio
+
+
+@contextlib.asynccontextmanager
+async def timer():
+    start = time.monotonic()
+    yield
+    print(f"Took {time.monotonic() - start:.3}s to run")
+
+
+def pi_each(trials: int) -> None:
+    Ncirc = 0
+    rand = random.Random()
+
+    for _ in range(trials):
+        x = rand.uniform(-1, 1)
+        y = rand.uniform(-1, 1)
+
+        if x * x + y * y <= 1:
+            Ncirc += 1
+
+    return 4.0 * (Ncirc / trials)
+
+
+async def pi_async(trials: int):
+    return await asyncio.to_thread(pi_each, trials)
+
+
+@timer()
+async def pi_all(trials: int, threads: int) -> float:
+    async with asyncio.TaskGroup() as tg:
+        tasks = [tg.create_task(pi_async(trials // threads)) for _ in range(threads)]
+    return statistics.mean(t.result() for t in tasks)
+
+
+def pi(trials: int, threads: int) -> float:
+    return asyncio.run(pi_all(trials, threads))
+
+
+print(f"{pi(10_000_000, 10)=}")

content/week11/piexample/procexec.py

@@ -0,0 +1,36 @@
+import contextlib
+import random
+import statistics
+import time
+from concurrent.futures import ProcessPoolExecutor
+
+
+@contextlib.contextmanager
+def timer():
+    start = time.monotonic()
+    yield
+    print(f"Took {time.monotonic() - start:.3}s to run")
+
+
+def pi_each(trials: int) -> None:
+    Ncirc = 0
+
+    for _ in range(trials):
+        x = random.uniform(-1, 1)
+        y = random.uniform(-1, 1)
+
+        if x * x + y * y <= 1:
+            Ncirc += 1
+
+    return 4.0 * (Ncirc / trials)
+
+
+@timer()
+def pi(trials: int, threads: int) -> float:
+    with ProcessPoolExecutor() as pool:
+        futures = pool.map(pi_each, [trials // threads] * threads)
+        return statistics.mean(futures)
+
+
+if __name__ == "__main__":
+    print(f"{pi(10_000_000, 10)=}")

content/week11/piexample/single.py

@@ -0,0 +1,28 @@
+import contextlib
+import random
+import statistics
+import time
+
+
+@contextlib.contextmanager
+def timer():
+    start = time.monotonic()
+    yield
+    print(f"Took {time.monotonic() - start:.3}s to run")
+
+
+@timer()
+def pi(trials: int) -> float:
+    Ncirc = 0
+
+    for _ in range(trials):
+        x = random.uniform(-1, 1)
+        y = random.uniform(-1, 1)
+
+        if x * x + y * y <= 1:
+            Ncirc += 1
+
+    return 4.0 * (Ncirc / trials)
+
+
+print(f"{pi(10_000_000)=}")

content/week11/piexample/thread.py

@@ -0,0 +1,44 @@
+import contextlib
+import random
+import statistics
+import threading
+import time
+import queue
+
+
+@contextlib.contextmanager
+def timer():
+    start = time.monotonic()
+    yield
+    print(f"Took {time.monotonic() - start:.3}s to run")
+
+
+def pi_each(q: queue.Queue, trials: int) -> None:
+    Ncirc = 0
+    rand = random.Random()
+
+    for _ in range(trials):
+        x = rand.uniform(-1, 1)
+        y = rand.uniform(-1, 1)
+
+        if x * x + y * y <= 1:
+            Ncirc += 1
+
+    q.put(4.0 * (Ncirc / trials))
+
+
+@timer()
+def pi(trials: int, threads: int) -> float:
+    q = queue.Queue()
+    workers = [
+        threading.Thread(target=pi_each, args=(q, trials // threads))
+        for _ in range(threads)
+    ]
+    for worker in workers:
+        worker.start()
+    for worker in workers:
+        worker.join()
+    return statistics.mean(q.get() for _ in range(q.qsize()))
+
+
+print(f"{pi(10_000_000, 10)=}")

content/week11/piexample/threadexec.py

@@ -0,0 +1,36 @@
+import contextlib
+import random
+import statistics
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+
+@contextlib.contextmanager
+def timer():
+    start = time.monotonic()
+    yield
+    print(f"Took {time.monotonic() - start:.3}s to run")
+
+
+def pi_each(trials: int) -> None:
+    Ncirc = 0
+    rand = random.Random()
+
+    for _ in range(trials):
+        x = rand.uniform(-1, 1)
+        y = rand.uniform(-1, 1)
+
+        if x * x + y * y <= 1:
+            Ncirc += 1
+
+    return 4.0 * (Ncirc / trials)
+
+
+@timer()
+def pi(trials: int, threads: int) -> float:
+    with ThreadPoolExecutor() as pool:
+        futures = pool.map(pi_each, [trials // threads] * threads)
+        return statistics.mean(futures)
+
+
+print(f"{pi(10_000_000, 10)=}")