misc (#528)

Author: jstac

lectures/jax_intro.md

@@ -645,20 +645,15 @@ efficient machine code that varies with both task size and hardware.
 We saw the power of JAX's JIT compiler combined with parallel hardware when we
 {ref}`above <jax_speed>`, when we applied `cos` to a large array.
 
-Let's try the same thing with a more complex function.
-
-
-### Evaluating a more complicated function
-
-Consider the function
+Let's try the same thing with a more complex function:
 
 ```{code-cell}
 def f(x):
     y = np.cos(2 * x**2) + np.sqrt(np.abs(x)) + 2 * np.sin(x**4) - x**2
     return y
 ```
 
-#### With NumPy
+### With NumPy
 
 We'll try first with NumPy
 
@@ -675,7 +670,7 @@ with qe.Timer():
 
 
 
-#### With JAX
+### With JAX
 
 Now let's try again with JAX.
 
@@ -712,10 +707,10 @@ The outcome is similar to the `cos` example --- JAX is faster, especially on the
 second run after JIT compilation.
 
 However, with JAX, we have another trick up our sleeve --- we can JIT-compile
-the *entire* function, not just individual operations.
+the entire function, not just individual operations.
 
 
-### Compiling the whole function
+### Compiling the Whole Function
 
 The JAX just-in-time (JIT) compiler can accelerate execution within functions by fusing array
 operations into a single optimized kernel.

lectures/numba.md

@@ -124,7 +124,7 @@ n = 10_000_000
 
 with qe.Timer() as timer1:
     # Time Python base version
-    x = qm(0.1, int(n))
+    x = qm(0.1, n)
 
 ```
 
@@ -154,7 +154,7 @@ Let's time this new version:
 ```{code-cell} ipython3
 with qe.Timer() as timer2:
     # Time jitted version
-    x = qm_numba(0.1, int(n))
+    x = qm_numba(0.1, n)
 ```
 
 This is a large speed gain.
@@ -167,7 +167,7 @@ function has been compiled and is in memory:
 ```{code-cell} ipython3
 with qe.Timer() as timer3:
     # Second run
-    x = qm_numba(0.1, int(n))
+    x = qm_numba(0.1, n)
 ```
 
 Here's the speed gain