intro_exercises3_2020.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "exercises3_2020.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c5M3FWWv4_Gy",
        "colab_type": "text"
      },
      "source": [
        "# Exercises to Lecture 3: Introduction to Python 3.6 \n",
        "By Dr. Anders S. Christensen\n",
        "`anders.christensen @ unibas.ch`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uqr4BO3daWDM",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 3.1: If/Else statments\n",
        "Yesterday, we used if and else statments to check conditions.\n",
        "\n",
        "For example, we can check if a variable `a` is greater 10:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KLJihM7OwzuI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 100\n",
        "\n",
        "if a > 10:\n",
        "  print(\"a is greater than 10\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XTLvKr6ktlWs",
        "colab_type": "text"
      },
      "source": [
        "### Question 3.1.1:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSHNLwhstolg",
        "colab_type": "text"
      },
      "source": [
        "In this exercise, write a function named for example `check_number(n)` which determines whether a number is negative, zero, or positive, and prints the answer.\n",
        "\n",
        "Verify with a couple of cases, that the code yields the correct \n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tPzj356TaWHO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def check_number(n):\n",
        "\n",
        "  # Write the rest of the function\n",
        "\n",
        "\n",
        "\n",
        "# Check the output of the tests below to ensure that your code works\n",
        "check_number(-1000.0)   # Code should print 'negative'\n",
        "check_number(-69.0)     # Code should print 'negative'\n",
        "check_number(0.0)       # Code should print 'zero'\n",
        "check_number(1.0)       # Code should print 'positive'\n",
        "check_number(420.0)     # Code should print 'positive'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OoANtRxkaWKm",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 3.2: When to stop a loop?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-0siAAL0sR0P",
        "colab_type": "text"
      },
      "source": [
        "Sometimes `for`-loops can be terminated before they run to the end of `range()`.\n",
        "\n",
        "In this example we wish to print all numbers where the square is smaller than 42.\n",
        "\n",
        "However, we might not know when to stop the `for` loop beforehand. In this case, we can use `if`/`else` to check when the condition is met, and when it is we can use the `break` statement to stop the `for` loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B999_WtlsR7Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Print all integers that where the square is smaller than 42:\n",
        "\n",
        "# Try all numbers up to 100\n",
        "for i in range(100):\n",
        "\n",
        "  # Check if the square is small enough\n",
        "  if i**2 < 42:\n",
        "    print(i, i**2)\n",
        "\n",
        "  # Stop the loop if the test is False\n",
        "  else:\n",
        "    break"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xs0r3ik8qv4F",
        "colab_type": "text"
      },
      "source": [
        "The so-called \"Basel problem\" in mathematics shows that the reciprocal of the square numbers form a convergent series:\n",
        "\n",
        "\\begin{equation}\n",
        "x=\\sum_{n=1}^\\infty \\frac{1}{n^2}  = \\frac{1}{1^2} + \\frac{1}{2^2} + \\frac{1}{3^2} \\dots = \\frac{\\pi^2}{6}\n",
        "\\end{equation}\n",
        "\n",
        "The problem is named after Leonhard Euler who lived here in in Basel and worked on the problem.\n",
        "\n",
        "\n",
        "The code below uses 10,000 iterations of a `for` loop to calculate the result."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0tLzFKtrxwou",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 0\n",
        "\n",
        "# Do 10000 iterations\n",
        "for i in range(1, 10000):\n",
        "\n",
        "  # Calculate 1/n^2 and add it to x\n",
        "  x = x + 1/i**2\n",
        "\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pgAX-BHKvhVT",
        "colab_type": "text"
      },
      "source": [
        "### Question 3.2.1:\n",
        "\n",
        "\n",
        "\n",
        "As part of his proof, Euler calculated many terms of this series by hand in order to verify his work.\n",
        "\n",
        "The sum of the series is approximately $1.645$. To achieve this accuracy, the numerical calculation of the sum can be stopped when $\\frac{1}{n^2} < 0.001$, long before 10000 terms as in the above example.\n",
        "\n",
        "*    In this question, rewrite the above code for the Basel problem, such that the calculation stops when the $\\frac{1}{n^2}$ terms are smaller than $0.001$. \n",
        "\n",
        "*     **Hint:** Use a `break` statement to stop the for loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XRyRBFhJaWOG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 0\n",
        "\n",
        "for i in range(1, 10000):\n",
        "\n",
        "  # Print the current iteration number\n",
        "  print(i)\n",
        "\n",
        "  ## Insert your own code here to calculate the sum from the Basel probelm\n",
        "\n",
        "\n",
        "print(x)\n",
        "\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lvN7vzKPaWRV",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 3.3: Matrices and Vectors with Numpy\n",
        "\n",
        "In this exercises you'll write some code contatining matrix and vector operations with numpy."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iTaC1T_m3IX8",
        "colab_type": "text"
      },
      "source": [
        "### Question 3.3.1: Matrix-Matrix Product\n",
        "\n",
        "In the code block below, you are give two matrices A ($3\\times4$ matrix), and B ($4\\times 4$ matrix)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5X4eTslFgY3I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "np.random.seed(2089)\n",
        "\n",
        "A = np.random.random(size=(3,4))\n",
        "B = np.random.random(size=(4,4))\n",
        "\n",
        "print(A)\n",
        "print(B)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BvWIrDjuhHjN",
        "colab_type": "text"
      },
      "source": [
        "Use numpy's `np.matmul()` function to calculate the matrix product `C`:\n",
        "\n",
        "\\begin{equation}\n",
        "\\mathbf{C} = \\mathbf{A}\\mathbf{B}\n",
        "\\end{equation}\n",
        "\n",
        "**Hint:** The matrix product is not the *element-wise* product!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rVDdVRJ7aWVC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Calculate the matrix product\n",
        "\n",
        "C = ??? # <--\n",
        "\n",
        "print(C)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-FUmvF4Vhx_H",
        "colab_type": "text"
      },
      "source": [
        "Also answer: what are the dimensions of `C`?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u16W5JLV3K05",
        "colab_type": "text"
      },
      "source": [
        "### Question 3.3.2: Dot products\n",
        "Here you are give two vectors (i.e. 1D Numpy arrays), `p` and `q`:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W-tJQQBojDO4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.random.seed(3001)\n",
        "\n",
        "p = np.random.random(size=(10))\n",
        "q = np.random.random(size=(10))\n",
        "\n",
        "print(p)\n",
        "print(q)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "FPXwcBcpjRZy"
      },
      "source": [
        "Use a Numpy function to calculate the dot product `k`:\n",
        "\n",
        "\\begin{equation}\n",
        "k = \\mathbf{p} \\cdot \\mathbf{q}\n",
        "\\end{equation}\n",
        "\n",
        "**Hint:** The dot product is not the *element-wise* product!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KQG6joGi3K5y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Calculate the dot product, k\n",
        "\n",
        "k = ??? # <--\n",
        "\n",
        "print(k)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "SXMpuoQxiYyJ"
      },
      "source": [
        "Also answer: Is `k` a scalar (a single number), a vector, or a matrix?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jVIK_0T0aWZB",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 3.4: Plotting a histogram\n",
        "The code block below makes some \"fake\" data for the height of 100 people in units of [cm].\n",
        "\n",
        "For now, you will use this to plot a histogram of the data. Before you start Question 3.4.1, make sure to run the code block below and inspect the output (which is a list named `heights` with the heights of 100 people)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h2AecmSkaWdF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "np.random.seed(2021)\n",
        "\n",
        "heights = np.random.normal(loc=170, scale=10, size=100)\n",
        "print(heights)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PtC0zvOpcgHC",
        "colab_type": "text"
      },
      "source": [
        "### Questions 3.4.1:\n",
        "\n",
        "In order to plot a histogram, you can use the function `plt.hist(list)` to make a histogram with matplotlib.pyplot.\n",
        "\n",
        "It works similarly to the `plt.plot()` (lineplots) and `plt.scatter()` (scatterplots), which you have already encountered in these exercises.\n",
        "\n",
        "If you are unsure, use Google or consult the manual for `plt.hist()` here:\n",
        "https://matplotlib.org/3.1.1/gallery/statistics/hist.html\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "POLUQyWgcgM_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Insert the code here to plot a histogram of the list 'heights'\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZRnUZkhhcgVN",
        "colab_type": "text"
      },
      "source": [
        "### Question 3.4.2: Making a better plot\n",
        "\n",
        "Similarly to Question 2.4.2 in the exercises from yesterday, add proper labels to the x- and y- axis to the histogram.\n",
        "\n",
        "***Go back to the code in Questions 3.4.1 and add labels to the plot***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "suplCKfo-B7s",
        "colab_type": "text"
      },
      "source": [
        "### Question 3.4.3: Changing colors\n",
        "\n",
        "Your supervisor/professor only wants red histograms!\n",
        "\n",
        "In this question, use Google, or other resources, to find out how to change the histogram from the default blue color to red color.\n",
        "\n",
        "***Go back to the code in Questions 3.4.1 and change the color to red***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BlkpyJZXdDAB",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 3.5: Matrix multiplication (harder)\n",
        "\n",
        "After doing this exercise, I hope you will appreciate NumPy and numpy arrays.\n",
        "\n",
        "In the example below, there are two random matrices defined, `A` and `B`.\n",
        "\n",
        "The matrix product \n",
        "\\begin{equation}\n",
        "\\mathbf{C} = \\mathbf{A}\\mathbf{B}\n",
        "\\end{equation}\n",
        "is calculated using the `np.matmul()` function:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oxpqVTkAdDEL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "np.random.seed(2021)\n",
        "\n",
        "A = np.random.random(size=(3,5))\n",
        "B = np.random.random(size=(5,4))\n",
        "\n",
        "C = np.matmul(A,B)\n",
        "\n",
        "print(C)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sqimjRE9dDH-",
        "colab_type": "text"
      },
      "source": [
        "### Question 3.5.1:\n",
        "Without NumPy, we would have to write our own code to calculate the matrix multiplication of `A` and `B`.\n",
        "\n",
        "For this, the formula is:\n",
        "\n",
        "\\begin{equation}\n",
        "C_{ik} = \\sum_j A_{ij}B_{jk}\n",
        "\\end{equation}\n",
        "\n",
        "In this question, you have to implement the above equation. That is, calculate the elements of `C` using this summation. \n",
        "\n",
        "Some things to consider:\n",
        "\n",
        "*   Use a triple loop over the indices $i$, $j$, and $k$\n",
        "*   What are the ranges for the indices?\n",
        "*   Use `np.zeros()` to initialize the `C` matrix\n",
        "\n",
        "Print the result and compare to the result in the previous code box to verify that you did it correctly."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vy-VSSmd4KHL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Initialize the array C of the correct size\n",
        "C = np.zeros((3,4))\n",
        "\n",
        "\n",
        "# Code the matrix multiplication below yourself\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# Finally, print C\n",
        "print(C)"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}