From ba2847e374f98ef4bfb9e3f17691067ae2a4b539 Mon Sep 17 00:00:00 2001
From: Robert Lanzafame <R.C.Lanzafame@tudelft.nl>
Date: Fri, 4 Oct 2024 16:21:47 +0200
Subject: [PATCH] PA 1.6 prep
---
content/Week_1_6/PA/PA_1_6_solution.ipynb | 1312 +++++++++++++++++++++
content/Week_1_6/PA/README.md | 40 +
2 files changed, 1352 insertions(+)
create mode 100644 content/Week_1_6/PA/PA_1_6_solution.ipynb
create mode 100644 content/Week_1_6/PA/README.md
diff --git a/content/Week_1_6/PA/PA_1_6_solution.ipynb b/content/Week_1_6/PA/PA_1_6_solution.ipynb
new file mode 100644
index 00000000..b600814a
--- /dev/null
+++ b/content/Week_1_6/PA/PA_1_6_solution.ipynb
@@ -0,0 +1,1312 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "d14e9d93",
+ "metadata": {},
+ "source": [
+ "# PA 1.6: Boxes and Bugs\n",
+ "\n",
+ "<h1 style=\"position: absolute; display: flex; flex-grow: 0; flex-shrink: 0; flex-direction: row-reverse; top: 60px;right: 30px; margin: 0; border: 0\">\n",
+ " <style>\n",
+ " .markdown {width:100%; position: relative}\n",
+ " article { position: relative }\n",
+ " </style>\n",
+ " <img src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/tu-logo/TU_P1_full-color.png\" style=\"width:100px; height: auto; margin: 0\" />\n",
+ " <img src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/mude-logo/MUDE_Logo-small.png\" style=\"width:100px; height: auto; margin: 0\" />\n",
+ "</h1>\n",
+ "<h2 style=\"height: 10px\">\n",
+ "</h2>\n",
+ "\n",
+ "*[CEGM1000 MUDE](http://mude.citg.tudelft.nl/): Week 1.6. Due: before Friday, Oct 4, 2024.*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f5a4caf7",
+ "metadata": {},
+ "source": [
+ "The purpose of this notebook is to introduce a few useful Python topics:\n",
+ "\n",
+ "1. assert statements\n",
+ "2. list comprehension\n",
+ "3. plt.bar()\n",
+ "4. including a figure in a Markdown document\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "7affbc76",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on _ArrayFunctionDispatcher in module numpy:\n",
+ "\n",
+ "fill_diagonal(a, val, wrap=False)\n",
+ " Fill the main diagonal of the given array of any dimensionality.\n",
+ "\n",
+ " For an array `a` with ``a.ndim >= 2``, the diagonal is the list of\n",
+ " locations with indices ``a[i, ..., i]`` all identical. This function\n",
+ " modifies the input array in-place, it does not return a value.\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " a : array, at least 2-D.\n",
+ " Array whose diagonal is to be filled, it gets modified in-place.\n",
+ "\n",
+ " val : scalar or array_like\n",
+ " Value(s) to write on the diagonal. If `val` is scalar, the value is\n",
+ " written along the diagonal. If array-like, the flattened `val` is\n",
+ " written along the diagonal, repeating if necessary to fill all\n",
+ " diagonal entries.\n",
+ "\n",
+ " wrap : bool\n",
+ " For tall matrices in NumPy version up to 1.6.2, the\n",
+ " diagonal \"wrapped\" after N columns. You can have this behavior\n",
+ " with this option. This affects only tall matrices.\n",
+ "\n",
+ " See also\n",
+ " --------\n",
+ " diag_indices, diag_indices_from\n",
+ "\n",
+ " Notes\n",
+ " -----\n",
+ " .. versionadded:: 1.4.0\n",
+ "\n",
+ " This functionality can be obtained via `diag_indices`, but internally\n",
+ " this version uses a much faster implementation that never constructs the\n",
+ " indices and uses simple slicing.\n",
+ "\n",
+ " Examples\n",
+ " --------\n",
+ " >>> a = np.zeros((3, 3), int)\n",
+ " >>> np.fill_diagonal(a, 5)\n",
+ " >>> a\n",
+ " array([[5, 0, 0],\n",
+ " [0, 5, 0],\n",
+ " [0, 0, 5]])\n",
+ "\n",
+ " The same function can operate on a 4-D array:\n",
+ "\n",
+ " >>> a = np.zeros((3, 3, 3, 3), int)\n",
+ " >>> np.fill_diagonal(a, 4)\n",
+ "\n",
+ " We only show a few blocks for clarity:\n",
+ "\n",
+ " >>> a[0, 0]\n",
+ " array([[4, 0, 0],\n",
+ " [0, 0, 0],\n",
+ " [0, 0, 0]])\n",
+ " >>> a[1, 1]\n",
+ " array([[0, 0, 0],\n",
+ " [0, 4, 0],\n",
+ " [0, 0, 0]])\n",
+ " >>> a[2, 2]\n",
+ " array([[0, 0, 0],\n",
+ " [0, 0, 0],\n",
+ " [0, 0, 4]])\n",
+ "\n",
+ " The wrap option affects only tall matrices:\n",
+ "\n",
+ " >>> # tall matrices no wrap\n",
+ " >>> a = np.zeros((5, 3), int)\n",
+ " >>> np.fill_diagonal(a, 4)\n",
+ " >>> a\n",
+ " array([[4, 0, 0],\n",
+ " [0, 4, 0],\n",
+ " [0, 0, 4],\n",
+ " [0, 0, 0],\n",
+ " [0, 0, 0]])\n",
+ "\n",
+ " >>> # tall matrices wrap\n",
+ " >>> a = np.zeros((5, 3), int)\n",
+ " >>> np.fill_diagonal(a, 4, wrap=True)\n",
+ " >>> a\n",
+ " array([[4, 0, 0],\n",
+ " [0, 4, 0],\n",
+ " [0, 0, 4],\n",
+ " [0, 0, 0],\n",
+ " [4, 0, 0]])\n",
+ "\n",
+ " >>> # wide matrices\n",
+ " >>> a = np.zeros((3, 5), int)\n",
+ " >>> np.fill_diagonal(a, 4, wrap=True)\n",
+ " >>> a\n",
+ " array([[4, 0, 0, 0, 0],\n",
+ " [0, 4, 0, 0, 0],\n",
+ " [0, 0, 4, 0, 0]])\n",
+ "\n",
+ " The anti-diagonal can be filled by reversing the order of elements\n",
+ " using either `numpy.flipud` or `numpy.fliplr`.\n",
+ "\n",
+ " >>> a = np.zeros((3, 3), int);\n",
+ " >>> np.fill_diagonal(np.fliplr(a), [1,2,3]) # Horizontal flip\n",
+ " >>> a\n",
+ " array([[0, 0, 1],\n",
+ " [0, 2, 0],\n",
+ " [3, 0, 0]])\n",
+ " >>> np.fill_diagonal(np.flipud(a), [1,2,3]) # Vertical flip\n",
+ " >>> a\n",
+ " array([[0, 0, 3],\n",
+ " [0, 2, 0],\n",
+ " [1, 0, 0]])\n",
+ "\n",
+ " Note that the order in which the diagonal is filled varies depending\n",
+ " on the flip function.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(np.fill_diagonal)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "342563b8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on function matshow in module matplotlib.pyplot:\n",
+ "\n",
+ "matshow(A: 'ArrayLike', fignum: 'None | int' = None, **kwargs) -> 'AxesImage'\n",
+ " Display a 2D array as a matrix in a new figure window.\n",
+ "\n",
+ " The origin is set at the upper left hand corner.\n",
+ " The indexing is ``(row, column)`` so that the first index runs vertically\n",
+ " and the second index runs horizontally in the figure:\n",
+ "\n",
+ " .. code-block:: none\n",
+ "\n",
+ " A[0, 0] ⋯ A[0, M-1]\n",
+ " â‹® â‹®\n",
+ " A[N-1, 0] ⋯ A[N-1, M-1]\n",
+ "\n",
+ " The aspect ratio of the figure window is that of the array,\n",
+ " unless this would make an excessively short or narrow figure.\n",
+ "\n",
+ " Tick labels for the xaxis are placed on top.\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " A : 2D array-like\n",
+ " The matrix to be displayed.\n",
+ "\n",
+ " fignum : None or int\n",
+ " If *None*, create a new, appropriately sized figure window.\n",
+ "\n",
+ " If 0, use the current Axes (creating one if there is none, without ever\n",
+ " adjusting the figure size).\n",
+ "\n",
+ " Otherwise, create a new Axes on the figure with the given number\n",
+ " (creating it at the appropriate size if it does not exist, but not\n",
+ " adjusting the figure size otherwise). Note that this will be drawn on\n",
+ " top of any preexisting Axes on the figure.\n",
+ "\n",
+ " Returns\n",
+ " -------\n",
+ " `~matplotlib.image.AxesImage`\n",
+ "\n",
+ " Other Parameters\n",
+ " ----------------\n",
+ " **kwargs : `~matplotlib.axes.Axes.imshow` arguments\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(plt.matshow)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5c2e0c3d",
+ "metadata": {},
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "646aeb89",
+ "metadata": {},
+ "source": [
+ "## Topic 1: Visualizing a Matrix\n",
+ "\n",
+ "For many problems in numerical analysis we discretize time and space into small pieces and make a large number of small calculations repeatedly. Although our goal is to solve non-linear equations, this is much easier if we can convert the problem into a system of linear equations. Then we can solve with matrices!\n",
+ "\n",
+ "Often we need to construct the matrices ourselves, or verify that the contents are implemented correctly. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cdf73279",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 1.1:</b> \n",
+ "Use Numpy to construct a 5x5 matrix where the diagonal contains value 5, the corners contain value 3 and every other element is a zero.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "id": "b927ac75",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[3. 0. 0. 0. 3.]\n",
+ " [0. 5. 0. 0. 0.]\n",
+ " [0. 0. 5. 0. 0.]\n",
+ " [0. 0. 0. 5. 0.]\n",
+ " [3. 0. 0. 0. 3.]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "A = np.zeros((5,5))\n",
+ "for i in range(5):\n",
+ " A[i, i] = 5\n",
+ "A[0, 0] = 3\n",
+ "A[-1, -1] = 3\n",
+ "A[0, -1] = 3\n",
+ "A[-1, 0] = 3\n",
+ "print(A)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "913ad7a6",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 1.2:</b> \n",
+ "Use <code>plt.matshow()</code> to visualize the matrix. Confirm that you defined A correctly.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "id": "fa47e06f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 480x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.matshow(A)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ec47c730",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 1.2:</b> \n",
+ "Use <code>np.fill_diagonal()</code> to fill the diagonal of a matrix B, then set the corner values to make it equivalent to A, checking that it was done properly with an assert statement.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "0e2d7682",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "-2.066666666666667\n",
+ "[[-2.06666667 1. 0. 0. ]\n",
+ " [ 1. -2.06666667 1. 0. ]\n",
+ " [ 0. 1. -2.06666667 1. ]\n",
+ " [ 0. 0. 1. -2.06666667]]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 480x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ " \n",
+ " \n",
+ "hc = 40\n",
+ "P = 0.016\n",
+ "k = 240\n",
+ "Ac = 1.6e-5\n",
+ "h=0.02\n",
+ "Ts = 293\n",
+ "beta = hc*P/(k*Ac)\n",
+ "matrix_element = -(2+h**2*beta)\n",
+ "print(matrix_element)\n",
+ "b_element = -h**2*beta*Ts\n",
+ " \n",
+ "# grid creation\n",
+ "x = np.arange(0,0.1+h,h)\n",
+ "T = np.zeros(x.shape)\n",
+ " \n",
+ "# boundary conditions\n",
+ "T[0] = 473\n",
+ "T[-1] = 293\n",
+ " \n",
+ "# Building matrix A\n",
+ "A = np.zeros((len(x)-2,len(x)-2))\n",
+ "np.fill_diagonal(A, matrix_element)\n",
+ "A[np.arange(3), np.arange(1, 4)] = 1 # Upper diagonal\n",
+ "A[np.arange(1, 4), np.arange(3)] = 1 # Lower diagonal\n",
+ " \n",
+ "b = np.array([ b_element - T[0] , b_element, b_element, b_element - T[-1]])\n",
+ " \n",
+ " \n",
+ "A_inv = np.linalg.inv(A)\n",
+ "T[1:-1] = A_inv @ b\n",
+ " \n",
+ "print(A)\n",
+ "plt.matshow(A);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a0330b70",
+ "metadata": {},
+ "source": [
+ "## Topic 1: Assert Statements\n",
+ "\n",
+ "Assert s"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2995706",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 1.1:</b> \n",
+ "Execute the cell below and observe the error. Note that it very specifically is an <code>AssertionError</code>.\n",
+ "\n",
+ "See if you can fix the code to prevent the error from occurring.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "646545ae",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'matrix_element' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[1;32mIn[4], line 4\u001b[0m\n\u001b[0;32m 1\u001b[0m x \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m])\n\u001b[0;32m 3\u001b[0m A \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros((\u001b[38;5;28mlen\u001b[39m(x)\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m,\u001b[38;5;28mlen\u001b[39m(x)\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m))\n\u001b[1;32m----> 4\u001b[0m np\u001b[38;5;241m.\u001b[39mfill_diagonal(A, matrix_element)\n\u001b[0;32m 5\u001b[0m A[np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m3\u001b[39m), np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m)] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;66;03m# Upper diagonal\u001b[39;00m\n\u001b[0;32m 6\u001b[0m A[np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m), np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m3\u001b[39m)] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
+ "\u001b[1;31mNameError\u001b[0m: name 'matrix_element' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "x = np.array([1, 2, 3, 4, 5])\n",
+ "\n",
+ "A = np.zeros((len(x)-2,len(x)-2))\n",
+ "np.fill_diagonal(A, matrix_element)\n",
+ "A[np.arange(3), np.arange(1, 4)] = 1 # Upper diagonal\n",
+ "A[np.arange(1, 4), np.arange(3)] = 1 # Lower diagonal"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "57973878",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 1.2:</b> \n",
+ "Now try fixing the cell below by 1) adding your own error message (see Case 2 above), and 2) forcing the assert statement to fail. Confirm that you can see error message in the error report.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "3c275192",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# y = 0\n",
+ "# assert y != 1, YOUR_MESSAGE_HERE\n",
+ "\n",
+ "# SOLUTION\n",
+ "y = 0\n",
+ "assert y != 1, \"y should not be 1 but it is\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "30ca5166",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 1.3:</b> \n",
+ "Explore assert statements by writing your own. Experiment with different data types (e.g., strings, floats, arrays, lists) and use different logical statements from the list above.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "27fa2738",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# YOUR_CODE_HERE"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "56a7f3a3",
+ "metadata": {},
+ "source": [
+ "### Summary of Asserts\n",
+ "\n",
+ "You are now an expert on `assert` statements. Remember these key points:\n",
+ "\n",
+ "- an assert statement answers a true/false question; it will will cause an error if false and do nothing if true\n",
+ "- the syntax is `assert <logical_statement>`\n",
+ "- you can easily customize the error message with the syntax `assert <logical_argument>, 'my error message'`\n",
+ "- the `<logical_statement>` must be a Boolean result"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db9ff6b8",
+ "metadata": {},
+ "source": [
+ "## Part 2: List Comprehension\n",
+ "\n",
+ "List and dictionary *comprehensions* are elegant constructs in Python that allow you to manipulate Python objects in a very compact and efficient way. You can think of them as writing a `for` loop in a single line. Here is the syntax:\n",
+ "\n",
+ "```\n",
+ "[<DO_SOMETHING> for <ITEM> in <ITERABLE>]\n",
+ "```\n",
+ "\n",
+ "Note the following key elements:\n",
+ "- the list comprehension is enclosed in list brackets: `[ ... ]`\n",
+ "- `<DO_SOMETHING>` is any Python expression (for example, `print()` or `x**2`) \n",
+ "- `<ITEM>` is generally a (temporary) variable that is used in the expression `<DO_SOMETHING>` and represents all of the \"items\" in `<ITERABLE>`\n",
+ "- `<ITERABLE>` is an _iterable_ object. Don't worry about what this is, exactly (we will study it more later).\n",
+ "\n",
+ "For our purposes, it is enough to consider the following _iterables_:\n",
+ "- lists (e.g., `[1, 2, 3]`)\n",
+ "- ndarrays (Numpy)\n",
+ "- `range()`\n",
+ "- dictionaries\n",
+ "\n",
+ "As with assert statements, the best way to illustrate this is by example."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e759e651",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 2.1:</b> \n",
+ "Read the cell below then execute it to see an example of a \"normal\" for loop that creates a list of squares from 0 to 9.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f50a040b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "squares = []\n",
+ "for i in range(10):\n",
+ " squares.append(i**2)\n",
+ "\n",
+ "print(squares)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2f53396f",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 2.2:</b> \n",
+ "Read the cell below then execute it to see an example of a list comprehension that does the same thing. It's much more compact, right?!\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "da714b14",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "squares = [i ** 2 for i in range(10)]\n",
+ "\n",
+ "print(squares)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "344df335",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 2.3:</b> \n",
+ "Read the cell below then execute it to see an example of a \"normal\" for loop that creates a dictionary that maps numbers to their squares.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "b4be24ab",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
+ ]
+ }
+ ],
+ "source": [
+ "squares_dict = {}\n",
+ "for i in range(10):\n",
+ " squares_dict[i] = i ** 2\n",
+ "\n",
+ "print(squares_dict)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d95bdd5",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 2.4:</b> \n",
+ "Read the cell below then execute it to see an example of a list comprehension that does the same thing. It's much more compact, right?!\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "1dbc3f22",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
+ ]
+ }
+ ],
+ "source": [
+ "squares_dict = {i: i ** 2 for i in range(10)}\n",
+ "\n",
+ "print(squares_dict)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a8687bf1",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 2.5:</b> \n",
+ "Now try it yourself! Create a new list from from the one defined below that has values that are half that of the original.\n",
+ "\n",
+ "<em>Note the use of asserts to make sure your answer is correct!</em>\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "1ca75689",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# my_list = [1, 2, 3, 4, 5]\n",
+ "# new_list = []\n",
+ "# print(new_list)\n",
+ "# assert new_list == [0.5, 1.0, 1.5, 2.0, 2.5], \"new_list values are not half of my_list!\" \n",
+ "\n",
+ "# SOLUTION\n",
+ "my_list = [1, 2, 3, 4, 5]\n",
+ "new_list = [x/2 for x in my_list]\n",
+ "assert new_list == [0.5, 1.0, 1.5, 2.0, 2.5], \"new_list values are not half of my_list!\" "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3e8b83e6",
+ "metadata": {},
+ "source": [
+ "### Summary\n",
+ "\n",
+ "There are several reasons why you should use list comprehension, hopefully you can recognize them from the examples and tasks above:\n",
+ "\n",
+ "- Readability: Comprehensions often turn multiple lines of code into a single, readable line, making the code easier to understand at a glance.\n",
+ "- Efficiency: They are generally faster because they are optimized in the Python interpreter.\n",
+ "- Simplicity: Reduces the need for loop control variables and indexing, making the code simpler.\n",
+ "\n",
+ "Sometimes the hardest thing to remember is the order and syntax. The following list comprehension uses obvious variable names to illustrate it (assuming you have an object with \"stuff\" in it, for example, `objects = [1, 2, 3]`); if you can remember this, you can remember list comprehensions!\n",
+ "\n",
+ "```\n",
+ "[print(object) for object in objects]\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "16632cc2",
+ "metadata": {},
+ "source": [
+ "## The `plt.bar()` Method\n",
+ "\n",
+ "At this point we have created many figures in MUDE assignments using a method from the Matplotlib plotting library: `plt.plot()`. This is our \"bread and butter\" plot because it is so easy to plot lines, data, scatter plots, etc. However, there are _many_ more types of plots available in Matplotlib. Today we will try `bar()`, which, as you can imagine, creates bar plots.\n",
+ "\n",
+ "First take a look at the documentation and see if you can figure out how it works."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1e9690a5",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 3.1:</b> \n",
+ "Run the cell below and read the docstring for the method. Can you determine the minimum type of inputs required, and what they will do?\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "4ce7aa15",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on function bar in module matplotlib.pyplot:\n",
+ "\n",
+ "bar(x: 'float | ArrayLike', height: 'float | ArrayLike', width: 'float | ArrayLike' = 0.8, bottom: 'float | ArrayLike | None' = None, *, align: \"Literal['center', 'edge']\" = 'center', data=None, **kwargs) -> 'BarContainer'\n",
+ " Make a bar plot.\n",
+ "\n",
+ " The bars are positioned at *x* with the given *align*\\ment. Their\n",
+ " dimensions are given by *height* and *width*. The vertical baseline\n",
+ " is *bottom* (default 0).\n",
+ "\n",
+ " Many parameters can take either a single value applying to all bars\n",
+ " or a sequence of values, one for each bar.\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " x : float or array-like\n",
+ " The x coordinates of the bars. See also *align* for the\n",
+ " alignment of the bars to the coordinates.\n",
+ "\n",
+ " height : float or array-like\n",
+ " The height(s) of the bars.\n",
+ "\n",
+ " Note that if *bottom* has units (e.g. datetime), *height* should be in\n",
+ " units that are a difference from the value of *bottom* (e.g. timedelta).\n",
+ "\n",
+ " width : float or array-like, default: 0.8\n",
+ " The width(s) of the bars.\n",
+ "\n",
+ " Note that if *x* has units (e.g. datetime), then *width* should be in\n",
+ " units that are a difference (e.g. timedelta) around the *x* values.\n",
+ "\n",
+ " bottom : float or array-like, default: 0\n",
+ " The y coordinate(s) of the bottom side(s) of the bars.\n",
+ "\n",
+ " Note that if *bottom* has units, then the y-axis will get a Locator and\n",
+ " Formatter appropriate for the units (e.g. dates, or categorical).\n",
+ "\n",
+ " align : {'center', 'edge'}, default: 'center'\n",
+ " Alignment of the bars to the *x* coordinates:\n",
+ "\n",
+ " - 'center': Center the base on the *x* positions.\n",
+ " - 'edge': Align the left edges of the bars with the *x* positions.\n",
+ "\n",
+ " To align the bars on the right edge pass a negative *width* and\n",
+ " ``align='edge'``.\n",
+ "\n",
+ " Returns\n",
+ " -------\n",
+ " `.BarContainer`\n",
+ " Container with all the bars and optionally errorbars.\n",
+ "\n",
+ " Other Parameters\n",
+ " ----------------\n",
+ " color : :mpltype:`color` or list of :mpltype:`color`, optional\n",
+ " The colors of the bar faces.\n",
+ "\n",
+ " edgecolor : :mpltype:`color` or list of :mpltype:`color`, optional\n",
+ " The colors of the bar edges.\n",
+ "\n",
+ " linewidth : float or array-like, optional\n",
+ " Width of the bar edge(s). If 0, don't draw edges.\n",
+ "\n",
+ " tick_label : str or list of str, optional\n",
+ " The tick labels of the bars.\n",
+ " Default: None (Use default numeric labels.)\n",
+ "\n",
+ " label : str or list of str, optional\n",
+ " A single label is attached to the resulting `.BarContainer` as a\n",
+ " label for the whole dataset.\n",
+ " If a list is provided, it must be the same length as *x* and\n",
+ " labels the individual bars. Repeated labels are not de-duplicated\n",
+ " and will cause repeated label entries, so this is best used when\n",
+ " bars also differ in style (e.g., by passing a list to *color*.)\n",
+ "\n",
+ " xerr, yerr : float or array-like of shape(N,) or shape(2, N), optional\n",
+ " If not *None*, add horizontal / vertical errorbars to the bar tips.\n",
+ " The values are +/- sizes relative to the data:\n",
+ "\n",
+ " - scalar: symmetric +/- values for all bars\n",
+ " - shape(N,): symmetric +/- values for each bar\n",
+ " - shape(2, N): Separate - and + values for each bar. First row\n",
+ " contains the lower errors, the second row contains the upper\n",
+ " errors.\n",
+ " - *None*: No errorbar. (Default)\n",
+ "\n",
+ " See :doc:`/gallery/statistics/errorbar_features` for an example on\n",
+ " the usage of *xerr* and *yerr*.\n",
+ "\n",
+ " ecolor : :mpltype:`color` or list of :mpltype:`color`, default: 'black'\n",
+ " The line color of the errorbars.\n",
+ "\n",
+ " capsize : float, default: :rc:`errorbar.capsize`\n",
+ " The length of the error bar caps in points.\n",
+ "\n",
+ " error_kw : dict, optional\n",
+ " Dictionary of keyword arguments to be passed to the\n",
+ " `~.Axes.errorbar` method. Values of *ecolor* or *capsize* defined\n",
+ " here take precedence over the independent keyword arguments.\n",
+ "\n",
+ " log : bool, default: False\n",
+ " If *True*, set the y-axis to be log scale.\n",
+ "\n",
+ " data : indexable object, optional\n",
+ " If given, all parameters also accept a string ``s``, which is\n",
+ " interpreted as ``data[s]`` (unless this raises an exception).\n",
+ "\n",
+ " **kwargs : `.Rectangle` properties\n",
+ "\n",
+ " Properties:\n",
+ " agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array and two offsets from the bottom left corner of the image\n",
+ " alpha: scalar or None\n",
+ " angle: unknown\n",
+ " animated: bool\n",
+ " antialiased or aa: bool or None\n",
+ " bounds: (left, bottom, width, height)\n",
+ " capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
+ " clip_box: `~matplotlib.transforms.BboxBase` or None\n",
+ " clip_on: bool\n",
+ " clip_path: Patch or (Path, Transform) or None\n",
+ " color: :mpltype:`color`\n",
+ " edgecolor or ec: :mpltype:`color` or None\n",
+ " facecolor or fc: :mpltype:`color` or None\n",
+ " figure: `~matplotlib.figure.Figure`\n",
+ " fill: bool\n",
+ " gid: str\n",
+ " hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
+ " height: unknown\n",
+ " in_layout: bool\n",
+ " joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
+ " label: object\n",
+ " linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
+ " linewidth or lw: float or None\n",
+ " mouseover: bool\n",
+ " path_effects: list of `.AbstractPathEffect`\n",
+ " picker: None or bool or float or callable\n",
+ " rasterized: bool\n",
+ " sketch_params: (scale: float, length: float, randomness: float)\n",
+ " snap: bool or None\n",
+ " transform: `~matplotlib.transforms.Transform`\n",
+ " url: str\n",
+ " visible: bool\n",
+ " width: unknown\n",
+ " x: unknown\n",
+ " xy: (float, float)\n",
+ " y: unknown\n",
+ " zorder: float\n",
+ "\n",
+ " See Also\n",
+ " --------\n",
+ " barh : Plot a horizontal bar plot.\n",
+ "\n",
+ " Notes\n",
+ " -----\n",
+ "\n",
+ " .. note::\n",
+ "\n",
+ " This is the :ref:`pyplot wrapper <pyplot_interface>` for `.axes.Axes.bar`.\n",
+ "\n",
+ " Stacked bars can be achieved by passing individual *bottom* values per\n",
+ " bar. See :doc:`/gallery/lines_bars_and_markers/bar_stacked`.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "help(plt.bar)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d0c48669",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 3.2:</b> \n",
+ "That's right, it plots a bar chart where the first argument is the x coordinate of the bar and the second argument is the height. Fill in the empty lists below to create a bar plot with any values you like.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "512718a3",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<BarContainer object of 4 artists>"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plt.bar([], [])\n",
+ "\n",
+ "# SOLUTION\n",
+ "plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "82b94893",
+ "metadata": {},
+ "source": [
+ "Pretty easy, right? Let's try to do one more thing with this - suppose we don't like that the _center_ of the bar is over the value we enter. It's easy to change this using a _keyword argument_; these are the input arguments to the function that have the equals sign (e.g., `function(keyword_arg=<xxx>)`). These are optional arguments; they are generally not needed, but can be specified, along with a value, to change the default behavior of the function. For our purposes this week, we will want to change _two_ keyword arguments:\n",
+ "\n",
+ "1. `width`\n",
+ "2. `align`\n",
+ "\n",
+ "Fortunately the `help` function printed out the docstring for `bar()`, which contains all the information you need to figure out what these keyword arguments do and how to use them."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "501c9c7b",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 3.3:</b> \n",
+ "Set the keyword arguments below to make the bars fill up the entire space between each bar (no white space) and to force the <b>left</b> side of the bar to align with the value specified.\n",
+ "\n",
+ "Note the addition of keyword argument <code>edgecolor</code> to make it easier to see the edges of the bar. \n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "id": "6b1fd9c1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<BarContainer object of 4 artists>"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6],\n",
+ "# width=YOUR_CODE_HERE,\n",
+ "# align=YOUR_CODE_HERE,\n",
+ "# edgecolor='black')\n",
+ "\n",
+ "# SOLUTION\n",
+ "plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6],\n",
+ " width=1,\n",
+ " align='edge',\n",
+ " edgecolor='black')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a3cc843c",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 3.4:</b> \n",
+ "Now set the keyword arguments below to make the bars fill up the entire space between each bar (no white space) and to force the <b>right</b> side of the bar to align with the value specified.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "id": "4958e71a",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<BarContainer object of 4 artists>"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6],\n",
+ "# width=YOUR_CODE_HERE,\n",
+ "# align=YOUR_CODE_HERE,\n",
+ "# edgecolor='black')\n",
+ "\n",
+ "# SOLUTION\n",
+ "plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6],\n",
+ " width=-1,\n",
+ " align='edge',\n",
+ " edgecolor='black')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "58811f81",
+ "metadata": {},
+ "source": [
+ "## Topic 4: Exporting a Figure and Including it in a Markdown Notebook\n",
+ "\n",
+ "Now that we can create a wider variety of figures, we should be able to include them in our Reports for communicating the results of our analyses. Here we show you a very simple way to save a figure generated in your notebook, then use Markdown to visualize the figure. Once a figure is made it is easy, use this syntax:\n",
+ "\n",
+ "```\n",
+ "\n",
+ "```\n",
+ "\n",
+ "The label is simply a name that will appear in case the figure fails to load. It can also be read by a website-reading app (for example, then a blind person could understand what the content of the figure may be). Here is an example for what this could look like in practice:\n",
+ "\n",
+ "```\n",
+ "\n",
+ "```\n",
+ "\n",
+ "This is very easy, so once again we lead by example! However, first a couple notes about filepaths.\n",
+ "\n",
+ "### File Paths\n",
+ "\n",
+ "A _file path_ is like an address to a file. There are generally two types, _absolute_ and _relative._ Most of our activities focus on working in a _working directory,_ so we will focus almost entirely on relative paths. The general format is like this:\n",
+ "\n",
+ "```\n",
+ "./subdirectory_1/subdir_2/filename.ext\n",
+ "```\n",
+ "\n",
+ "where:\n",
+ "- the dot `.` indicates one should use the current directory of the file (or the CLI) as the current location (the `.` is like saying \" start _here_\")\n",
+ "- forward slashes `/` separate subdirectories\n",
+ "- the last two words are the file name and extension. For example, common image extensions are `.jpg`, `.png` or `.svg`\n",
+ "- in this example, the image file is stored inside a folder called `subdir_2` which is inside a folder called `subdirectory_1` which is in our working directory.\n",
+ "\n",
+ "As a general rule, **always use forward slashes whenever possible.** Although backward slashes are the default and must be used at times on Windows, they don't work on Mac or Linux systems. This causes problems when sharing code with others running these systems (or when we check your assignments on GitHub!!!). Remember that we try to do things in a way that allows easy collaboration: using approaches that are agnostic of the operating system (i.e., works on all platforms). This is hard to guarantee in practice, but consistently using forward slashes will get us close!\n",
+ "\n",
+ "### Try it out yourself\n",
+ "\n",
+ "We will try this out, but first we need to create a figure! The code below is a quick way of saving a Matplotlib figure as an svg file."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8ca99b68",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 4.1:</b> \n",
+ "Run the cell below to create the svg file. Confirm that it is created successfully by examining your working directory.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "id": "3c82a997",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 800x600 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, ax = plt.subplots(1,1,figsize = (8,6))\n",
+ "plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6])\n",
+ "fig.savefig('my_figure.svg')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3b62b94f",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 4.2:</b> \n",
+ "Now that the image is created, use the Markdown cell below to display it in this notebook.\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c71b287",
+ "metadata": {},
+ "source": [
+ "Use this Markdown cell to try visualizing the figure we just saved using Markdown!\n",
+ "\n",
+ "![a figure]()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "847c2d7e",
+ "metadata": {},
+ "source": [
+ "**SOLUTION**\n",
+ "\n",
+ "```\n",
+ "\n",
+ "````\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "26492dd2",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 4.3:</b> \n",
+ "Test your understanding of relative file paths by moving the csv file to a subdirectory with name <code>figure</code> and getting the following Markdown cell to display the figure.\n",
+ "\n",
+ "<pre>\n",
+ "<code>\n",
+ "\n",
+ "</code>\n",
+ "</pre>\n",
+ "\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b23f5743",
+ "metadata": {},
+ "source": [
+ "** MAKE SURE A FIGURE APPEARS HERE BY MODIFYING THIS MARKDOWN CELL**\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0d7a487d",
+ "metadata": {},
+ "source": [
+ "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+ "<p>\n",
+ "<b>Task 4.4:</b> \n",
+ "Now add the figure to an actual markdown while, specifically <code>myfigure.md</code>. Then visualize to confirm you did it properly (remember to use `CTRL+SHIFT+V` in VSC, the [Markdown All-in-one extension](https://mude.citg.tudelft.nl/2024/book/external/learn-programming/book/install/ide/vsc/extensions.html#markdown-all-in-one))\n",
+ "\n",
+ "</p>\n",
+ "</div>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d191fa12",
+ "metadata": {},
+ "source": [
+ "**End of notebook.**\n",
+ "<h2 style=\"height: 60px\">\n",
+ "</h2>\n",
+ "<h3 style=\"position: absolute; display: flex; flex-grow: 0; flex-shrink: 0; flex-direction: row-reverse; bottom: 60px; right: 50px; margin: 0; border: 0\">\n",
+ " <style>\n",
+ " .markdown {width:100%; position: relative}\n",
+ " article { position: relative }\n",
+ " </style>\n",
+ " <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">\n",
+ " <img alt=\"Creative Commons License\" style=\"border-width:; width:88px; height:auto; padding-top:10px\" src=\"https://i.creativecommons.org/l/by/4.0/88x31.png\" />\n",
+ " </a>\n",
+ " <a rel=\"TU Delft\" href=\"https://www.tudelft.nl/en/ceg\">\n",
+ " <img alt=\"TU Delft\" style=\"border-width:0; width:100px; height:auto; padding-bottom:0px\" src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/tu-logo/TU_P1_full-color.png\" />\n",
+ " </a>\n",
+ " <a rel=\"MUDE\" href=\"http://mude.citg.tudelft.nl/\">\n",
+ " <img alt=\"MUDE\" style=\"border-width:0; width:100px; height:auto; padding-bottom:0px\" src=\"https://gitlab.tudelft.nl/mude/public/-/raw/main/mude-logo/MUDE_Logo-small.png\" />\n",
+ " </a>\n",
+ " \n",
+ "</h3>\n",
+ "<span style=\"font-size: 75%\">\n",
+ "© Copyright 2024 <a rel=\"MUDE\" href=\"http://mude.citg.tudelft.nl/\">MUDE</a> TU Delft. This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">CC BY 4.0 License</a>."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.4"
+ },
+ "widgets": {
+ "application/vnd.jupyter.widget-state+json": {
+ "state": {},
+ "version_major": 2,
+ "version_minor": 0
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/content/Week_1_6/PA/README.md b/content/Week_1_6/PA/README.md
new file mode 100644
index 00000000..1c5034fd
--- /dev/null
+++ b/content/Week_1_6/PA/README.md
@@ -0,0 +1,40 @@
+# PA 1.5: MUDE-git-crossword and Ice prediction
+*[CEGM1000 MUDE](http://mude.citg.tudelft.nl/): Week 1.6. Due: before Friday, October 11th, 2024.*
+
+This PA consists of 4 parts:
+
+1. `PA_1_5_.useful_tricks.ipynb`: a notebook covering a few simple Python topics that are especially useful for the WS and GA assignments this week.
+2. [Programming for Week 1.5](https://mude.citg.tudelft.nl/2024/book/programming/week_1_5.html) (Online Textbook): read this chapter, which covers more Git topics: branching, forking, pull requests and merge conflicts
+3. `crossword.md`: file containing a crossword puzzle, which you will use to work on a separate branch and merge commits into the `main` branch.
+4. `predictions.txt`: a file in a _separate_ repository [github.com/iceclassic/mude-pa-1-5](https://github.com/iceclassic/mude-pa-1-5). where you will contribute a commit from your own fork of the separate repository
+
+Notes:
+- The notebook can be completed independently from the other parts; try to finish complete this before the Wednesday in-class session.
+- This PA actually involves 3 repositories: the one created for this assignment, the ice repository and your own personal fork of the ice repository, which you will create.
+
+## Ice Classic Repo
+
+For Part 4 you will be making a prediction for the 2025 ice classic! The repo is: [github.com/iceclassic/mude-pa-1-5](https://github.com/iceclassic/mude-pa-1-5).
+
+**To add your prediction,** find your GitHub username in the list in `predictions.txt` and enter a prediction in the format `(YYYY-MM-DD HH:MM:SS)` (year,month, day, hour minute, seconds). That's it!
+
+- The repo already contains a figure that displays all of the historic breakup days and times, and the predictions of MUDE students will be added on top. Here is a direct link to the figure: [predictions.svg](https://github.com/iceclassic/test_pa15/blob/main/test.svg).
+- The repo is set up to automatically update the figure every time a commit is made. Note, however that it may take some time before your change is visible, as the instructors must approve the pull requests.
+
+## Grading Criteria
+
+You will pass this PA if:
+1. For the python and markdown topics of this PA.
+ - Your notebook `PA_1_5_useful_tricks.ipynb` runs without errors.
+ - Your repository contains a file `my_figure.svg` located in subdirectory `/figures`
+ - You update the `myfigure.md` file to include a reference to the previous figure.
+2. For the branching part of this PA: you successfully merged a pull request from your own branch.
+3. For the forking part of this PA: You successfully created a pull request to the ice repo with your bet (it should be visible on the [Pull Requests tab of the repo](https://github.com/iceclassic/mude-pa-1-5/pulls)). After your pull request is accepted (this requires some manual actions from your teachers on your pull request) you can confirm that your bet is approved by seeing it in the figure `guesses.svg`.
+
+You can verify that you passed checks 1 and 2 by looking for the green circle in this repository. It runs automatically just like last week when you uploaded your notebook. Check 3 will be done manually by your teachers.
+
+
+**End of file.**
+
+<span style="font-size: 75%">
+© Copyright 2024 <a rel="MUDE" href="http://mude.citg.tudelft.nl/">MUDE</a>, TU Delft. This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by/4.0/">CC BY 4.0 License</a>.
\ No newline at end of file
--
GitLab