Exercises/04 Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "e0a9b2e8a53ee557285f579debe9e5cc",
     "grade": false,
     "grade_id": "cell-0dc6eedbed930025",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Exercise 04.1 (simple function)\n",
    "\n",
    "Write a function called `is_odd` which takes an integer as an argument and returns `True` if the argument is odd, and otherwise returns `False`. Test your function for several values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "a02ca20847904f8b06f9f4e363f7793f",
     "grade": false,
     "grade_id": "cell-f07e8ac1f9838913",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def is_odd(x):\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "1c1d897bf819677735ebbabd84478b5a",
     "grade": true,
     "grade_id": "cell-8a4ca795d9fa96dd",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_odd(0) == False\n",
    "assert is_odd(101) == True\n",
    "assert is_odd(982) == False \n",
    "assert is_odd(-5) == True\n",
    "assert is_odd(-8) == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "34d59ab6e239d09f5de616f9f8d7a54d",
     "grade": false,
     "grade_id": "cell-5ff5517961853849",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Exercise 04.2 (functions and default arguments)\n",
    "\n",
    "Write a single function named `magnitude` that takes each component of a vector of length 2 or 3 and returns the magnitude.\n",
    "Use default arguments to handle vectors of length 2 or 3 with the same code. Test your function for correctness against hand calculations for a selection of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "eb3b0a0798740195ebc614523189be95",
     "grade": false,
     "grade_id": "cell-693a09b45c6bb532",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "53cdb70056d8af7e0a1d29feffbe9ccc",
     "grade": true,
     "grade_id": "cell-384a85ba97b226d7",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert round(magnitude(3, 4) - 5.0, 10) == 0.0\n",
    "assert round(magnitude(4, 3) - 5.0, 10) == 0.0\n",
    "assert round(magnitude(4, 3, 0.0)- 5.0, 10) == 0.0\n",
    "assert round(magnitude(4, 0.0, 3.0) - 5.0, 10) == 0.0\n",
    "assert round(magnitude(3, 4, 4) - 6.403124237, 8) == 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "41dbb0a818ccdedb37806cea8a5e4866",
     "grade": false,
     "grade_id": "cell-668d765c259431ca",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Exercise 04.3 (functions)\n",
    "\n",
    "Given the coordinates of the vertices of a triangle, $(x_0, y_0)$, $(x_1, y_1)$ and $(x_2, y_2)$, the area $A$ of the triangle is given by:\n",
    "$$\n",
    "A = \\left| \\frac{x_0(y_1  - y_2) + x_1(y_2 - y_0) + x_2(y_0 - y_1)}{2} \\right|\n",
    "$$\n",
    "Write a function named `area` that computes the area of a triangle given the coordinates of the vertices.\n",
    "The order of the function arguments must be (`x0, y0, x1, y1, x2, y2)`.\n",
    "\n",
    "Test the output of your function against some known solutions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "57a01efe35b4f958c2cfea74b0f11088",
     "grade": false,
     "grade_id": "cell-ed02439d4509b2c1",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "940773ef0980f1e545e0b29f04d732a9",
     "grade": true,
     "grade_id": "cell-64f8b6708595aed3",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "x0, y0 = 0.0, 0.0\n",
    "x1, y1 = 0.0, 2.0\n",
    "x2, y2 = 3.0, 0.0\n",
    "A = area(x0, y0, x1, y1, x2, y2)\n",
    "assert round(A - 3.0, 10) == 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "97c39673707c88c2a920b9e9c9102b21",
     "grade": false,
     "grade_id": "cell-45e85991122d3796",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Exercise 04.4 (recursion)\n",
    "\n",
    "The factorial of a non-negative integer $n$ is expressed recursively by:\n",
    "$$\n",
    "n! = \n",
    "\\begin{cases}\n",
    "1 & n = 0 \\\\\n",
    "(n - 1)! \\,n & n > 0\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "Develop a function named `factorial` for computing the factorial using recursion.\n",
    "Test your function against the `math.factorial` function, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "5f6fa5bbfa9f96c7d955158555fbb5cb",
     "grade": false,
     "grade_id": "cell-680d3c06fd6b37a7",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "print(\"Reference factorial:\", math.factorial(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "4b880132ee8f1129be58f9d2f13d65f4",
     "grade": false,
     "grade_id": "cell-9591c1fc1c49c167",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()\n",
    "    \n",
    "print(\"Factorial of 5:\", factorial(5))\n",
    "\n",
    "import math\n",
    "print(\"Reference value of factorial of 5:\", math.factorial(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "fe906129e2843116208179ed6debe846",
     "grade": true,
     "grade_id": "cell-ffe589e9fb2f1419",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert factorial(0) == 1\n",
    "assert factorial(1) == 1\n",
    "assert factorial(2) == 2\n",
    "assert factorial(5) == 120\n",
    "\n",
    "import math\n",
    "assert factorial(32) == math.factorial(32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 04.5 (functions and passing functions as arguments)\n",
    "\n",
    "Restructure your program from the bisection problem in Exercise 02 to \n",
    "\n",
    "- Use a Python function to evaluate the mathematical function $f$ that we want to find the root of; \n",
    "\n",
    "and then\n",
    "\n",
    "- Encapsulate the bisection algorithm inside a Python function, which takes as arguments:\n",
    "  - the function we want to find the roots of\n",
    "  - the points $x_{0}$ and $x_{1}$ between which we want to search for a root\n",
    "  - the tolerance for exiting the bisection algorithm (exit when $|f(x)| < \\text{tol}$)\n",
    "  - maximum number of iterations (the algorithm should exit once this limit is reached)\n",
    "\n",
    "For the first step, use a function for evaluating $f$, e.g.:\n",
    "```python\n",
    "def f(x):\n",
    "    # Put body of the function f(x) here, and return the function value\n",
    "```           \n",
    "For the second step, encapsulate the bisection algorithm in a function:\n",
    "```python\n",
    "def compute_root(f, x0, x1, tol, max_it):\n",
    "    # Implement bisection algorithm here, and return when tolerance is satisfied or\n",
    "    # number of iterations exceeds max_it\n",
    "\n",
    "    # Return the approximate root, value of f(x) and the number of iterations\n",
    "    return x, f, num_it\n",
    "\n",
    "# Compute approximate root of the function f\n",
    "x, f_x, num_it = compute_root(f, x0=3, x1=6, tol=1.0e-6, max_it=1000)\n",
    "```\n",
    "\n",
    "Try testing your program for a different function. A quadratic function, whose roots you can find analytically, would be a good test case.\n",
    "\n",
    "\n",
    "### Optional extension \n",
    "\n",
    "Use recursion to write a `compute_root` function that *does not* require a `for` or `while` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution\n",
    "\n",
    "Define the function for computing $f(x)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "06f934406aa016836ce63505a5136576",
     "grade": false,
     "grade_id": "cell-a9cacdc8d223e7a4",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "def my_f(x):\n",
    "    \"Evaluate polynomial function\"\n",
    "    return x**3 - 6*x**2 + 4*x + 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the function that performs the bisection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "3a24916f619f77367d88ef3156d1e0a8",
     "grade": false,
     "grade_id": "cell-622edcb129dcc7f2",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def compute_root(f, x0, x1, tol, max_it):\n",
    "    \"Compute roots of a function using bisection\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "     \n",
    "    return x_mid, f_mid, it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7312b324cda17ae9abcbcda67e9166fe",
     "grade": true,
     "grade_id": "cell-cb5a5cdf1d790edb",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "x, f, num_it = compute_root(my_f, x0=3, x1=6, tol=1.0e-6, max_it=1000)\n",
    "assert round(x - 4.534070134162903, 10) == 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Optional extension: using recursion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "a1c34758641dd06b2980beb1edcc528e",
     "grade": false,
     "grade_id": "cell-c944bb2229317d4d",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def compute_root(f, x0, x1, tol, max_it, it_count=0):\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "    \n",
    "    # Call compute_root recursively\n",
    "    return compute_root(f, x0, x1, tol, max_it, it_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "e2a8ed573821574e3398861b6f7eff06",
     "grade": true,
     "grade_id": "cell-9ebe2f13b2899a8f",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "x, f, num_it = compute_root(my_f, x0=3, x1=6, tol=1.0e-6, max_it=1000)\n",
    "assert round(x - 4.534070134162903, 10) == 0.0"
   ]
  }
 ],
 "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
}