lecture-1-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 1-2: Numerical integration\n",
    "\n",
    "### Introduction\n",
    "\n",
    "We just discussed **Riemann sums** and the **trapezoidal rule**, two simple methods to perform numerical integration. How can we apply them to a real problem? The first step for us is to define a function to integrate.\n",
    "\n",
    "### Defining and using functions\n",
    "\n",
    "We've already used functions to print text and to make plots, but they were already defined for us. Now we're going to write our own function.\n",
    "\n",
    "Add a new code block below, then type\n",
    "```\n",
    "def f(x):\n",
    "    return 3 * (x**2)\n",
    "\n",
    "y = f(1)\n",
    "print(y)\n",
    "```\n",
    "You can use `tab` to indent the second line. Before you evaluate the code, what do you expect will happen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Anatomy of a function\n",
    "\n",
    "Let's diagram what's happening here! `def` is a special word in Python, which tells the computer that we're going to define a function. \n",
    "\n",
    "The next thing that comes after `def` is the **name** of the function. Functions are named just like variables are. Here, we just named our function `f`. You can name a function anything that you like, as long as 1) the name doesn't begin with a letter, and 2) it doesn't contain any spaces or special characters other than `_`.\n",
    "\n",
    "After the name there are parentheses `()`. The text inside the parentheses are the **arguments** that are passed to the function. When the function is defined, the arguments don't have a particular value, we're just giving them a variable name that will allow us to use them later on.\n",
    "\n",
    "This line ends with a colon `:`. Everything below this point that is **indented** forms the **body** of the function. Every time you **call** a function, it sends the arguments that you pass to the functions and then evaluates the code in the **body**.\n",
    "\n",
    "For example, here's what happened when you wrote `y = f(1)` above:\n",
    "- Python recognizes that `f` is a function, and it passes the argument `1` to the function `f`  \n",
    "- `f` takes one variable, whose name is `x` -- since we called the function with `f(1)`, `x` is assigned a value of `1`  \n",
    "- The **body** of `f` only contains one line: it first computes `3 * (x**2)`, which gives `3`, and it **returns** this value\n",
    "- Finally, the value of `y` is set to the value that `f(1)` returns, so `y = 3`\n",
    "\n",
    "### More function examples and words of caution\n",
    "\n",
    "Try typing in the following examples. Let's consider what happens in each case.\n",
    "\n",
    "**Example 1.** Passing multiple arguments to a function.\n",
    "```\n",
    "import numpy as np\n",
    "\n",
    "def aFunctionThatAdds(arg1, arg2):\n",
    "    return arg1 + arg2\n",
    "    \n",
    "print(aFunctionThatAdds(1, 2))\n",
    "print(aFunctionThatAdds('one', 'two'))\n",
    "print(aFunctionThatAdds(np.array([1, 1]), np.array([2, 2])))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example 2.** Variable scope.\n",
    "```\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "    \n",
    "x = 1\n",
    "print(add(2, 2))\n",
    "\n",
    "def add(z, y):\n",
    "    return x + y\n",
    "    \n",
    "print(add(2, 2))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing a function to perform numerical integration\n",
    "\n",
    "Now we know how to write a function. Let's continue by writing a function that performs numerical integration.\n",
    "\n",
    "Let's start by writing out the steps for the **trapezoidal rule**. We have a function $f(x)$ of a single variable $x$, which we would like to integrate over $[a, b]$. We have to then:\n",
    "- Divide the interval into $n$ pieces.  \n",
    "    - Each piece is $\\Delta x = (b-a)/n$ long.  \n",
    "    - The left side of the $i$th piece is located at $a + (i-1)\\Delta x$.  \n",
    "    - The right side of the $i$th piece is located at $a + i \\Delta x$.\n",
    "- Compute the average value of the function on each piece, assuming that the function is linear.\n",
    "    - The value of the function at the left edge is $f(a + (i-1)\\Delta x)$.  \n",
    "    - The value of the function at the right edge is $f(a + i\\Delta x)$.  \n",
    "- Sum the length of each piece times the average value of the function on that piece:\n",
    "$$\\int_a^b\\! dx\\,f(x) \\approx \\sum_{i=1}^{n} \\Delta x \\frac{f(a + (i-1)\\Delta x) + f(a + i\\Delta x)}{2}\\,.$$\n",
    "\n",
    "Most of this we can do, but something is missing: how can we compute a **sum**? We can use a **loop**!\n",
    "\n",
    "Add a new code block below and fill it with the following:\n",
    "```\n",
    "print(list(range(5)))\n",
    "print('')\n",
    "\n",
    "for i in range(5):\n",
    "    print(i)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops\n",
    "\n",
    "In Python `for` is a keyword that begins a **for loop**. In the code above, the next word `i` is the name of the iteration variable. This is followed by `in`, which tells us that the next phrase `range(5)` is the list of indices to iterate over.  \n",
    "\n",
    "`range` is also a keyword in Python that creates sets of variables for iterating. `range(n, m)`, for any integers `n` and `m`, will provide a list of the numbers from $n$ to $m-1$.\n",
    "\n",
    "For loops are very useful for adding or evaluating functions sequentially. During every iteration with a new value of the iteration variable, all of the indented code below the `for` line is executed. Try this example:\n",
    "```\n",
    "total = 0\n",
    "for x in range(1, 5):\n",
    "    print(x)\n",
    "    total = total + x\n",
    "    \n",
    "print(total)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bringing it all together\n",
    "\n",
    "Now we're ready to write a function to perform numerical integration. As an example, let's start by numerically evaluating the integral\n",
    "\n",
    "$$\\int_0^1 \\!dx\\; 3 x^2 = 1\\,.$$\n",
    "\n",
    "The code block below has an outline of the steps of the **trapezoidal rule**. We'll fill them in together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    # This is the function that we want to integrate\n",
    "\n",
    "def integrate(func, a, b, n):\n",
    "    # This functions integrates the univariate function 'func' over \n",
    "    # the interval from 'a' to 'b' using the trapezoidal rule, \n",
    "    # diving the interval into n pieces \n",
    "    \n",
    "    # Define the length of the pieces, delta x\n",
    "    \n",
    "    # Sum the average value of the function over each piece\n",
    "    \n",
    "    # Return the result\n",
    "    \n",
    "\n",
    "# Now, let's test our function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accuracy\n",
    "\n",
    "How does the number of pieces `n` to break the integration interval into affect the accuracy of integration?\n",
    "\n",
    "Try the following example:\n",
    "```\n",
    "print(integrate(f, 0, 1, 1))\n",
    "print(integrate(f, 0, 1, 4))\n",
    "print(integrate(f, 0, 1, 16))\n",
    "print(integrate(f, 0, 1, 64))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "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.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}