Lecture.12-Numerical-Differention-and-Integration.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('default')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numerical Differentiation and Integration\n",
    "## Lecture 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First Derivatives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Approximations to a derivative can be obtained by expanding a function using Taylor series. Here are three schemes for calculating numerically the derivative of a continuous functions. These are called the forward, backward and centered difference schemes. \n",
    "\n",
    "#### Forward scheme\n",
    "\n",
    "$$\\frac{df}{dx}(x_0) \\approx \\frac{f(x_0+\\Delta x )-f(x_0)}{\\Delta x}$$\n",
    "\n",
    "#### Backward scheme\n",
    "\n",
    "$$\\frac{df}{dx}(x_0) \\approx \\frac{f(x_0) - f(x_0 - \\Delta x )}{\\Delta x}$$\n",
    "\n",
    "#### Centered scheme\n",
    "$$\\frac{df}{dx}(x_0) \\approx \\frac{f(x_0+\\Delta x)-f(x_0-\\Delta x)}{2 \\Delta x}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how these schemes can be coded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Forward difference scheme\n",
    "def NDf(f, x0, dx):\n",
    "    return(f(x0+dx) - f(x0)) / dx\n",
    "\n",
    "# Backward difference scheme \n",
    "def NDb(f, x0, dx):\n",
    "    return(f(x0) - f(x0-dx)) / dx   \n",
    "\n",
    "# Centered difference scheme \n",
    "def NDc(f, x0, dx):\n",
    "    return (f(x0+dx) - f(x0-dx)) / (2*dx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a function that can be derived analytically, for example \n",
    " \n",
    "$$\\frac{d}{dx}\\sin(x) = \\cos(x)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(figsize=(8,6))\n",
    "x = np.arange(0, 2*np.pi, 0.1)\n",
    "y = np.sin(x)\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('f(x)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and let's compare the derivative at  $\\pi/4$ of the 3 schemes, using say  $\\Delta x =0.1$, with the exact solution,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x0 = np.pi/4\n",
    "dx = 0.01\n",
    "\n",
    "print(\"Exact:\", np.cos(x0))\n",
    "print(\"  NDf:\", NDf(np.sin, x0, dx))\n",
    "print(\"  NDb:\", NDb(np.sin, x0, dx))\n",
    "print(\"  NDc:\", NDc(np.sin, x0, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Would be more illuminating to look at the absolute relative error. \n",
    "\n",
    "$$ \\text{RelativeError} = \\frac{\\left|\\text{ApproxValue} - \\text{ExactValue}\\right|}{\\text{ExactValue}}$$\n",
    "\n",
    "Let's do this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exact = np.cos(x0)\n",
    "print(\"  NDf: {:.6f}\".format(abs(NDf(np.sin, x0, dx) - exact) / exact))\n",
    "print(\"  NDb: {:.6f}\".format(abs(NDb(np.sin, x0, dx) - exact) / exact))\n",
    "print(\"  NDc: {:.6f}\".format(abs(NDc(np.sin, x0, dx) - exact) / exact))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the forward and backward schemes have a similar error but that the centered scheme is much more accurate. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Second derivatives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second order derivative can be constructed from the forward and backward scheme and is given by\n",
    "\n",
    "#### Centered scheme for 2nd order derivative\n",
    "$$\\frac{d^2 f}{dx^2}(x_0) \\approx \\frac{f(x_0+\\Delta x)-2f(x_0)+f(x_0-\\Delta x)}{\\Delta x^2} $$\n",
    "\n",
    "Which can be coded like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def NDc2(f, x0, dx):\n",
    "    return (f(x0+dx) -2*f(x0)+ f(x0-dx)) / (dx**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And compared with the exact solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x0 = np.pi/4\n",
    "dx = 0.01\n",
    "print(\"Exact:\", -np.sin(x0))\n",
    "print(\" NDc2:\", NDc2(np.sin, x0, dx))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical differentiation of discrete functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numerical differentiation is largely used for estimating derivatives from experimental data. Consider the following set of measurements of a ball thrown in the air. The list of pairs give the time-position of a ball."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BallData = np.array( [ \n",
    "            [0,1.33],\n",
    "            [0.03333,1.411],\n",
    "            [0.06667,1.5], \n",
    "            [0.1,1.578],\n",
    "            [0.1333,1.6456],\n",
    "            [0.1667,1.703],\n",
    "            [0.2,1.745],\n",
    "            [0.2333,1.781],\n",
    "            [0.2667,1.807],\n",
    "            [0.3,1.828],\n",
    "            [0.3333,1.818],\n",
    "            [0.3667,1.818],\n",
    "            [0.4,1.807],\n",
    "            [0.4333,1.776],\n",
    "            [0.4667,1.734],\n",
    "            [0.5,1.682],\n",
    "            [0.5333,1.63],\n",
    "            [0.567,1.552],\n",
    "            [0.6,1.469],\n",
    "            [0.6333,1.37],\n",
    "            [0.667,1.266],\n",
    "            [0.7,1.151],\n",
    "            [0.733,1.026],\n",
    "            [0.7667,0.875],\n",
    "            [0.8,0.719],\n",
    "            [0.8333,0.5573],\n",
    "            [0.867,0.3854],\n",
    "            [0.9,0.193],\n",
    "            [0.9333,0.0052] ] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(BallData[:,0], BallData[:,1], 'o-')\n",
    "plt.xlabel('t (s)')\n",
    "plt.ylabel('y (m)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the acceleration $a$? The acceleration is \n",
    "\n",
    " $$ a= \\frac{d^2 y}{dt^2}.$$\n",
    "\n",
    "Numerically this could be coded as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def second_derivative(data, i):\n",
    "    return (data[i+1,1]-2*data[i,1]+data[i-1,1])/(data[i+1,0]-data[i,0])**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make a list of pair to plot the acceleration as a function of time. Note that we do not attempt to calculate the acceleration at i = 0 and i = 29 because this would require data outside the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "accel = np.zeros(28)\n",
    "\n",
    "for i in range(1, 28):\n",
    "    accel[i] = second_derivative(BallData, i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(BallData[1:29, 0], accel)\n",
    "plt.xlabel('t (s)')\n",
    "plt.ylabel('a (m/s$^2$)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get the mean acceleration over the experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(accel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical integration: Rectangle rule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest algorithm to estimate numerically a definite integral of this sort\n",
    "\n",
    "$$\\int_a^b f(x) dx$$\n",
    "\n",
    "is to divide the area between \n",
    "\n",
    "$$f(a)$$ and  $$f(b)$$ into \n",
    "\n",
    "$n$ rectangles of constant width \n",
    "\n",
    "$$\\Delta x = (b-a)/n$$\n",
    "\n",
    "and heights $f(x_0)$, $f(x_2)$, $f(x_3)$, $\\ldots$, $f(x_{n-1})$\n",
    "\n",
    "and to sum the areas of these rectangles. \n",
    "\n",
    "This leads to the following approximation called the rectangle rule\n",
    "\n",
    "\n",
    "$$ \\int_a^b f(x) dx \\approx [f(x_0)+f(x_2)+f(x_3) + \\dots +f(x_{n-1})] \\Delta x = \\sum_{i=0}^{n-1} f(x_i)\\Delta x $$\n",
    "\n",
    "where\n",
    "\t\n",
    "$$ x_i=a + i \\Delta x $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create our own function that will achieve this type of numerical integration. I will call this function `NIRect` for Numerical Integration using the Rectangle rule. I want to create this function with the following four arguments\n",
    "\n",
    "- `f`: the function that we want to integrate numerically\n",
    "- `a`: the lower limit of integration\n",
    "- `b`: the upper limit of integration\n",
    "- `n`: the number of elements (i.e. rectangles) to use for the integration\n",
    "\n",
    "Your function may look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def NIRect(f, a, b, n):\n",
    "    dx = (b-a)/n\n",
    "    sum = 0\n",
    "    for i in range(n):\n",
    "        sum += f(a + i*dx) * dx\n",
    "   \n",
    "    return sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how you can use this function. First define the function that you need to integrate, say \n",
    "\n",
    "sin(x) from 0 to $\\pi/2$, and then call `NIRect` with the appropriate arguments. Let's use only 10 rectangles, i.e.,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = np.sin\n",
    "a = 0\n",
    "b = np.pi / 2\n",
    "n = 10\n",
    "\n",
    "NIRect(f, a, b, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The integral\n",
    "\n",
    "$$\\int_0^{\\pi/2} \\sin (x) dx$$\n",
    "\n",
    " can in fact be integrated analytically and we know that the exact answer should be \n",
    "\n",
    "$$ -\\cos(\\pi/2) + \\cos(0) = 1 $$\n",
    "\n",
    "We see that using the rectangle rule with 10 rectangles returns 0.919403, which is an error of roughly 8% compared to the exact solution which is exactly "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Let's try with 100 rectangles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = np.sin\n",
    "a = 0\n",
    "b = np.pi / 2\n",
    "n = 100\n",
    "\n",
    "NIRect(f, a, b, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that increasing the number of rectangles produces a more accurate results. Yet, it is not 1. In fact, it will never be 1 unless you use an infinite number of rectangles. So, when doing numerical calculations like this there is always the issue of determining when to stop the integration. For example, if we use 10 billion rectangles the computer may take days to perform the integration. There is always a trade off between limits of computational power and accuracy needed for your application.  \n",
    "\n",
    "Note that we don't need to use the variable `f` for the input function. Here's another example with a function that cannot be integrated analytically\n",
    "\n",
    "$$ g(x) = \\frac{1}{x^2} e^{x^2} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(x):\n",
    "    return 1/x**2 * np.exp(x**2)\n",
    "\n",
    "a = 1\n",
    "b = 2\n",
    "n = 10\n",
    "\n",
    "NIRect(g, a, b, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how I called my function `NIRect` this time with the variable name `g` even though the function is originally defined with the variable `f`. This illustrates the power and flexibility of defining functions. Same can be said with the other arguments. For example `a` and `b` can really be anything else. For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def MyFunction(y):\n",
    "    return 3*y**2 + y\n",
    "\n",
    "LowerLimit = 2.3\n",
    "UpperLimit = 10.2\n",
    "NumRectangles = 100\n",
    "\n",
    "NIRect(MyFunction, LowerLimit, UpperLimit, NumRectangles)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda functions\n",
    "\n",
    "Often, these one-liner functions like `g` and `MyFunction` are defined as lambda functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = lambda x: 1/x**2 * np.exp(x**2)\n",
    "a = 1\n",
    "b = 2\n",
    "n = 10\n",
    "NIRect(g, a, b, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the values can also be passed directly if you really wanted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NIRect(lambda y: 3*y**2 + y, 2.3, 10.2, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical integration: Trapezoidal rule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A more accurate method for solving an integral is to use $n$ trapezoids instead of $n$ rectangles. You should understand where this formulation comes from.\n",
    "\n",
    "$$\\int_a^b f(x) dx \\approx \\frac{1}{2} f(x_0) + \\frac{1}{2} f(x_n)+ \\sum_{i=1}^{n-1} f(x_i) \\Delta x $$\n",
    "\n",
    "where as in the rectangle rule\n",
    "\n",
    " \n",
    " $$\\Delta x = (b-a)/n$$\n",
    "\n",
    "and\n",
    "\n",
    " \t\n",
    "\n",
    "$$x_i=a + i \\Delta x.$$\n",
    "\n",
    "Note how although we use $n$ trapezoids the function needs to be evaluated up to \n",
    " $f(x_n)$ whereas in the rectangle rule the function only needed to be evaluated up to \n",
    " $f(x_{n-1})$. Can you tell why?\n",
    "\n",
    "Here's how this can be coded within a new function that I will call `NITrap`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def NITrap(f, a, b, n):\n",
    "    dx = (b-a)/n\n",
    "    sum = 0.5*(f(a) + f(b)) * dx\n",
    "    for i in range(1, n):\n",
    "        sum = sum + f(a + i*dx) * dx\n",
    "   \n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = np.sin\n",
    "a = 0\n",
    "b = np.pi / 2\n",
    "n = 1000\n",
    "\n",
    "print(NIRect(f, a, b, n))\n",
    "print(NITrap(f, a, b, n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From these outputs it is quite clear that the trapezoid rule is more accurate using the same number of trapezoids as the rectangle rule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing rectangle rule and trapezoid rule\n",
    "\n",
    "The goal of this section is to compare visually the error associated with the rectangle and the trapezoidal rule as a function of the number of elements (rectangles or trapezoids) used. This will require some coding.  \n",
    "\n",
    "The integral to evaluate is\n",
    "\n",
    "$$\\int_a^b f(x) dx $$\n",
    "\n",
    "where\n",
    "\n",
    "\n",
    "$$ f(x)= \\sin(x) + x^3, \\quad a=0, \\quad  b =5 $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise to be done as a class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Define $f(x)$ as Python function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Plot this function between  x=-10 and x=10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Calculate the exact value of the integral above (with a=0 and b=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Evaluate numerically the integral using the rectangle rule with 10 rectangles. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5. Evaluate numerically the integral using the trapezoid rule with 10 trapezoids."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6. Briefly comment on the answers you obtained in 4. and 5. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7. The absolute relative error of the numerical integration can be calculated as follow: \n",
    "\n",
    "$\\Delta$ =|Numerical Solution - Exact Solution|/|Exact Solution|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code this expression for the relative error and calculate $\\Delta$ for the results obtained in 4. and 5. above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 8. Redo the same as in 7. but this time calculate the error when using 100 rectangles or trapezoids to evaluate the integral."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9. It should be clear from your previous calculations that the error reduces significantly by increasing the number of elements and that the trapezoid rule is always more accurate than the rectangle rule.  \n",
    "\n",
    "What would be illuminating would be to plot the relative error for each algorithms (i.e. rectangle and trapezoid rules) as a function of the number $n$ of elements used to approximate numerically the integral. Before coding this you need to become a little more familiar with NumPy arrays.\n",
    "\n",
    "First, use the `np.arange` function  to automatically create the array: [1,2,3,4,5,6,7,8,9,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, starting from this first array and multiplying, create the array: [2,4,6,8,10,12,14,16,18,20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead, try and create the array [2,4,8,16,32,64,128,256,512,1024]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 10. Next, the challenge is to create a two column matrix with the first column containing the number $n$ of elements used in the numerical integration and in the second column the relative error $\\Delta$.  \n",
    "\n",
    "(This can be done with or without loops.)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can plot the results of this analysis like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 11. Redo the same analysis with a graph for the trapezoid rule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 12. Finally compare the results obtained in 11 for the rectangle rule and in 12 for the trapezoid rule on a single graph. Draw a brief conclusion to the results obtained graphically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comment: The trapezoidal rule converges much faster than the rectangle rule to the exact solution."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}