Section_06_While_Loop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# While Loop\n",
    "\n",
    "- [Overview](#Overview)\n",
    "- [Framework](#Framework)\n",
    "    - [Boolean Expressions](#Boolean-Expressions)\n",
    "    - [Multiple Conditions](#Multiple-Conditions)\n",
    "- [Additional Examples](#Additional-Examples)\n",
    "- [Growing Lists](#Growing-Lists)\n",
    "- [Recap](#Recap)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "### Example - ``ln(2)`` approximation:\n",
    "- Scribbled in an old book you see:\n",
    "$$ \\ln(2) = \\sum_{n=1}^{\\infty} (-1)^{(n-1)} \\left( \\frac{1}{n} \\right) = 1 − \\frac{1}{2} + \\frac{1}{3} − \\frac{1}{4} + \\frac{1}{5} − \\cdots $$\n",
    "\n",
    "\n",
    "- How many terms are required to approximate $\\ln(2)$?\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Strategies to alternate the sign of terms.\n",
    "\n",
    "\n",
    "- Infinite terms on the computer implies infinite resources.\n",
    "\n",
    "\n",
    "- How well do we want to approximate $\\ln(2)$\n",
    "\n",
    "\n",
    "- How many terms needed to approximate $\\ln(2)$ $\\to$ we don’t necessarily know before hand.\n",
    "\n",
    "\n",
    "- Unknown number of terms (repetitions) $\\to$ `while` loop\n",
    "\n",
    "\n",
    "- `for` loop or `array` only viable if **you** can determine the number of iterations required"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext nbtutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def ln_approx(N):\n",
    "    # sum fixed number of terms with/in an array\n",
    "    i = np.arange(1, N+1, 1)\n",
    "    signs = (-1)**(i - 1)\n",
    "    terms = 1.0 / i\n",
    "    return np.sum(signs * terms)\n",
    "\n",
    "\n",
    "approx = ln_approx(N=10)\n",
    "actual = np.log(2)\n",
    "error = abs(actual - approx)\n",
    "print(\"Approx:\", approx)\n",
    "print(\"Actual:\", actual)\n",
    "print(\"Error:\", error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def ln_approx(N):\n",
    "    # sum fixed number of terms with a for loop\n",
    "    approx = 0\n",
    "    for i in range(1, N+1, 1):\n",
    "        sign = (-1)**(i - 1)\n",
    "        term = 1.0 / i\n",
    "        approx = approx + (sign * term)\n",
    "    return approx\n",
    "\n",
    "\n",
    "approx = ln_approx(N=10)\n",
    "actual = np.log(2)\n",
    "error = abs(actual - approx)\n",
    "print(\"Approx:\", approx)\n",
    "print(\"Actual:\", actual)\n",
    "print(\"Error:\", error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def ln_approx(tol):\n",
    "    # sum unknown number of terms with a while loop\n",
    "    approx = 0\n",
    "    actual = np.log(2)\n",
    "    error = 1\n",
    "    ind = 1\n",
    "\n",
    "    while error > tol:\n",
    "        sign = (-1)**(ind - 1)\n",
    "        term = 1.0 / ind\n",
    "        approx = approx + (sign * term)\n",
    "        error = abs(actual - approx)\n",
    "        ind = ind + 1\n",
    "    return approx\n",
    "\n",
    "\n",
    "actual = np.log(2)\n",
    "approx = ln_approx(tol=1e-2)\n",
    "error = abs(actual - approx)\n",
    "print(\"Approx:\", approx)\n",
    "print(\"Actual:\", actual)\n",
    "print(\"Error:\", error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Framework\n",
    "\n",
    "<img src=\"./figures/while_loop_framework.svg\" alt=\"While Loop Framework\" style=\"height: 400px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- **Used to repeat code an unknown number of times for a known condition**\n",
    "\n",
    "- Executed from top to the bottom of the script\n",
    "\n",
    "- Indentation (white space) of the code tells Python it is part of the while-loop\n",
    "\n",
    "- Condition has to be **True** to **enter** the while-loop\n",
    "\n",
    "- The code inside the while-loop is repeated as long as the condition is **True**\n",
    "\n",
    "- When the condition becomes **False**, program continues with under while-loop with not indented code\n",
    "\n",
    "- Careful: **Infinite loop** when condition is not updated inside the while-loop.\n",
    "\n",
    "- Condition has to be updated inside the while-loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Boolean Expressions\n",
    "\n",
    "- Boolean Expressions (Conditions, Questions or Comparisons):\n",
    "    - $A > B$ $\\to$ is A greater than B\n",
    "    - $A < B$ $\\to$ is A less than B\n",
    "    - $A >= B$ $\\to$ is A greater than or equal to B\n",
    "    - $A <= B$ $\\to$ is A less than or equal to B\n",
    "    - $A == B$ $\\to$ is A equal to B\n",
    "    - $A != B$ $\\to$ is A not equal to B\n",
    "    - **Note:**\n",
    "        - `=` $\\to$ assignment (`A = B`)\n",
    "        - `==` $\\to$ comparison (is `A == B`)\n",
    "    - Conditions always evaluate to **True** or **False**\n",
    "    - New object type **bool** e.g. `type(4 < 6)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Examples - Illustrative:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(10 * 24 > 100)\n",
    "print(10.32 < 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Numerical accuracy (round-off errors)\n",
    "    - Computers have a finite amount of space to store real numbers\n",
    "    - Real numbers are usually represented up to only 16 decimal digits\n",
    "    - Real numbers often have small “round-off” errors when calculated on a computer\n",
    "    - `(1.0 / 49) * 49` $\\to$ `0.9999999999999999`\n",
    "    - Important when comparing real numbers\n",
    "    - How to compare real numbers then?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "ans = (1.0 / 49) * 49\n",
    "print(ans)\n",
    "print(ans == 1.0)\n",
    "print(abs(1 - ans) <= 1e-12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f --digits 16\n",
    "price = 4.35\n",
    "quantity = 100\n",
    "total = price * quantity\n",
    "\n",
    "print(total == 435)\n",
    "print(abs(435 - total) <= 1e-12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Outcomes:\n",
    "- Understand how boolean expressions work\n",
    "\n",
    "\n",
    "- Understand that boolean expressions evaluate to either `True` or `False`\n",
    "\n",
    "\n",
    "- Understand how to compare `float` (real) objects\n",
    "\n",
    "\n",
    "- Understand the `abs` function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example ``ln(2)`` approximation:\n",
    "\n",
    "- $\\ln(2)$ can be approximated by:\n",
    "    $$\\ln(2) = \\sum_{n=1}^{\\infty} (-1)^{(n-1)} \\left( \\frac{1}{n} \\right) = 1 - \\frac{1}{2} + \\frac{1}{3} - \\frac{1}{4} + \\dots $$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- initialising the condition (before the `while` loop)\n",
    "\n",
    "\n",
    "- which condition to use:\n",
    "    - `error == 1e-6`\n",
    "    - `error != 1e-6`\n",
    "    - `error > 1e-6`\n",
    "    - `error < 1e-6`\n",
    "\n",
    "\n",
    "- updating the condition (in the `while` loop)\n",
    "\n",
    "\n",
    "- no `arange` function or `for` loop index $\\to$ need to create an index counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def ln_approx(tol):\n",
    "    approx = 0\n",
    "    actual = np.log(2)\n",
    "    error = 1\n",
    "    ind = 1\n",
    "\n",
    "    while error > tol:\n",
    "        sign = (-1)**(ind - 1)\n",
    "        term = 1.0 / ind\n",
    "        approx = approx + (sign * term)\n",
    "        error = abs(actual - approx)\n",
    "        ind = ind + 1\n",
    "    return approx\n",
    "\n",
    "\n",
    "actual = np.log(2)\n",
    "approx = ln_approx(tol=1e-6)\n",
    "error = abs(actual - approx)\n",
    "print(\"Approx:\", approx)\n",
    "print(\"Actual:\", actual)\n",
    "print(\"Error:\", error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Multiple Conditions\n",
    "\n",
    "### Example ``ln(2)`` approximation:\n",
    "\n",
    "- $\\ln(2)$ can be approximated by:\n",
    "    $$ \\ln(2) = \\sum_{n=1}^{\\infty} (-1)^{(n+1)} \\left( \\frac{1}{n} \\right) = 1 - \\frac{1}{2} + \\frac{1}{3} - \\frac{1}{4} + \\dots $$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "- infinite loop $\\to$ Not updating the condition in the `while` loop\n",
    "\n",
    "\n",
    "- top Right Circle $\\to$ Python kernel activity\n",
    "\n",
    "\n",
    "- `stop` Button $\\to$ break the infinite loop\n",
    "\n",
    "\n",
    "- Counter limit $\\to$ maximum number of iterations of the `while` loop $\\to$ safeguard\n",
    "\n",
    "\n",
    "- Combine two conditions using `and` keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def ln_approx(tol, max_iter):\n",
    "    approx = 0\n",
    "    actual = np.log(2)\n",
    "    error = 1\n",
    "    ind = 1\n",
    "\n",
    "    while (error > tol) and (ind < max_iter):\n",
    "        sign = (-1)**(ind - 1)\n",
    "        term = 1.0 / ind\n",
    "        approx = approx + (sign * term)\n",
    "        error = abs(actual - approx)\n",
    "        ind = ind + 1\n",
    "    return approx\n",
    "\n",
    "\n",
    "actual = np.log(2)\n",
    "approx = ln_approx(tol=1e-6, max_iter=1000)\n",
    "error = abs(actual - approx)\n",
    "print(\"Approx:\", approx)\n",
    "print(\"Actual:\", actual)\n",
    "print(\"Error:\", error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Expressions Cont."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `or` keyword:\n",
    "    - `cond1 or cond2` $\\to$ only **False** when both are False\n",
    "    - `True` or `True` $\\to$ `True`\n",
    "    - `True` or `False` $\\to$ `True`\n",
    "    - `False` or `False` $\\to$ `False`\n",
    "\n",
    "\n",
    "- `and` keyword:\n",
    "    - `cond1 and cond2` $\\to$ only **true** when both are true\n",
    "    - `True` and `True` $\\to$ `True`\n",
    "    - `True` and `False` $\\to$ `False`\n",
    "    - `False` and `False` $\\to$ `False`\n",
    "\n",
    "\n",
    "### Examples - Illustrative:\n",
    "- `number < 0 or number >= 10`?\n",
    "\n",
    "\n",
    "- `number < 10 or number >= 0`?\n",
    "\n",
    "\n",
    "- `number < 0 and number >= 10`?\n",
    "\n",
    "\n",
    "- `number < 10 and number >= 0`?\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Understand difference between combining two or more boolean expressions using the `and` / `or` keywords\n",
    "\n",
    "\n",
    "- Able to identify appropriate conditions and combine them as part of solving a problem\n",
    "\n",
    "\n",
    "- `and` is always executed before `or` (similar to `*` being executed before `+`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "number = 8\n",
    "print((number < 0) or (number >= 10))\n",
    "print((number < 10) or (number >= 0))\n",
    "print((number < 0) and (number >= 10))\n",
    "print((number < 10) and (number >= 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Throw a Die Until\n",
    "\n",
    "- Write a program that simulates the throw of a die until it lands on `4`\n",
    "\n",
    "\n",
    "### Outcomes\n",
    "\n",
    "- Understanding the `numpy.random.randint` function\n",
    "\n",
    "\n",
    "- A condition, computed separately"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def throw_die(N):\n",
    "    cnt = 0\n",
    "    run = True\n",
    "    while run:\n",
    "        die = np.random.randint(1, 7)\n",
    "        run = (die != N)\n",
    "        cnt = cnt + 1\n",
    "    return cnt\n",
    "\n",
    "\n",
    "throws = throw_die(N=4)\n",
    "print(throws)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Sum Random Integers:\n",
    "\n",
    "- Write a program that simulates the throw of a die.\n",
    "\n",
    "\n",
    "- Add the die throws together until the sum is greater than 50\n",
    "\n",
    "\n",
    "- What is the sum of the die throws?\n",
    "\n",
    "\n",
    "- How many die throws were needed?\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- understanding the `numpy.random.randint` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def sum_die_values(N):\n",
    "    cnt = 0\n",
    "    die_sum = 0\n",
    "    while die_sum <= N:\n",
    "        die = np.random.randint(1, 7)\n",
    "        die_sum = die_sum + die\n",
    "        cnt = cnt + 1\n",
    "    return cnt, die_sum\n",
    "\n",
    "\n",
    "nthrows, total = sum_die_values(50)\n",
    "print(\"Throws:\", nthrows)\n",
    "print(\"Sum:\", total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Sum Random Integers:\n",
    "\n",
    "- Write a program that simulates the throw of a die\n",
    "\n",
    "\n",
    "- Add the die throws together until the sum is greater than 50\n",
    "\n",
    "\n",
    "- What is the sum of the die throws?\n",
    "\n",
    "\n",
    "- How many die throws were needed?\n",
    "\n",
    "\n",
    "- **Count how many times the die lands on a certain number and store this information to an array**\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Using an array with a `while` loop\n",
    "\n",
    "\n",
    "- Enhance the understanding of indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def sum_die_values(N):\n",
    "    cnt = 0\n",
    "    die_sum = 0\n",
    "    value_cnt = np.zeros(6)\n",
    "    while die_sum <= N:\n",
    "        die = np.random.randint(1, 7)\n",
    "        value_cnt[die-1] = value_cnt[die-1] + 1\n",
    "        die_sum = die_sum + die\n",
    "        cnt = cnt + 1\n",
    "    return cnt, die_sum, value_cnt\n",
    "\n",
    "\n",
    "nthrows, total, count = sum_die_values(50)\n",
    "print(\"Throws:\", nthrows)\n",
    "print(\"Sum:\", total)\n",
    "print(\"Die landed on\")\n",
    "print(\"\\tValue:\", np.arange(1, 7, 1.))\n",
    "print(\"\\tTimes:\", count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Series\n",
    "- Consider the following series:\n",
    "\n",
    "    $$ \\sum^\\infty_{k=1} \\frac{(k!)^2}{(2k)!} = \\frac{1!^2}{2!} + \\frac{2!^2}{4!} + \\frac{3!^2}{6!} + \\cdots $$\n",
    "\n",
    "\n",
    "- Compute the value that the above series converges to, within an error of 1e-5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def series(tol):\n",
    "    k = 1\n",
    "    approx = 0\n",
    "    error = 1\n",
    "    while (error >= tol):\n",
    "        term = (\n",
    "            np.math.factorial(k)**2 / \n",
    "            np.math.factorial(2*k)\n",
    "        )\n",
    "        approx = approx + term\n",
    "        error = abs(term)\n",
    "        k = k + 1\n",
    "    return k, approx, error\n",
    "\n",
    "\n",
    "nterms, approx, error = series(tol=1e-5)\n",
    "print(\"Num Terms:\", nterms)\n",
    "print(\"Approx:\", approx)\n",
    "print(\"Error:\", error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Growing Lists\n",
    "\n",
    "### Example - Sum Random Integers:\n",
    "\n",
    "- Write a program that simulates the throw of a die\n",
    "\n",
    "\n",
    "- Add the die throws together until the sum is greater than 50\n",
    "\n",
    "\n",
    "- Store the history of die throws in a list\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Using a list with a `while` loop\n",
    "\n",
    "\n",
    "- Growing a list of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "import numpy as np\n",
    "\n",
    "def sum_die_values(N):\n",
    "    cnt = 0\n",
    "    die_sum = 0\n",
    "    die_values = []\n",
    "    while die_sum <= N:\n",
    "        die = np.random.randint(1, 7)\n",
    "        die_values.append(die)\n",
    "        die_sum = die_sum + die\n",
    "        cnt = cnt + 1\n",
    "    return cnt, die_sum, die_values\n",
    "\n",
    "\n",
    "nthrows, total, history = sum_die_values(50)\n",
    "print(\"Throws:\", nthrows)\n",
    "print(\"Sum:\", total)\n",
    "print(\"Throw History:\\n\\t\", history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Cannot \"grow\" an array of values!!** $\\to$ need to use a list\n",
    "- Can convert a list to an array after \"growing\" it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - sin(x) Approximation:\n",
    "- $\\sin(x)$ can be approximated by:\n",
    "    $$ \\sin(x) = x - \\frac{x^3}{3!} + \\frac{x^5}{5!} - \\frac{x^7}{7!} + \\frac{x^9}{9!} + \\dots $$\n",
    "\n",
    "\n",
    "- Compute the $\\sin(x)$ approximation within an error of 1E-1 for $x \\in [\\pi/4, 3\\pi/4]$\n",
    "- Compute the $\\sin(x)$ approximation within an error of 1E-2 for $x \\in [\\pi/4, 3\\pi/4]$\n",
    "- Compute the $\\sin(x)$ approximation within an error of 1E-3 for $x \\in [\\pi/4, 3\\pi/4]$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- nested `for` loop to change data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def sin_approx(x, tol):\n",
    "    approx = 0\n",
    "    error = 1\n",
    "    sign = 1\n",
    "    odd_num = 1\n",
    "    while (error >= tol):\n",
    "        term = (x**odd_num) / np.math.factorial(odd_num)\n",
    "        approx = approx + (sign * term)\n",
    "        error = abs(np.sin(x) - approx)\n",
    "        odd_num = odd_num + 2\n",
    "        sign = (-1) * sign\n",
    "    return approx, error\n",
    "\n",
    "\n",
    "tolerances = np.array([1e-1, 1e-2, 1e-3])\n",
    "xvals = np.arange(np.pi/4, 3*np.pi/4+0.1, 0.1)\n",
    "for tol in tolerances:\n",
    "    ans = []\n",
    "    for x in xvals:\n",
    "        approx, error = sin_approx(x=x, tol=tol)\n",
    "        ans.append(approx)\n",
    "    plt.plot(xvals, ans)\n",
    "\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Recap\n",
    "\n",
    "### For Loop, While Loop, Nested Loops\n",
    "\n",
    "- Loops\n",
    "    - For-Loop $\\to$ Used to repeat code a known and fixed number of times\n",
    "    - While-Loop $\\to$ Used to repeat code an unknown number of times for a known condition\n",
    "\n",
    "\n",
    "- While-Loop\n",
    "    - Initialise condition outside the while-loop\n",
    "    - Take care to use the correct condition for the while-loop\n",
    "    - Update the condition inside the while-loop\n",
    "\n",
    "\n",
    "- Nested Loops\n",
    "    - inner loop (for or while) is repeated for every iteration of the outer loop (for or while)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Recap Quiz\n",
    "\n",
    "- Example of an object falling:\n",
    "    - $t_0 = 0 \\: s$ (initial time)\n",
    "    - $s_0 = 830 \\: m$ (initial height) - Burj Khalifa in Dubai\n",
    "    - $v_0 = 0 \\: m/s$ (initial velocity)\n",
    "    - $a = -9.81 \\: m/s^2$ (gravitational acceleration)\n",
    "    - $t = t_0 + 0.2i \\: s \\qquad \\text{for} \\quad i = 0, 1, 2, \\dots$ (time)\n",
    "\n",
    "$$ \n",
    "\\begin{align}\n",
    "    a(t) &= \\text{const} \\\\\n",
    "    v(t) &= \\int a dt  =  v_0 + at \\\\\n",
    "    s(t) &= \\int v(t) dt = s_0 + v_0t + \\frac{1}{2} at^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "\n",
    "- What type of loop should you use to answer the following, and why:\n",
    "    1. Calculate $s(t)$ for 100 time intervals\n",
    "    2. Calculate $s(t)$ as long as the object is above the ground\n",
    "\n",
    "\n",
    "- Example (Add Integers):\n",
    "    - Illustrate how to add the first 10 integers with a `for` loop\n",
    "    - Illustrate how to add the first 10 integers with a `while` loop\n",
    "    - `for` loop $\\to$ convenient due to the counter / looping through lists\n",
    "    - `while` loop $\\to$ more general loop structure than the for-loop\n",
    "\n",
    "\n",
    "- Without knowing the problem behind this code, how many mistakes can you spot? There are 7 in total."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy.random as rand\n",
    "\n",
    "def bar():\n",
    "    my_sum = 1.45\n",
    "    while my_sum:\n",
    "        val = numpy.random.randint(0, 10)\n",
    "        my_sum = my_sum + -1**(i-1)\n",
    "\n",
    "\n",
    "print(bar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- What is wrong with the following code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "\n",
    "def foo(i):\n",
    "    my_sum = 0\n",
    "    while i == 0:\n",
    "        my_sum = my_sum + 10\n",
    "    return my_sum\n",
    "\n",
    "\n",
    "for n in range(0, 10, 1):\n",
    "    print(foo(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Visualize",
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}