03_Riemann_Sums.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Riemann Sums, Loops and Chart Minutiae"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histograms vs Bar Charts\n",
    "\n",
    "Off the top of your head, can you recall the difference between a histogram and a bar chart?\n",
    "\n",
    "In the more probable case that you haven't spent too much time generating visualisations, we will briefly visit both."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histogram\n",
    "\n",
    "Used for forming counts of one variable.\n",
    "\n",
    "A histogram takes in continuous data, taking the values that fall between two areas, lumping them into a `bin` and scoring a count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = [1,1,1,2,3,7,8,21,21,22,38,39,40, 42,42]\n",
    "\n",
    "plt.hist(x, 5)\n",
    "plt.ylabel(\"Count\")\n",
    "plt.xlabel(\"Continuous Variable\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Histograms will not be talked about further in this notebook, but one should be aware of the difference between them and bar charts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bar Chart\n",
    "\n",
    "Used to represent data between two variables. A discrete one on the x-axis (usually) and a continuous one on the y-axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Continuous Bar Chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def func(x):\n",
    "    return x**2 + 3*x -10\n",
    "\n",
    "# Some f(x)\n",
    "x = np.linspace(0,10,50) # Domain of f(x)\n",
    "y = func(x)\n",
    "\n",
    "a = np.array([4,5,6,7])\n",
    "b = func(a)\n",
    "\n",
    "plt.plot(x,y, color='b', label='f(x)')\n",
    "plt.bar(a,b, color='r', label='bars')\n",
    "plt.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So what did we do? \n",
    "\n",
    "We took a domain of discrete points and mapped them through a function, then made a bar of each point in the domain that we mapped.\n",
    "\n",
    "This can be useful for things where you are taking a category (here, each point in the domain is a category) and comparing it against a quantitative variable.\n",
    "\n",
    "Here is another example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = [\"Australia\", \"India\", \"Canada\"]\n",
    "y = [1.3, 2.5, 1.65]\n",
    "\n",
    "plt.bar(x,y)\n",
    "plt.title(\"GDP\")\n",
    "plt.ylabel(\"Trillion USD\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Riemann Sums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For $n$ points, split into $n-1$ intervals, a Riemann sum can be calculated by the following:\n",
    "\n",
    "$$\n",
    "\\sum_{i=1}^{n-1} f(x)(x_{i+1} - x_{i})\n",
    "$$\n",
    "\n",
    "Here, the $n$ intervals are constructed on the real line from $a$ to $b$. \n",
    "\n",
    "More formally:\n",
    "$$\n",
    "\\{ x_{1}, \\ldots , \\ x_n \\} \\in (a,b)\n",
    "$$\n",
    "\n",
    "\n",
    "Where $f(x)$ is some function you are attempting to approximate.\n",
    "When you take the limit:  $\\lim_{n \\rightarrow \\infty}$ then you approach an integral which we are familiar with in mathematics.\n",
    "\n",
    "i.e.\n",
    "\n",
    "\n",
    "$$\n",
    "\\lim_{n \\rightarrow \\infty} \\sum_{i=1}^{n-1} f(x)(x_{i+1} - x_{i}) = \\int^{b}_{a} f(x) \\ dx\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(variable):\n",
    "    return variable**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nice_red    = \"#CC8888\"\n",
    "nice_blue   = \"#8888CC\"\n",
    "nice_d_blue = \"#4444CC\"\n",
    "\n",
    "# init\n",
    "fig = plt.figure()\n",
    "a = 6\n",
    "b = 10\n",
    "########\n",
    "n = 8\n",
    "#######\n",
    "my_width = (b-a)/(n)\n",
    "\n",
    "# Your continuous function\n",
    "x = np.linspace(a,b,200)\n",
    "y = func(x)\n",
    "plt.plot(x,y,  color=nice_red)\n",
    "\n",
    "# Your riemann-sum approximation\n",
    "w = np.linspace(a,b,n+1)\n",
    "xl = w[:-1]\n",
    "xr = w[1:]\n",
    "v = func((xl+xr)/2)\n",
    "plt.bar(xl, v, color=nice_blue, align='edge', edgecolor=nice_d_blue, width=xr-xl)\n",
    "\n",
    "# Make things show\n",
    "plt.grid()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_width"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1:\n",
    "\n",
    "Create a representation of the Riemann sum of the function $x^2$ over the domain $[2,8]$. Represent the bars of the approximation in green.\n",
    "\n",
    "Plot a line that represents the function itself in orange over the domain $[0,12]$. \n",
    "\n",
    "\n",
    "\n",
    "**Requirements:**\n",
    "\n",
    "* For both the green and orange, use hexadecimal colours to make your selection.\n",
    "* You must split the approximation into $n=10$ intervals.\n",
    "* Ensure that there is an appropriate amount of points to your $f(x)$ to give the appearance of continuity. Jagged lines are not ok.\n",
    "* Ensure that there is an `edgecolor` to differentiate separate bars from one another in your Riemann sum."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `for`-Loops\n",
    "\n",
    "A `for` loop is something that allows you to write a short amount of code to repeat instructions a large amount of times.\n",
    "\n",
    "e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for count in range(5):\n",
    "    print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `range` function\n",
    "\n",
    "What is happening here? What is `range`? \n",
    "\n",
    "Unfortunately, it's a little involved, even if we try to `type()` both the function call and the function name, we don't get much information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but we can think of range is simply a sequence of values that we are iterating through where `range(n)` provides the numbers `0,1,...,n`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also provide a list with custom start points and amounts to increment by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3,10,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we can see that when we specify:\n",
    "`range(a, b, c)`\n",
    "\n",
    "we mathematically get:\n",
    "\n",
    "$$\n",
    "i \\in \\{ a, \\ a+c, \\ a+2c, \\ldots \\ , b-1 \\}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating through a `list`\n",
    "Whilst iterating with range is helpful, sometimes iterating through a list will be more applicable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,7,8,4,9,1,3,2,0,3]\n",
    "for element in x:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we have created a variable `element` and allowed it to iteratively take on the values of the numbers within the list.\n",
    "\n",
    "We can combine this with some kind of conditions, implemented with `if`-statements that we learnt about in `Python Basics` (go back for a refresher if need-be)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for element in x:\n",
    "    if element > 3:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sum the elements in a `list`\n",
    "We can also set it up to sum the elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum = 0\n",
    "\n",
    "for element in x:\n",
    "    sum += element\n",
    "    \n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 2:\n",
    "\n",
    "Using `for`-loops, print out a list of **even** numbers that count from 88 to 99 using for loops.\n",
    "\n",
    "\n",
    "# Answer 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 3: \n",
    "\n",
    "Using `for`-loops, print out a list of numbers that counts backwards from 50 to 42.\n",
    "\n",
    "# Answer 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 4: \n",
    "\n",
    "Given the list below, print out only the elements greater than 4 using only a `for`-loop and an `if` statement.\n",
    "\n",
    "# Answer 4:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3,4,5,6,8,9]\n",
    "\n",
    "# Your code here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 5:\n",
    "\n",
    "You can obtain the length of a `string` by passing it to the `len` function, which tells you how many characters (letters) there are in it, including spaces.\n",
    " \n",
    "From the list below, print out only the mathematicians whose name is less than or equal to 5 characters.\n",
    "\n",
    "# Answer 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mathematicians = [\"Gauss\", \"Leibniz\", \"Newton\", \"Hilbert\", \"Tao\", \"Euler\", \"Riemann\"]\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Actually Approximating Integrals\n",
    "\n",
    "So we know how to visualise the approximation of an integral, and we're also familiar with `for`-loops.\n",
    "\n",
    "Let's now try to actually approximate an integral: $$\\int^{4}_{2} x^2 dx$$\n",
    "\n",
    "Verifying what our answer should be first, as the number of points in our partition approaches $\\infty$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy as sp\n",
    "sp.init_printing()\n",
    "x = sp.Symbol('x')\n",
    "\n",
    "y = x**2\n",
    "\n",
    "sp.integrate(y, (x, 2, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 6:\n",
    "\n",
    "Write some code to approximate the value of $$\\int^{4}_{2} x^2 dx$$ using your knowledge of Riemann sums, loops and partitions.\n",
    "\n",
    "Defining $n$ as the number of points, give your approximations for:\n",
    "\n",
    "(a) $n$ = 5\n",
    "\n",
    "(b) $n$ = 15\n",
    "\n",
    "(c) $n$ = 50\n",
    "\n",
    "(d) $n$ = 200\n",
    "\n",
    "# Answer 6:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}