Merge pull request #282 from coding-for-reproducible-research/julia_session_3

Julia session 3

Author: liamjberrisford

_toc.yml

@@ -115,6 +115,11 @@ parts:
                   - file: individual_modules/introduction_to_julia/arrays_and_matrices
                   - file: individual_modules/introduction_to_julia/io
                   - file: individual_modules/introduction_to_julia/package_management
+                  - file: individual_modules/introduction_to_julia/performant_code
+                  - file: individual_modules/introduction_to_julia/project_game_of_life
+                  - file: individual_modules/introduction_to_julia/implemented_game_of_life
+                  - file: individual_modules/introduction_to_julia/visualisation
+                  - file: individual_modules/introduction_to_julia/multi_file_project
           - file: course_homepages/python
             sections:
               - file: individual_modules/section_landing_pages/introduction_to_python

individual_modules/introduction_to_julia/array.bin

@@ -1643,7 +1643,9 @@
     "#### Exercise: assigning to a submatrix\n",
     "\n",
     "Use assignment with appropriate index slicing to change the values of the matrix of ones as follows:\n",
-    "$$\n",
+    "\n",
+    "\n",
+    "$\n",
     "\\begin{bmatrix}\n",
     "    1 & 1 & 1 & 1 \\\\\n",
     "    1 & 1 & 1 & 1 \\\\\n",
@@ -1654,7 +1656,7 @@
     "    0 & 1 & 1 & 0 \\\\\n",
     "    0 & 1 & 1 & 0 \\\\\n",
     "\\end{bmatrix}\n",
-    "$$"
+    "$"
    ]
   },
   {
@@ -2277,15 +2279,15 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Julia 1.10.9",
+   "display_name": "Julia 1.11.5",
    "language": "julia",
-   "name": "julia-1.10"
+   "name": "julia-1.11"
   },
   "language_info": {
    "file_extension": ".jl",
    "mimetype": "application/julia",
    "name": "julia",
-   "version": "1.10.9"
+   "version": "1.11.5"
   }
  },
  "nbformat": 4,

individual_modules/introduction_to_julia/arrays_and_matrices.ipynb

@@ -61,11 +61,9 @@
     "```{admonition} Substep 1 Solution\n",
     ":class: dropdown\n",
     "```Julia\n",
-    "using Random\n",
-    "\n",
     "const N = 100  # grid size\n",
     "# Create a random N×N Matrix of Bool\n",
-    "grid = Matrix{Bool}(rand(Bool, N, N))\n",
+    "grid = rand(Bool, N, N)\n",
     "```\n",
     "```"
    ]
@@ -82,23 +80,18 @@
    },
    "source": [
     "### Substep 2: Neighbor Counting\n",
+    "\n",
     "**Goal:** Count the number of live neighbors surrounding cell `(i, j)` in a finite `Matrix{Bool}` grid.  \n",
     "```{admonition} Substep 2 Solution\n",
     ":class: dropdown\n",
     "```Julia\n",
-    "function count_neighbors_naive(grid::Matrix{Bool}, i::Int, j::Int)::Int\n",
-    "    cnt = 0\n",
-    "    for di in -1:1, dj in -1:1\n",
-    "        if di != 0 || dj != 0\n",
-    "            i2, j2 = i + di, j + dj\n",
-    "            if 1 ≤ i2 ≤ size(grid,1) && 1 ≤ j2 ≤ size(grid,2)\n",
-    "                cnt += grid[i2, j2]\n",
-    "            end\n",
-    "        end\n",
-    "    end\n",
-    "    return cnt\n",
+    "function count_alive_neighbours(grid::Matrix{Bool}, i::Int, j::Int)::Int\n",
+    "    subset_i = max(1, i - 1):min(size(grid, 1), i + 1)\n",
+    "    subset_j = max(1, j - 1):min(size(grid, 2), j + 1)\n",
+    "    return sum(grid[subset_i, subset_j]) - grid[i, j]  # don't count subject cell itself\n",
     "end\n",
     "```\n",
+    "How do you think this could be made more efficient?\n",
     "```"
    ]
   },
