Exercises/02 Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 02.1 (if-else)\n",
    "\n",
    "Consider the following assessment criteria which map a score out of 100 to an \n",
    "assessment grade:\n",
    "\n",
    "| Grade            | Raw score  (/100)      |\n",
    "| ---------------- | ---------------------- |\n",
    "| Excellent        | $\\ge 82$               |\n",
    "| Very good        | $\\ge 76.5$ and $< 82$  |\n",
    "| Good             | $\\ge 66$ and $< 76.5$  |\n",
    "| Need improvement | $\\ge 45$ and $< 66$    |\n",
    "| Did you try?     | $< 45$                 |\n",
    "\n",
    "Write a program that, given an a score, prints the appropriate grade. Print an error message if the input score is greater than 100 or less than zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "a514c1218467051dab6b6e4fa054bc90",
     "grade": false,
     "grade_id": "cell-71121f470be22e4a",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 02.2 (bisection)\n",
    "\n",
    "Bisection is an iterative method for finding approximate roots of a function. Say we know that the function $f(x)$ has one root between $x_{0}$ and $x_{1}$ ($x_{0} < x_{1}$). We then:\n",
    "\n",
    "- Evaluate $f$ at the midpoint $x_{\\rm mid} = (x_0 + x_1)/2$, i.e. compute\n",
    "   $f_{\\rm mid} = f(x_{\\rm mid})$\n",
    "- Evaluate $f(x_0) \\cdot f(x_{\\rm mid})$\n",
    "\n",
    "  - If $f(x_0) \\cdot f(x_{\\rm mid}) < 0$: \n",
    "\n",
    "    $f$ must change sign somewhere between $x_0$ and $x_{\\rm mid}$, hence the root must lie between \n",
    "    $x_0$ and $x_{\\rm mid}$, so set $x_1 = x_{\\rm mid}$.\n",
    "   \n",
    "  - Else\n",
    "\n",
    "    $f$ must change sign somewhere between $x_{\\rm mid}$ and $x_1$, so set\n",
    "    $x_0 = x_{\\rm mid}$.\n",
    "\n",
    "The above steps can be repeated a specified number of times, or until $|f_{\\rm mid}|$\n",
    "is below a tolerance, with $x_{\\rm mid}$ being the approximate root.\n",
    "\n",
    "\n",
    "### Task\n",
    "\n",
    "The function\n",
    "\n",
    "$$\n",
    "f(x) = x^3 - 6x^2 + 4x + 12\n",
    "$$\n",
    "\n",
    "has one root somewhere between $x_0 = 3$ and $x_1 = 6$.\n",
    "\n",
    "1. Use the bisection method to find an approximate root $x_{r}$ using 15 iterations \n",
    "   (use a `for` loop).\n",
    "2. Use the bisection method to find an approximate root $x_{r}$ such that \n",
    "   $\\left| f(x_{r}) \\right| < 1 \\times 10^{-6}$ and report the number of iterations \n",
    "   required (use a `while` loop).\n",
    "\n",
    "Store the approximate root using the variable `x_mid`, and store $f(x_{\\rm mid})$ using the variable `f`.\n",
    "\n",
    "*Hint:* Use  `abs` to compute the absolute value of a number, e.g. `y = abs(x)` assigns the absolute value of `x` to `y`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (1) Using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "ee3cd280d0ab20bacff2198885db439f",
     "grade": false,
     "grade_id": "cell-3a0d0a59613d6b3f",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Initial end points\n",
    "x0 = 3.0\n",
    "x1 = 6.0\n",
    "\n",
    "# Use 15 iterations\n",
    "for n in range(15):\n",
    "    # Compute midpoint\n",
    "    x_mid = (x0 + x1)/2\n",
    "\n",
    "    # Evaluate function at left end-point and at midpoint\n",
    "    f0 = x0**3 - 6*x0**2 + 4*x0 + 12\n",
    "    f = x_mid**3 - 6*x_mid**2 + 4*x_mid + 12\n",
    "    \n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "\n",
    "    print(n, x_mid, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "300a5759e0f5b564a00fa0e9acee6f68",
     "grade": true,
     "grade_id": "cell-421824bbd4e61fae",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert round(x_mid - 4.534149169921875, 10) == 0.0\n",
    "assert abs(f) < 0.0009"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (2) Using a `while` loop\n",
    "\n",
    "Use the variable `counter` for the iteration number. \n",
    "\n",
    "*Remember to guard against infinite loops.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "cc52d8a36b886950be06af5bfa258206",
     "grade": false,
     "grade_id": "cell-1747a3fb1dd1de48",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Initial end points\n",
    "x0 = 3.0\n",
    "x1 = 6.0\n",
    "\n",
    "tol = 1.0e-6\n",
    "error = tol + 1.0\n",
    "\n",
    "# Iterate until tolerance is met\n",
    "counter = 0\n",
    "while error > tol:\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "\n",
    "    # Guard against an infinite loop\n",
    "    if counter > 1000:\n",
    "        print(\"Oops, iteration count is very large. Breaking out of while loop.\")\n",
    "        break\n",
    "    \n",
    "    print(counter, x_mid, error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "5604f410d2134838760ac580a9b40f73",
     "grade": true,
     "grade_id": "cell-ddff32f44df88388",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert counter == 23\n",
    "assert abs(f) < 1.0e-6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercise 02.3 (series expansion)\n",
    "\n",
    "The power series expansion for the sine function is: \n",
    "\n",
    "$$\n",
    "\\sin(x) = \\sum_{n = 0}^{\\infty} (-1)^n \\frac{x^{2n +1}}{(2n+1)!}\n",
    "$$\n",
    "\n",
    "(See mathematics data book for a less compact version; this compact version is preferred here as it is simpler to program.)\n",
    "\n",
    "1. Using a `for` statement, approximate $\\sin(3\\pi/2)$ using 15 terms in the series expansion and report the absolute error.\n",
    "\n",
    "1. Using a `while` statement, compute how many terms in the series are required to approximate $\\sin(3\\pi/2)$ to within $1 \\times 10^{-8}$. \n",
    "\n",
    "Store the absolute value of the error in the variable `error`.\n",
    "\n",
    "*Note:* Calculators and computers use iterative or series expansions to compute trigonometric functions, similar to the one above (although they use more efficient formulations than the above series).\n",
    "\n",
    "### Hints\n",
    "\n",
    "To compute the factorial and to get a good approximation of $\\pi$, use the Python `math` module:\n",
    "```python\n",
    "import math\n",
    "nfact = math.factorial(10)\n",
    "pi = math.pi\n",
    "```\n",
    "You only need '`import math`' once at the top of your program. Standard modules, like `math`, will be explained in a later. If you want to test for angles for which sine is not simple, you can use \n",
    "```python\n",
    "a = 1.3\n",
    "s = math.sin(a)\n",
    "```    \n",
    "to get an accurate computation of sine to check the error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (1) Using a `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "105cfce8eabbd37a7afaee8203d6bd3b",
     "grade": false,
     "grade_id": "cell-d6df4b428f969a5d",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Import the math module to access math.sin and math.factorial\n",
    "import math\n",
    "\n",
    "# Value at which to approximate sine\n",
    "x = 1.5*math.pi\n",
    "\n",
    "# Initialise approximation of sine\n",
    "approx_sin = 0.0\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()\n",
    "    \n",
    "print(\"The error is:\")\n",
    "print(error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "e96bb82c27a0c914a648526edbe13d26",
     "grade": true,
     "grade_id": "cell-8b269b717e92414d",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert error < 1.0e-12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (2) Using a `while` loop\n",
    "\n",
    "*Remember to guard against infinite loops.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "f7c4320acbc1a64d9d8423de7111714b",
     "grade": false,
     "grade_id": "cell-03df25d83df3674e",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Import the math module to access math.sin and math.factorial\n",
    "import math\n",
    "\n",
    "# Value at which to approximate sine\n",
    "x = 1.5*math.pi\n",
    "\n",
    "# Tolerance and initial error (this just needs to be larger than tol)\n",
    "tol = 1.0e-8\n",
    "error = tol + 1.0\n",
    "\n",
    "# Intialise approximation of sine\n",
    "approx_sin = 0.0\n",
    "\n",
    "# Initialise counter\n",
    "n = 0\n",
    "\n",
    "# Loop until error satisfies tolerance, with a check to avoid \n",
    "# an infinite loop\n",
    "while error > tol and n < 1000:\n",
    "    \n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "    \n",
    "    # Increment counter\n",
    "    n += 1    \n",
    "    \n",
    "    \n",
    "print(\"The error is:\")\n",
    "print(error)\n",
    "\n",
    "print(\"Number of terms in series:\")\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7e9cf956faf5c223affc2cc9a50d4cf5",
     "grade": true,
     "grade_id": "cell-03df25d83df3674dfwe",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert error <= 1.0e-8"
   ]
  }
 ],
 "metadata": {
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}