@@ -113,22 +106,38 @@
     "tags": []
    },
    "source": [
-    "### Substep 3: Compute Next State Naïvely\n",
+    "### Substep 3: Compute Next State\n",
+    "\n",
     "**Goal:** Compute and return the next generation of the Game of Life grid by applying Conway’s rules, using a fresh `Matrix{Bool}` for the updated state.  \n",
     "```{admonition} Substep 3 Solution\n",
     ":class: dropdown\n",
     "```Julia\n",
-    "function next_state_naive(grid::Matrix{Bool})::Matrix{Bool}\n",
+    "function next_state(grid::Matrix{Bool})\n",
+    "    # Get grid dimensions: N1 rows, N2 columns\n",
     "    N1, N2 = size(grid)\n",
+    "\n",
+    "    # Pre-allocate a new grid of the same size, initially all false (dead)\n",
     "    newgrid = falses(N1, N2)\n",
+    "\n",
+    "    # Loop over every cell position (i, j)\n",
     "    for i in 1:N1, j in 1:N2\n",
-    "        cnt = count_neighbors_naive(grid, i, j)\n",
+    "        # Count the live neighbors around (i, j)\n",
+    "        cnt = count_alive_neighbours(grid, i, j)\n",
+    "\n",
+    "\n",
+    "        # Apply the Game of Life rules:\n",
+    "        # - A live cell stays alive if it has 2 or 3 neighbors.\n",
+    "        # - A dead cell becomes alive if it has exactly 3 neighbors.\n",
+    "        # Otherwise it remains or becomes dead.\n",
     "        newgrid[i,j] = (grid[i,j] && (cnt == 2 || cnt == 3)) ||\n",
     "                       (!grid[i,j] && cnt == 3)\n",
     "    end\n",
+    "\n",
+    "    # Return the updated grid for the next generation\n",
     "    return newgrid\n",
     "end\n",
     "```\n",
+    "Are there any opportunities for a boost in performance?\n",
     "```"
    ]
   },
@@ -143,32 +152,101 @@
     "tags": []
    },
    "source": [
-    "### Substep 4: Run Simulation and Visualise\n",
-    "**Goal:** Animate the evolution of the Game of Life grid over a given number of steps and save the result as a GIF using Plots.  \n",
+    "### Substep 4: Run Simulation\n",
+    "\n",
+    "**Goal:** Simulate the Game of Life for a given number of steps.  \n",
     "\n",
     "```{admonition} Substep 4 Solution\n",
     ":class: dropdown\n",
     "```Julia\n",
-    "using Plots\n",
+    "function simulate(initial_grid::Matrix{Bool}, steps::Int)\n",
+    "    # Get grid dimensions\n",
+    "    N1, N2 = size(initial_grid)\n",
     "\n",
-    "function run_naive_simulation(grid::Matrix{Bool}, steps::Int)\n",
-    "    anim = @animate for _ in 1:steps\n",
-    "        grid = next_state_naive(grid)\n",
+    "    # Make 3D array with time along the third axis.\n",
+    "    # Starts with only a single time index corresponding to initial\n",
+    "    # grid.\n",
+    "    simulations = reshape(initial_grid, N1, N2, 1)\n",
+    "    \n",
+    "    for step in 1:steps\n",
+    "        # Current latest generation\n",
+    "        current = simulations[:, :, end]\n",
+    "        \n",
+    "        # Update simulations with next generation\n",
+    "        next_gen = next_state(current)\n",
+    "        simulations = cat(simulations, next_gen; dims=3)\n",
+    "    end\n",
+    "    \n",
+    "    return simulations\n",
+    "end\n",
+    "```\n",
+    "How do you think this could be made more performant?\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "27592a70-12b5-4466-b832-1d70d94cf0c4",
+   "metadata": {},
+   "source": [
+    "### Substep 5: Visualize\n",
+    "\n",
+    "**Goal:** Animate the evolution of the Game of Life grid and save the result as a GIF using `Plots`. \n",
+    "\n",
+    "```{admonition} Substep 5 Solution\n",
+    ":class: dropdown\n",
+    "```Julia\n",
+    "function visualize_simulations(\n",
+    "        simulations::Array{Bool, 3};\n",
+    "        print_interval_percent::Int=10\n",
+    ")\n",
+    "    # Compute how many steps correspond to one print interval:\n",
+    "    # at least 1, scaled by the given percentage of total steps\n",
+    "    n_steps = size(simulations, 3)\n",
+    "    step_interval = max(1, floor(Int, n_steps * print_interval_percent / 100))\n",
+    "\n",
+    "    t_start = time()\n",
+    "    anim = @animate for step in axes(simulations, 3)\n",
+    "        # If we've reached a print interval, output progress stats\n",
+    "        if step % step_interval == 0\n",
+    "            pct     = step / n_steps * 100\n",
+    "            elapsed = time() - t_start\n",
+    "            avg     = elapsed / step\n",
+    "            remain  = avg * (n_steps - step)\n",
+    "            @printf(\"Progress: %3.0f%% | Elapsed: %5.1fs | Remaining: %5.1fs\\n\",\n",
+    "                    pct, elapsed, remain)\n",
+    "        end\n",
+    "\n",
+    "        # Generate a heatmap frame for the current grid state\n",
     "        heatmap(\n",
-    "            grid;\n",
-    "            color = :grays, \n",
-    "            axis = false, \n",
+    "            view(simulations, :, :, step);\n",
+    "            color = :grays,\n",
+    "            axis = false,\n",
     "            legend = false,\n",
     "            framestyle = :none,\n",
     "            aspect_ratio = 1\n",
     "        )\n",
     "    end\n",
-    "    gif(anim, \"life_naive.gif\"; fps = 10)\n",
-    "    println(\"Saved naive animation to life_naive.gif\")\n",
-    "end\n",
+    "    \n",
+    "    # Ensure the “data” directory exists\n",
+    "    mkpath(\"data\")\n",
     "\n",
-    "# Example usage:\n",
-    "run_naive_simulation(grid, 100)\n",
+    "    # Write the animation to GIF at 10 frames per second\n",
+    "    gif(anim, \"data/life_naive.gif\"; fps = 10)\n",
+    "    println(\"Saved animation to data/life_naive.gif\")\n",
+    "    \n",
+    "    # Detect if running inside a Jupyter notebook\n",
+    "    in_notebook = isdefined(Main, :IJulia) && IJulia.inited\n",
+    " \n",
+    "    if in_notebook\n",
+    "        # Display the GIF inline in the notebook\n",
+    "        display(\"image/gif\", read(\"data/life_naive.gif\"))\n",
+    "    else\n",
+    "        # Otherwise, instruct the user to open the files manually\n",
+    "        println(\"Not running in a notebook.\")\n",
+    "        println(\"Open `data/life_naive.gif` in your OS image viewer to see the results.\")\n",
+    "    end\n",
+    "end\n",
     "```\n",
     "```"
    ]
@@ -206,14 +284,21 @@
     "### Formatted Output with `Printf`\n",
     "\n",
     "**Module**: `using Printf`\n",
+    "\n",
     "**Macro**: `@printf` for C-style formatted printing to `STDOUT`.\n",
-    "`@printf(\"Progress: %3.0f%% | Elapsed: %5.1fs | Remaining: %5.1fs\\n\",\n",
-    "        pct, elapsed, remain)`\n",
+    "\n",
+    "````julia\n",
+    "@printf(\"Progress: %3.0f%% | Elapsed: %5.1fs | Remaining: %5.1fs\\n\",\n",
+    "        pct, elapsed, remain)\n",
+    "````\n",
     "```\n",
     "\n",
     "```{admonition} Hint 2 \n",
     ":class: dropdown\n",
-    "### Animations with `Plots.jl` \n",
+    "### Animations with `Plots.jl`\n",
+    "\n",
+    "**Module**: `using Plots`\n",
+    "\n",
     "**Macro**: `@animate` collects plot frames in a loop, which can then be exported with `gif(anim, filepath; fps=10)`.\n",
     "\n",
     "````julia \n",
@@ -223,27 +308,19 @@
     "````\n",
     "```\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c7ad76a0-fb5c-4a87-ade8-1690e2e1f61b",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Julia 1.11.5",
+   "display_name": "Julia 1.10.9",
    "language": "julia",
-   "name": "julia-1.11"
+   "name": "julia-1.10"
   },
   "language_info": {
    "file_extension": ".jl",
    "mimetype": "application/julia",
    "name": "julia",
-   "version": "1.11.5"
+   "version": "1.10.9"
   }
  },
  "nbformat": 4,