{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SciPy\n",
    "\n",
    "SciPy is a collection of numerical algorithms with python interfaces.  In many cases, these interfaces are wrappers around standard numerical libraries that have been developed in the community and are used with other languages.  Usually detailed references are available to explain the implementation.\n",
    "\n",
    "There are many subpackages generally, you load the subpackages separately, e.g.\n",
    "\n",
    "```\n",
    "from scipy import linalg, optimize\n",
    "```\n",
    "then you have access to the methods in those namespaces\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numerical Methods \n",
    "\n",
    "One thing to keep in mind -- all numerical methods have strengths and weaknesses, and make assumptions.  You should always do some research into the method to understand what it is doing.\n",
    "\n",
    "It is also always a good idea to run a new method on some test where you know the answer, to make sure it is behaving as expected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Integration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we'll do some integrals of the form\n",
    "\n",
    "$$I = \\int_a^b f(x) dx$$\n",
    "\n",
    "We can imagine two situations:\n",
    "* our function $f(x)$ is given by an analytic expression.  This gives us the freedom to pick our integration points, and in general can allow us to optimize our result and get high accuracy\n",
    "* our function $f(x)$ is defined on at a set of (possibly regular spaced) points.  \n",
    "\n",
    "In numerical analysis, the term _quadrature_ is used to describe any integration method that represents the integral as the weighted sum of a discrete number of points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from scipy import integrate\n",
    "#help(integrate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "quad is the basic integrator for a general (not sampled) function.  It uses a general-interface from the Fortran package QUADPACK (QAGS or QAGI).  It will return the integral in an interval and an estimate of the error in the approximation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return np.sin(x)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "2.3058791671639882e-09\n"
     ]
    }
   ],
   "source": [
    "I, err = integrate.quad(f, 0.0, 2.0*np.pi, epsabs=1.e-14)\n",
    "print(I)\n",
    "print(err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function quad in module scipy.integrate.quadpack:\n",
      "\n",
      "quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50)\n",
      "    Compute a definite integral.\n",
      "    \n",
      "    Integrate func from `a` to `b` (possibly infinite interval) using a\n",
      "    technique from the Fortran library QUADPACK.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    func : {function, scipy.LowLevelCallable}\n",
      "        A Python function or method to integrate.  If `func` takes many\n",
      "        arguments, it is integrated along the axis corresponding to the\n",
      "        first argument.\n",
      "    \n",
      "        If the user desires improved integration performance, then `f` may\n",
      "        be a `scipy.LowLevelCallable` with one of the signatures::\n",
      "    \n",
      "            double func(double x)\n",
      "            double func(double x, void *user_data)\n",
      "            double func(int n, double *xx)\n",
      "            double func(int n, double *xx, void *user_data)\n",
      "    \n",
      "        The ``user_data`` is the data contained in the `scipy.LowLevelCallable`.\n",
      "        In the call forms with ``xx``,  ``n`` is the length of the ``xx``\n",
      "        array which contains ``xx[0] == x`` and the rest of the items are\n",
      "        numbers contained in the ``args`` argument of quad.\n",
      "    \n",
      "        In addition, certain ctypes call signatures are supported for\n",
      "        backward compatibility, but those should not be used in new code.\n",
      "    a : float\n",
      "        Lower limit of integration (use -numpy.inf for -infinity).\n",
      "    b : float\n",
      "        Upper limit of integration (use numpy.inf for +infinity).\n",
      "    args : tuple, optional\n",
      "        Extra arguments to pass to `func`.\n",
      "    full_output : int, optional\n",
      "        Non-zero to return a dictionary of integration information.\n",
      "        If non-zero, warning messages are also suppressed and the\n",
      "        message is appended to the output tuple.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    y : float\n",
      "        The integral of func from `a` to `b`.\n",
      "    abserr : float\n",
      "        An estimate of the absolute error in the result.\n",
      "    infodict : dict\n",
      "        A dictionary containing additional information.\n",
      "        Run scipy.integrate.quad_explain() for more information.\n",
      "    message\n",
      "        A convergence message.\n",
      "    explain\n",
      "        Appended only with 'cos' or 'sin' weighting and infinite\n",
      "        integration limits, it contains an explanation of the codes in\n",
      "        infodict['ierlst']\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    epsabs : float or int, optional\n",
      "        Absolute error tolerance.\n",
      "    epsrel : float or int, optional\n",
      "        Relative error tolerance.\n",
      "    limit : float or int, optional\n",
      "        An upper bound on the number of subintervals used in the adaptive\n",
      "        algorithm.\n",
      "    points : (sequence of floats,ints), optional\n",
      "        A sequence of break points in the bounded integration interval\n",
      "        where local difficulties of the integrand may occur (e.g.,\n",
      "        singularities, discontinuities). The sequence does not have\n",
      "        to be sorted.\n",
      "    weight : float or int, optional\n",
      "        String indicating weighting function. Full explanation for this\n",
      "        and the remaining arguments can be found below.\n",
      "    wvar : optional\n",
      "        Variables for use with weighting functions.\n",
      "    wopts : optional\n",
      "        Optional input for reusing Chebyshev moments.\n",
      "    maxp1 : float or int, optional\n",
      "        An upper bound on the number of Chebyshev moments.\n",
      "    limlst : int, optional\n",
      "        Upper bound on the number of cycles (>=3) for use with a sinusoidal\n",
      "        weighting and an infinite end-point.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    dblquad : double integral\n",
      "    tplquad : triple integral\n",
      "    nquad : n-dimensional integrals (uses `quad` recursively)\n",
      "    fixed_quad : fixed-order Gaussian quadrature\n",
      "    quadrature : adaptive Gaussian quadrature\n",
      "    odeint : ODE integrator\n",
      "    ode : ODE integrator\n",
      "    simps : integrator for sampled data\n",
      "    romb : integrator for sampled data\n",
      "    scipy.special : for coefficients and roots of orthogonal polynomials\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    \n",
      "    **Extra information for quad() inputs and outputs**\n",
      "    \n",
      "    If full_output is non-zero, then the third output argument\n",
      "    (infodict) is a dictionary with entries as tabulated below.  For\n",
      "    infinite limits, the range is transformed to (0,1) and the\n",
      "    optional outputs are given with respect to this transformed range.\n",
      "    Let M be the input argument limit and let K be infodict['last'].\n",
      "    The entries are:\n",
      "    \n",
      "    'neval'\n",
      "        The number of function evaluations.\n",
      "    'last'\n",
      "        The number, K, of subintervals produced in the subdivision process.\n",
      "    'alist'\n",
      "        A rank-1 array of length M, the first K elements of which are the\n",
      "        left end points of the subintervals in the partition of the\n",
      "        integration range.\n",
      "    'blist'\n",
      "        A rank-1 array of length M, the first K elements of which are the\n",
      "        right end points of the subintervals.\n",
      "    'rlist'\n",
      "        A rank-1 array of length M, the first K elements of which are the\n",
      "        integral approximations on the subintervals.\n",
      "    'elist'\n",
      "        A rank-1 array of length M, the first K elements of which are the\n",
      "        moduli of the absolute error estimates on the subintervals.\n",
      "    'iord'\n",
      "        A rank-1 integer array of length M, the first L elements of\n",
      "        which are pointers to the error estimates over the subintervals\n",
      "        with ``L=K`` if ``K<=M/2+2`` or ``L=M+1-K`` otherwise. Let I be the\n",
      "        sequence ``infodict['iord']`` and let E be the sequence\n",
      "        ``infodict['elist']``.  Then ``E[I[1]], ..., E[I[L]]`` forms a\n",
      "        decreasing sequence.\n",
      "    \n",
      "    If the input argument points is provided (i.e. it is not None),\n",
      "    the following additional outputs are placed in the output\n",
      "    dictionary.  Assume the points sequence is of length P.\n",
      "    \n",
      "    'pts'\n",
      "        A rank-1 array of length P+2 containing the integration limits\n",
      "        and the break points of the intervals in ascending order.\n",
      "        This is an array giving the subintervals over which integration\n",
      "        will occur.\n",
      "    'level'\n",
      "        A rank-1 integer array of length M (=limit), containing the\n",
      "        subdivision levels of the subintervals, i.e., if (aa,bb) is a\n",
      "        subinterval of ``(pts[1], pts[2])`` where ``pts[0]`` and ``pts[2]``\n",
      "        are adjacent elements of ``infodict['pts']``, then (aa,bb) has level l\n",
      "        if ``|bb-aa| = |pts[2]-pts[1]| * 2**(-l)``.\n",
      "    'ndin'\n",
      "        A rank-1 integer array of length P+2.  After the first integration\n",
      "        over the intervals (pts[1], pts[2]), the error estimates over some\n",
      "        of the intervals may have been increased artificially in order to\n",
      "        put their subdivision forward.  This array has ones in slots\n",
      "        corresponding to the subintervals for which this happens.\n",
      "    \n",
      "    **Weighting the integrand**\n",
      "    \n",
      "    The input variables, *weight* and *wvar*, are used to weight the\n",
      "    integrand by a select list of functions.  Different integration\n",
      "    methods are used to compute the integral with these weighting\n",
      "    functions.  The possible values of weight and the corresponding\n",
      "    weighting functions are.\n",
      "    \n",
      "    ==========  ===================================   =====================\n",
      "    ``weight``  Weight function used                  ``wvar``\n",
      "    ==========  ===================================   =====================\n",
      "    'cos'       cos(w*x)                              wvar = w\n",
      "    'sin'       sin(w*x)                              wvar = w\n",
      "    'alg'       g(x) = ((x-a)**alpha)*((b-x)**beta)   wvar = (alpha, beta)\n",
      "    'alg-loga'  g(x)*log(x-a)                         wvar = (alpha, beta)\n",
      "    'alg-logb'  g(x)*log(b-x)                         wvar = (alpha, beta)\n",
      "    'alg-log'   g(x)*log(x-a)*log(b-x)                wvar = (alpha, beta)\n",
      "    'cauchy'    1/(x-c)                               wvar = c\n",
      "    ==========  ===================================   =====================\n",
      "    \n",
      "    wvar holds the parameter w, (alpha, beta), or c depending on the weight\n",
      "    selected.  In these expressions, a and b are the integration limits.\n",
      "    \n",
      "    For the 'cos' and 'sin' weighting, additional inputs and outputs are\n",
      "    available.\n",
      "    \n",
      "    For finite integration limits, the integration is performed using a\n",
      "    Clenshaw-Curtis method which uses Chebyshev moments.  For repeated\n",
      "    calculations, these moments are saved in the output dictionary:\n",
      "    \n",
      "    'momcom'\n",
      "        The maximum level of Chebyshev moments that have been computed,\n",
      "        i.e., if ``M_c`` is ``infodict['momcom']`` then the moments have been\n",
      "        computed for intervals of length ``|b-a| * 2**(-l)``,\n",
      "        ``l=0,1,...,M_c``.\n",
      "    'nnlog'\n",
      "        A rank-1 integer array of length M(=limit), containing the\n",
      "        subdivision levels of the subintervals, i.e., an element of this\n",
      "        array is equal to l if the corresponding subinterval is\n",
      "        ``|b-a|* 2**(-l)``.\n",
      "    'chebmo'\n",
      "        A rank-2 array of shape (25, maxp1) containing the computed\n",
      "        Chebyshev moments.  These can be passed on to an integration\n",
      "        over the same interval by passing this array as the second\n",
      "        element of the sequence wopts and passing infodict['momcom'] as\n",
      "        the first element.\n",
      "    \n",
      "    If one of the integration limits is infinite, then a Fourier integral is\n",
      "    computed (assuming w neq 0).  If full_output is 1 and a numerical error\n",
      "    is encountered, besides the error message attached to the output tuple,\n",
      "    a dictionary is also appended to the output tuple which translates the\n",
      "    error codes in the array ``info['ierlst']`` to English messages.  The\n",
      "    output information dictionary contains the following entries instead of\n",
      "    'last', 'alist', 'blist', 'rlist', and 'elist':\n",
      "    \n",
      "    'lst'\n",
      "        The number of subintervals needed for the integration (call it ``K_f``).\n",
      "    'rslst'\n",
      "        A rank-1 array of length M_f=limlst, whose first ``K_f`` elements\n",
      "        contain the integral contribution over the interval\n",
      "        ``(a+(k-1)c, a+kc)`` where ``c = (2*floor(|w|) + 1) * pi / |w|``\n",
      "        and ``k=1,2,...,K_f``.\n",
      "    'erlst'\n",
      "        A rank-1 array of length ``M_f`` containing the error estimate\n",
      "        corresponding to the interval in the same position in\n",
      "        ``infodict['rslist']``.\n",
      "    'ierlst'\n",
      "        A rank-1 integer array of length ``M_f`` containing an error flag\n",
      "        corresponding to the interval in the same position in\n",
      "        ``infodict['rslist']``.  See the explanation dictionary (last entry\n",
      "        in the output tuple) for the meaning of the codes.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    Calculate :math:`\\int^4_0 x^2 dx` and compare with an analytic result\n",
      "    \n",
      "    >>> from scipy import integrate\n",
      "    >>> x2 = lambda x: x**2\n",
      "    >>> integrate.quad(x2, 0, 4)\n",
      "    (21.333333333333332, 2.3684757858670003e-13)\n",
      "    >>> print(4**3 / 3.)  # analytical result\n",
      "    21.3333333333\n",
      "    \n",
      "    Calculate :math:`\\int^\\infty_0 e^{-x} dx`\n",
      "    \n",
      "    >>> invexp = lambda x: np.exp(-x)\n",
      "    >>> integrate.quad(invexp, 0, np.inf)\n",
      "    (1.0, 5.842605999138044e-11)\n",
      "    \n",
      "    >>> f = lambda x,a : a*x\n",
      "    >>> y, err = integrate.quad(f, 0, 1, args=(1,))\n",
      "    >>> y\n",
      "    0.5\n",
      "    >>> y, err = integrate.quad(f, 0, 1, args=(3,))\n",
      "    >>> y\n",
      "    1.5\n",
      "    \n",
      "    Calculate :math:`\\int^1_0 x^2 + y^2 dx` with ctypes, holding\n",
      "    y parameter as 1::\n",
      "    \n",
      "        testlib.c =>\n",
      "            double func(int n, double args[n]){\n",
      "                return args[0]*args[0] + args[1]*args[1];}\n",
      "        compile to library testlib.*\n",
      "    \n",
      "    ::\n",
      "    \n",
      "       from scipy import integrate\n",
      "       import ctypes\n",
      "       lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path\n",
      "       lib.func.restype = ctypes.c_double\n",
      "       lib.func.argtypes = (ctypes.c_int,ctypes.c_double)\n",
      "       integrate.quad(lib.func,0,1,(1))\n",
      "       #(1.3333333333333333, 1.4802973661668752e-14)\n",
      "       print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result\n",
      "       # 1.3333333333333333\n",
      "    \n",
      "    Be aware that pulse shapes and other sharp features as compared to the\n",
      "    size of the integration interval may not be integrated correctly using\n",
      "    this method. A simplified example of this limitation is integrating a\n",
      "    y-axis reflected step function with many zero values within the integrals\n",
      "    bounds.\n",
      "    \n",
      "    >>> y = lambda x: 1 if x<=0 else 0\n",
      "    >>> integrate.quad(y, -1, 1)\n",
      "    (1.0, 1.1102230246251565e-14)\n",
      "    >>> integrate.quad(y, -1, 100)\n",
      "    (1.0000000002199108, 1.0189464580163188e-08)\n",
      "    >>> integrate.quad(y, -1, 10000)\n",
      "    (0.0, 0.0)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(integrate.quad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sometimes our integrand function takes optional arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(x, A, sigma):\n",
    "    return A*np.exp(-x**2/sigma**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8451240256511698 2.0484991765669867e-14\n"
     ]
    }
   ],
   "source": [
    "I, err = integrate.quad(g, -1.0, 1.0, args=(1.0, 2.0))\n",
    "print(I, err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "numpy defines the inf quantity which can be used in the integration limits.  We can integrate a Gaussian (we know the answer is sqrt(pi)\n",
    "\n",
    "Note: behind the scenes, what the integration function does is do a variable transform like: $t = 1/x$.  This works when one limit is $\\infty$, giving\n",
    "\n",
    "$$\\int_a^b f(x) dx = \\int_{1/b}^{1/a} \\frac{1}{t^2} f\\left (\\frac{1}{t}\\right) dt$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.7724538509055159 1.4202636780944923e-08\n",
      "1.7724538509055159\n"
     ]
    }
   ],
   "source": [
    "I, err = integrate.quad(g, -np.inf, np.inf, args=(1.0, 1.0))\n",
    "print(I, err)\n",
    "x=np.sqrt(np.pi)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multidimensional integrals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "multidimensional integration can be done with successive calls to quad(), but there are wrappers that help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compute \n",
    "\n",
    "$$I = \\int_{y=0}^{1/2} \\int_{x=0}^{1-2y} xy dxdy = \\frac{1}{96}$$\n",
    "\n",
    "(this example comes from the SciPy tutorial)\n",
    "\n",
    "Notice that the limits of integration in x depend on y.\n",
    "\n",
    "Note the form of the function:\n",
    "\n",
    "```\n",
    "dblquad(f, a, b, ylo, yhi)\n",
    "```\n",
    "where `f` = `f(y, x)` -- the y argument is first\n",
    "\n",
    "The integral will be from: $x = [a,b]$, and $y$ = `ylo(x)`, $y$ = `yhi(x)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010416666666666668 95.99999999999999\n"
     ]
    }
   ],
   "source": [
    "def integrand(x,y):\n",
    "    return x*y\n",
    "\n",
    "def x_lower_lim(y):\n",
    "    return 0\n",
    "    \n",
    "def x_upper_lim(y):\n",
    "    return 1-2*y\n",
    "\n",
    "# we change the definitions of x and y in this call\n",
    "I, err = integrate.dblquad(integrand, 0.0, 0.5, x_lower_lim, x_upper_lim)\n",
    "print(I, 1.0/I)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you remember the python lambda functions (one expression functions), you can do this more compactly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010416666666666668\n"
     ]
    }
   ],
   "source": [
    "I, err = integrate.dblquad(lambda x, y: x*y, 0.0, 0.5, lambda y: 0, lambda y: 1-2*y)\n",
    "print(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### integration of a sampled function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "here we integrate a function that is defined only at a sequece of points.  Recall that Simpson's rule will use piecewise parabola data.  Let's compute\n",
    "\n",
    "$$I = \\int_0^{2\\pi} f(x_i) dx$$\n",
    "\n",
    "with $x_i = 0, \\ldots, 2\\pi$ defined at $N$ points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "N = 17\n",
    "x = np.linspace(0.0, 2.0*np.pi, N, endpoint=True)\n",
    "y = np.sin(x)**2\n",
    "\n",
    "I = integrate.simps(y, x)\n",
    "print(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Romberg integration is specific to equally-spaced samples, where $N = 2^k + 1$  and can be more converge faster (it uses extrapolation of coarser integration results to achieve higher accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1430658353300385\n"
     ]
    }
   ],
   "source": [
    "N = 17\n",
    "x = np.linspace(0.0, 2.0*np.pi, N, endpoint=True)\n",
    "y = np.sin(x)**2\n",
    "\n",
    "I = integrate.romb(y, dx=x[1]-x[0])\n",
    "print(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interpolation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpolation fills in the gaps between a discrete number of points by making an assumption about the behavior of the functional form of the data.\n",
    "\n",
    "Many different types of interpolation exist\n",
    "* some ensure no new extrema are introduced\n",
    "* some conserve the quantity being interpolated\n",
    "* some match derivative at end points\n",
    "\n",
    "Pathologies exist -- it is not always best to use a high-order polynomial to pass through all of the points in your dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the `interp1d()` function allows for a variety of 1-d interpolation methods.  It returns an object that acts as a function, which can be evaluated at any point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.interpolate as interpolate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class interp1d in module scipy.interpolate.interpolate:\n",
      "\n",
      "class interp1d(scipy.interpolate.polyint._Interpolator1D)\n",
      " |  interp1d(x, y, kind='linear', axis=-1, copy=True, bounds_error=None, fill_value=nan, assume_sorted=False)\n",
      " |  \n",
      " |  Interpolate a 1-D function.\n",
      " |  \n",
      " |  `x` and `y` are arrays of values used to approximate some function f:\n",
      " |  ``y = f(x)``.  This class returns a function whose call method uses\n",
      " |  interpolation to find the value of new points.\n",
      " |  \n",
      " |  Note that calling `interp1d` with NaNs present in input values results in\n",
      " |  undefined behaviour.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  x : (N,) array_like\n",
      " |      A 1-D array of real values.\n",
      " |  y : (...,N,...) array_like\n",
      " |      A N-D array of real values. The length of `y` along the interpolation\n",
      " |      axis must be equal to the length of `x`.\n",
      " |  kind : str or int, optional\n",
      " |      Specifies the kind of interpolation as a string\n",
      " |      ('linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',\n",
      " |      'previous', 'next', where 'zero', 'slinear', 'quadratic' and 'cubic'\n",
      " |      refer to a spline interpolation of zeroth, first, second or third\n",
      " |      order; 'previous' and 'next' simply return the previous or next value\n",
      " |      of the point) or as an integer specifying the order of the spline\n",
      " |      interpolator to use.\n",
      " |      Default is 'linear'.\n",
      " |  axis : int, optional\n",
      " |      Specifies the axis of `y` along which to interpolate.\n",
      " |      Interpolation defaults to the last axis of `y`.\n",
      " |  copy : bool, optional\n",
      " |      If True, the class makes internal copies of x and y.\n",
      " |      If False, references to `x` and `y` are used. The default is to copy.\n",
      " |  bounds_error : bool, optional\n",
      " |      If True, a ValueError is raised any time interpolation is attempted on\n",
      " |      a value outside of the range of x (where extrapolation is\n",
      " |      necessary). If False, out of bounds values are assigned `fill_value`.\n",
      " |      By default, an error is raised unless `fill_value=\"extrapolate\"`.\n",
      " |  fill_value : array-like or (array-like, array_like) or \"extrapolate\", optional\n",
      " |      - if a ndarray (or float), this value will be used to fill in for\n",
      " |        requested points outside of the data range. If not provided, then\n",
      " |        the default is NaN. The array-like must broadcast properly to the\n",
      " |        dimensions of the non-interpolation axes.\n",
      " |      - If a two-element tuple, then the first element is used as a\n",
      " |        fill value for ``x_new < x[0]`` and the second element is used for\n",
      " |        ``x_new > x[-1]``. Anything that is not a 2-element tuple (e.g.,\n",
      " |        list or ndarray, regardless of shape) is taken to be a single\n",
      " |        array-like argument meant to be used for both bounds as\n",
      " |        ``below, above = fill_value, fill_value``.\n",
      " |  \n",
      " |        .. versionadded:: 0.17.0\n",
      " |      - If \"extrapolate\", then points outside the data range will be\n",
      " |        extrapolated.\n",
      " |  \n",
      " |        .. versionadded:: 0.17.0\n",
      " |  assume_sorted : bool, optional\n",
      " |      If False, values of `x` can be in any order and they are sorted first.\n",
      " |      If True, `x` has to be an array of monotonically increasing values.\n",
      " |  \n",
      " |  Methods\n",
      " |  -------\n",
      " |  __call__\n",
      " |  \n",
      " |  See Also\n",
      " |  --------\n",
      " |  splrep, splev\n",
      " |      Spline interpolation/smoothing based on FITPACK.\n",
      " |  UnivariateSpline : An object-oriented wrapper of the FITPACK routines.\n",
      " |  interp2d : 2-D interpolation\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |  >>> import matplotlib.pyplot as plt\n",
      " |  >>> from scipy import interpolate\n",
      " |  >>> x = np.arange(0, 10)\n",
      " |  >>> y = np.exp(-x/3.0)\n",
      " |  >>> f = interpolate.interp1d(x, y)\n",
      " |  \n",
      " |  >>> xnew = np.arange(0, 9, 0.1)\n",
      " |  >>> ynew = f(xnew)   # use interpolation function returned by `interp1d`\n",
      " |  >>> plt.plot(x, y, 'o', xnew, ynew, '-')\n",
      " |  >>> plt.show()\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      interp1d\n",
      " |      scipy.interpolate.polyint._Interpolator1D\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, x, y, kind='linear', axis=-1, copy=True, bounds_error=None, fill_value=nan, assume_sorted=False)\n",
      " |      Initialize a 1D linear interpolation class.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  fill_value\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from scipy.interpolate.polyint._Interpolator1D:\n",
      " |  \n",
      " |  __call__(self, x)\n",
      " |      Evaluate the interpolant\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : array_like\n",
      " |          Points to evaluate the interpolant at.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      y : array_like\n",
      " |          Interpolated values. Shape is determined by replacing\n",
      " |          the interpolation axis in the original array with the shape of x.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from scipy.interpolate.polyint._Interpolator1D:\n",
      " |  \n",
      " |  dtype\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help (interpolate.interp1d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x181921d6a0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsnXd4VEX3xz+TUAIEQgvSCSg9QIDQTIAgXVC6gsgLNqxYftZXBLHwiqKC2BAbKhFQEGyISicgQkBApEgLEGpChwBp8/vjbEISdjdte+bzPPvs3ntn75xsds+de+bM9yitNQaDwWDwffzcbYDBYDAYXINx+AaDwVBEMA7fYDAYigjG4RsMBkMRwTh8g8FgKCIYh28wGAxFhEI7fKVULaXUcqXUDqXUP0qpxyz7KyqlfldK7bY8Vyi8uQaDwWAoKKqwefhKqWpANa31JqVUWWAj0B8YBZzSWk9SSj0HVNBaP1tYgw0Gg8FQMAo9wtdaH9Vab7K8Pg/sAGoA/YAvLM2+QC4CBoPBYHAThR7hZzuZUiHAKiAUOKi1Lp/l2Gmttd2wTuXKlXVISIjD7DEYDIaiwMaNGxO11sG5tSvmqA6VUoHAfOBxrfU5pVRe3zcaGA1Qu3ZtYmNjHWWSwWAwFAmUUgfy0s4hWTpKqeKIs4/WWn9n2X3cEt/PiPOfsPZerfUMrXW41jo8ODjXC5TBYDAYCogjsnQU8CmwQ2v9dpZDPwAjLa9HAt8Xti+DwWAwFBxHhHQigBHA30qpzZZ9zwOTgG+UUvcAB4EhDujLYDAYDAWk0A5fax0D2ArYdy3s+Q0Gg8HgGMxKW4PBYCgiGIdvMBgM7iQ6GkJCwM9PnqOjndaVw9IyDQaDwZBPoqNh9GhISpLtAwdkG2D4cId3Z0b4BoPB4C7Gjr3q7DNISpL9TsA4/FyIi4sjNDTU3WYUihtvvDHXNlOnTiUp5xfPYDA4l4MH87e/kPiew3dhPMxbWLt2ba5tjMM3GNxA7dpsoTkXKMNxqmTb7wx8y+FnxMMOHACtr8bDHOT09+3bR8uWLdmwYQMzZ85k4MCB9OrVi/r16/PMM89ktps9ezbNmjUjNDSUZ58VgdBvvvmG//u//wPgnXfeoV69egDs3buXyMhIAEJCQnjxxRdp1aoVzZo1Y+fOndfYMHPmTPr160evXr1o2LAhL730Uuaxt99+m9DQUEJDQ5k6dWrm/sDAQABWrFhBVFQUgwcPplGjRgwfPhytNdOmTePIkSN06dKFLl26kJaWxqhRowgNDaVZs2ZMmTLFIZ+fwWDIwcSJXC4RRCAXCeCS7CtdGiZOdE5/WmuPebRu3VoXijp1tBZXn/1Rp06BT7l//37dtGlTvXPnTh0WFqb/+usvrbXWn3/+ua5bt64+c+aMvnTpkq5du7Y+ePCgPnz4sK5Vq5Y+ceKETklJ0V26dNELFizQR48e1eHh4VprrQcNGqTDw8N1fHy8njlzpn7uuecs5tfR06ZN01pr/f777+t77rnnGns+//xzXbVqVZ2YmKiTkpJ006ZN9YYNG3RsbKwODQ3VFy5c0OfPn9dNmjTRmzZt0lprXaZMGa211suXL9flypXThw4d0mlpabp9+/Z69erVmX0nJCRorbWOjY3V3bp1y+zz9OnTBf78DAZDLkyblt1XzZqV71MAsToPPta3RvhOioclJCTQr18/Zs2aRVhYWOb+rl27EhQUREBAAE2aNOHAgQNs2LCBqKgogoODKVasGMOHD2fVqlVUrVqVCxcucP78eQ4dOsQdd9zBqlWrWL16NR07dsw858CBAwFo3bo1cXFxVu3p3r07lSpVolSpUgwcOJCYmBhiYmIYMGAAZcqUITAwkIEDB7J69epr3tu2bVtq1qyJn58fYWFhVvuoV68e+/btY8yYMSxevJhy5coV6vMzGAzWSU+H1Bs7ycb8+RAX55TsnAx8y+HbinsVMh4WFBRErVq1WLNmTbb9JUuWzHzt7+9Pamoq2o7cdIcOHfj8889p2LAhHTt2ZPXq1fzxxx9ERERcc86M81kjpxKpUspuv7nZnJMKFSqwZcsWoqKieP/997n33nvzdG6DwZA/Nm6EAR0TZaNyZaf351sOf+JEiX9lxQHxsBIlSrBw4UK+/PJLvv76a7tt27Vrx8qVK0lMTCQtLY3Zs2fTuXNnADp16sSbb75Jp06daNmyJcuXL6dkyZIEBQXly57ff/+dU6dOcenSJRYuXEhERASdOnVi4cKFJCUlcfHiRRYsWJDtziE3ypYty/nz5wFITEwkPT2dQYMG8corr7Bp06Z82WcwGPJG2bLQPyJBNlzg8H1r4VXGrdDYsRLGqV1bnL0DbpHKlCnDTz/9RPfu3SlTpozNdtWqVeO1116jS5cuaK25+eab6devHwAdO3bk0KFDdOrUCX9/f2rVqkWjRo3ybUtkZCQjRoxgz5493HHHHYSHhwMwatQo2rZtC8C9995Ly5Yt83zO0aNH07t3b6pVq8bUqVO56667SE9PB+C1117Lt40GgyF3GjWCRv0SYQkucfgOrXhVWMLDw7UpgGKfmTNnEhsby3vvveduUwwGQyFISYFjx6DWpxPg5ZchORmKFWwMrpTaqLUOz62db4V0DAaDwUvYsEGCEHGxiVChQoGdfX4wDt/LGDVqlBndGww+QEgITJkC1YoluCScA8bhGwwGg1uoXh0efxxKnk8EF5V3NQ7fYDAYXExaGixbBufPA4mJZoRvMBgMvsrOndC1KyxciHH4BoPB4MuEhMDixdCju4YEL4vhK6U+U0qdUEpty7JvglLqsFJqs+VxsyP68jVWrFhhU83yypUrdOvWjbCwMObOneuwPhcuXMj27dszt8ePH8+SJUscdn6DwWCfMmWgZ0+4rvR5yc90UQzfUXlAM4H3gC9z7J+itX7TQX34JCtWrCAwMNCqZv1ff/1FSkoKmzdvdmifCxcupG/fvjRp0gSAl19+2aHnNxgM9lm4EBo2hMYlXSerAA4a4WutVwGnHHEuT2TWrFm0bduWsLAw7r//ftLS0jhw4AD169fPlCHo2LEjv/32GwD9+/endevWNG3alBkzZmSeZ/HixbRq1YoWLVrQtWtX4uLimD59OlOmTCEsLCyb2NmJEye488472bx5M2FhYezdu5eQkBASE+ULEhsbS1RUFAATJkzg7rvvJioqinr16jFt2rTM83z55Zc0b96cFi1aMGLECNauXcsPP/zA008/nXneUaNGMW/ePACWLl1Ky5YtadasGXfffTdXrlwB8ibdbDAYcictTRb/T5+OxO/BZQ7fYdLGQAiwLcv2BCAO2Ap8BlSw8b7RQCwQW7t27VxlQDt31vrzz+V1crJsf/WVbF+8KNtz5sj2mTOyPX++bCckyPYPP8j20aO5dqe3b9+u+/btq5OTk7XWWj/44IP6iy++0Fpr/fHHH+tBgwbpN954Q48ePTrzPSdPntRa60z54sTERH3ixAlds2ZNvW/fvmxtXnzxRT158mSrfS9fvlz36dMnczurhPGGDRt0586dM8/RoUMHffnyZZ2QkKArVqyok5OT9bZt23SDBg0y35PR58iRI/W3336bed6M7UuXLumaNWvqXbt2aa21HjFihJ4yZUpm37lJNxsMhtxJT9d6716t4+K01j/9JLLI69YV6px4gDzyh8D1QBhwFHjLxgVnhtY6XGsdHuyiOFZ+WLp0KRs3bqRNmzaEhYWxdOlS9u3bB4hezfnz55k+fTpvvnk1cjVt2jRatGhB+/btOXToELt372bdunV06tSJunXrAlCxYkWH2tmnTx9KlixJ5cqVqVKlCsePH2fZsmUMHjyYypbRQ2597tq1i7p169KgQQMARo4cyapVqzKP50W62WAw2EcpqFcP6tTh6gjfy2L416C1Pp7xWin1MfCTI867YsXV18WLZ98uXTr7dlBQ9u3KlbNvV62ae39aa0aOHGlVQCwpKYn4+HgALly4QNmyZVmxYgVLlizhjz/+oHTp0kRFRXH58mW01tfIGueXYsWKZQqaXb58OdsxW1LN+elT56KrlBfpZoPBYJ8ffoDUVBg4EJeHdJw2wldKVcuyOQDYZqutJ9O1a1fmzZvHiRMnADh16hQHDhwA4Nlnn2X48OG8/PLL3HfffQCcPXuWChUqULp0aXbu3Mm6desA0cJfuXIl+/fvzzwPZJclzo2QkBA2btwIwPz58/Nk+zfffMPJkyfz1GejRo2Ii4tjz549AHz11VeZ0s4Gg8ExTJ0Kb2XEOxITZeRatqxL+nZUWuZs4A+goVIqXil1D/CGUupvpdRWoAvwhCP6cjVNmjTh1VdfpUePHjRv3pzu3btz9OhRVq5cyYYNGzKdfokSJfj888/p1asXqampNG/enHHjxtG+fXsAgoODmTFjBgMHDqRFixbcfvvtANxyyy0sWLDgmklba7z44os89thjdOzYEX9//1xtb9q0KWPHjqVz5860aNEis6bu0KFDmTx5Mi1btmTv3r2Z7QMCAvj8888ZMmQIzZo1w8/PjwceeKCgH53Bh1i6FBYtcrcVvsGvv4IlR0Jy8IODJc7jAow8ssFgsMqFC5IvrhT06iVSvg7OEDb07w/798OWLYU6jZFHNhgMBebYMWjZEjIyfOfNk5KrAEePZhmhGvLFypUifX/xomWHC2UVwDh8g8FghSpV4KaboE0b2Q4MhOuvl9fjxsG998Lp0+6zz1tZswbeeAMycyxc7PBNSMdgMOSLs2fh0CEIDXW3Jd7J5csQEGDZqFQJhg2DQta4MCEdg8GQb3bvhnbtYJudnLqgoKvO3pJ0ZsgHmc4+NVVuk0xIx2AwuIOjRyEpKW/rgD77TMI8u3c73y5fID4eRozIMvF9+jRobRy+wWBwD506wdatcN11ube9+WaYNEni/YbcOXxYFn4mJVl2JCTIs3H4noU1JcucTJ06laTM/6TzmDlzJo888kiB3nvmzBk++OADB1tk8AW0lhWgaWl5TwmvWhWeeUZCPIbcaddO5j4y3YmLZRXAOPw8YUuvPisFcfhpaWkFNalAGIdvsMXatdCvH8yenf/3/vorLFjgeJt8HlcrZWIcfp4IDAwERLs+KiqKwYMH06hRI4YPH47WmmnTpnHkyBG6dOlCly5dAPjtt9/o0KEDrVq1YsiQIVy4cAEQeYSXX36ZyMhIvv32W6Kionj88ce58cYbCQ0NZf369YDIIPTv35/mzZvTvn17tm7deo1dP/74I+3ataNly5Z069aN48dFvsiWXPJzzz3H3r17CQsL4+mnn3b652bwHtq1g59/lnVA+eV//5NUQ4N97rrr6roGwC0O32niaU7h8ccdv9QvLEzELfLIX3/9xT///EP16tWJiIhgzZo1PProo7z99tssX76cypUrk5iYyKuvvsqSJUsoU6YMr7/+Om+//Tbjx48HRMIgJiYGgOnTp3Px4kXWrl3LqlWruPvuu9m2bRsvvvgiLVu2ZOHChSxbtoz//Oc/1xRCiYyMZN26dSil+OSTT3jjjTd4yyLSsXPnTpYvX8758+dp2LAhDz74IJMmTWLbtm0OL6hi8H6KFZOYfEGYNStvMf+iztGjYBHLFdwQw/cuh+8BtG3blpo1awIQFhZGXFwckZGR2dqsW7eO7du3ExERAUBycjIdOnTIPJ6ho5PBsGHDAOjUqRPnzp3jzJkzxMTEZAqk3XTTTZw8eZKzZ89me198fDy33347R48eJTk5OVN6Ga7KJZcsWTJTLtlgsMavv8I//8DDD2dZEJQPatVyvE2+yOLFOXYkJopoWkE+9ALiXQ4/HyNxZ2FNhjgnWmu6d+/ObBsB0TJlymTbzilhrJSyKlWcs92YMWP4v//7P2699VZWrFjBhAkT8mWnwQDwyy8Sg3/88YKfY/lyeOEF+OknqFDBcbb5NC5eZQsmhu8wskoOt2/fnjVr1mTKDCclJfHvv//afG9GgfKYmBiCgoIICgqiU6dOREdHAzJ3ULlyZcqVK5ftfWfPnqVGjRoAfPHFF/my0WDIYOpUiZT6FcIblColtbiPHHGcXb7Eu+9Ct26y1ioTNzh87xrhezCjR4+md+/eVKtWjeXLlzNz5kyGDRuWWRP21VdfzawklZMKFSpw4403cu7cOT777DNAJl7vuusumjdvTunSpa069AkTJjBkyBBq1KhB+/btM7X2bVGpUiUiIiIIDQ2ld+/eTJ48uZB/tcFXKOyovH17sOQbGKxQsqREb4pl9bgJCS6f/DBaOm4mKiqKN998k/DwXGUwDAaHojV07SrpmI89luXAjh0wc6bkh3foAK1ayRA+D2RkGuehXIMhJAQ6d4Y83J3nhtHSMRgMdrl0SVbJZhZbiomBW26BJk2kJNPTT0NkpKysGjsWLOU1bbF5swxYly1zvu1ej9Zw4oRLF12BcfhuZ8WKFWZ0b3ALpUvDnDlw993IiquOHWHdOpgwQQTxjx2DhQthyBBJth8yJIsuwLU0aAB9+0LFii77E7yCHTukYPnSpVl2XrggV1wXh3RMDN9gKKKcP28Z3a9bJ6uCOnWSlJ3Spa826tcPbr0VwsPhySelzY8/QrVq15yvdGmJBBmyo5TcKFWvnmVnRpp01aoutcWM8A2GIsjJkyLF/vWkg7K8tkYNKWmV1dlnoBQ88QR8/z3s3CntU1Jsnvv4cYlWGIRGjSA6Gho3zrLz2DF5dvEI31FFzD9TSp1QSm3Lsq+iUup3pdRuy7PJzjUYPIT0dBj3ZBIDPr9FQgs//ZR7iuAtt4gm8vr18MorVpucOSPXDiPZdBWrkllePsKfCfTKse85YKnWuj6w1LJtMBg8gOBgGFf+XUr9u1UC+dmGn3a47Tb4z39g4kSp15eD8uXho48gx2LyIk1YmKxizoY3j/C11quAUzl29wMy8o2+AAogy2QwGBxNWhpsXHEePXky9OoFvXvn7wTvviuzkHfeCefOXXP4nnvyfv0oCgwZIjH8bBw/LivdfGil7XVa66MAlmerZRKUUqOVUrFKqdiEDDEhg8HgNNavh3ld3kOdPCkZOfmlXDn46is4eBCeffaaw6mpsHo1WBaaF3nGj5eytdk4flxus1y8YMHtk7Za6xla63CtdXiwi3NSDYYiRXQ0hITQ+MbyTFAvkxIaJrrIBSEiQuIUH398jWe/cgVuuknC/UWdS5dyyClkcOyYWyRGnenwjyulqgFYns28vcHgLqKjYfRoOHCA8pylpL5M8d07ZH9Bef55KFHimruEMmVgyRJ46qnCmewLTJ0qn8c1yxeOH/c5h/8DMNLyeiTwvRP7MhgM9hg7FpKSSKASVyhBCv4yFB87tuDnrFoVHn0Uvv4atm3LdqhzZ7MACyR2/8ILVrJdjx1zeYYOOC4tczbwB9BQKRWvlLoHmAR0V0rtBrpbtg0Ggzs4eBCAfdSjJMnsp262/QXmmWdk9ZaluE8G58/DJ5+Izn5RpmNHGDcux06tvXuEr7UeprWuprUurrWuqbX+VGt9UmvdVWtd3/KcM4vHYDC4itq1AWjLBi4RwA3syba/wFSsKCtwFyyALMKHaWkSQfrxx8Kd3pvRWq6n10gQnT8Ply97r8M3GAwezsSJEBCAAkpxWX74pUvL/sLy+OOybPellzJ3lS8Pe/daTeIpMpw4Idmr77+f40BGDr63hnQMBoOHM3w457oOAOAw1cUTzZgBw4cX/tzlyknGzs8/i5e3ULeuqDIUVQICYPp0KXySjYxVtmaEbzAYnILW+G3exEo6cXLLYYiLc4yzz+D++yWn/MMPM3cdPSoKy1u3Oq4bbyIoSD6WaxahuUlWAYzDNxiKBhs3Enh4F23euZPQUCecv3p1GDBAku8tOYj+/rIod8sWJ/TnBezdKxe9a3CTrAIYh28wFA2io6FECUqPGFyo2rV2eeQROH1atPWR4ipnz8KIEU7qz8N57DFRrriGDFmFSpVcbpNx+AavoWdPePttd1vhhaSmkhY9m/XBfdh6yImitR07QmgovPeepKggtVyLKv/9L0yylox+7JhcDd1QB9I4fIPHsmEDvPHG1e2yZWUiDKT+88iREB/vHtu8iuXL8U84zseX7sytSmHhUEpG+Zs3wx9/APKyf3/Yv9+J/XooERE2dOnclIMPxuEbPJh582DKFAkLZGw/9JC8Xr9e6nFYEWs05OSHH6BUKWYc6k2LFk7ua/hwydqx5CIqJTVTMsLWRYVTp0Q92mpFSOPwDYarZIxCx42DXbsk2yEnffrAoUNSbxvsFmAq2mgNixZB166o0qWcnyYZGChB++++g7NnadFCHH6HDk7u18NYuVJkFbZvt3LQTbIKYBy+wcNYvlwEHI8cEd9RrpzttmXLyvMnn0DbtrKA0ZCDf/+FffuY+NfNrFjhoj5HjJCVpN9956IOPY+OHaWIWMaAJBM3yiqAcfgGD0NrKF4cSpXK+3vq1oV69Zxnk1ezaBEA2+v0poKrioy2bQs33ACzZgHy1KqVDZlgH6VyZbkLvUY07dw5Ea1z0wi/mFt6NRhscNNNEvu0Gno4d07ulTdtgpAQaNECGjema9eSdO3qaku9hEWLoEkToteEuK5PpaQa1ksvQXw8gYE1qVlT6t26uMCT2/jlF/mKXrPoyo05+GBG+AYP4YMPpJaG1lac/W+/ScpDxYpw662ivz5qFLRsKTGfceMgOZm4OLj7bnEsBiTGtXIluvfNru97+HD5Z86eTf/+Mm9cVJy91nDHHTBtmpWDbpRVAOPwDR6A1iLDsmhRDmd/8qTkXvbsKUpUzz0Hy5bBhQuwY4cU3x48GF59Fdq351LsP3z7bTbRxqLN0qWQksIt0/swc6aL+77hBmjfPjOsA5mp+UWCP/6wUQDGjcJpYEI6Bg9AKZngungxy84VK+C222Tl5gsvSKGOjCR8gEaN5HH77VIlevRoGt/ZmuOfzaF0t/6u/hM8k0WLSA8sS93hETRo4Ib+77xT8vK3bmXMx83ZvFlq3fo6SslX0ypmhG8oyqxbJ3n2SklWDgCLF8uKlcqVYeNGeOWV7M4+J/37S8WlFi0oPfpO+OcfU0Dbko7p17MH704vzo03usGG226DYsVg1iyaN5c0xaLA5s0wdy4kJ1s5ePy4rLB1g6wCGIdvcCOpqTB0aA6tle+/lzh9o0awahU0b563k1WpImmAgYGc7TqANvXPsHmzU8z2Dv7+Gw4f5kJnN8TvMwgOFjGZ2bO57550XnvNfaa4krlz5ebGqmZRhqyC0wSN7GMcvsFtFCsmPjqzOt6PP0pMvlUridXnd5avRg2YN49yJ/ezsfGd1KnlTB0BD2fxYgDavNCLp592ox1Dhoj+RWwsWucI2/ko48fL9baYtYC5G3PwwTh8g5tp1QrCw5FfyB13QFiYZOUUNGk8MhL1zjvU2/EzFWZOcaitXsWyZaQ3bsIDL1enb1832tG3b+aVvWlTqZPi65QqZSeG78ZVtuACh6+UilNK/a2U2qyUMvkTBkB00p9+WmqfkpgI/frJ0tmFC+0vr80LDz4IvXuTPGEi8z4pgjmaKSkQE4PfTV147DHo3NmNtlSsCF26wPz53D9au/fi4wLS0+H11+3UACgiI/wuWuswrXW4i/ozeDh794rOiH96ikzuHTkihbBr1Cj8yZWC116jxIXTnHvhjSKVDgiIzOjFixxu0IULF9xtDDBwIOzZw2Pd/mHwYHcb41yOHZPs4bVrrRx0s6wCmJCOwU1MnSrzszz/vAjozJghIjqOokULLg24g7vOTUUds1Z2yIdZvhyAQdM6O7SKYYHp318uwt99R2LiVfVTX6R6dVkQfuedVg6ePCmpO9Wru9yuDFzh8DXwm1Jqo1JqdM6DSqnRSqlYpVRsQkKCC8wxuJNLl0TlEqDYyqXw5pvwwAPwn/84vK9Sk19GJSejGzSQrIiQEKn85OssXw7Nm/PS+5WtL/5xNVWrQkQEyXO+IzhYslh8mbJlrwr7ZePwYXmuWdOl9mTFFQ4/QmvdCugNPKyU6pT1oNZ6htY6XGsdHhwc7AJzDO7kiy9E6OzfdadkFW3DhvDWW87pbN06TlKR1AuX+Uc3hgMHYPRo33b6V66IGFGXLvTsKaqNHsHAgZTYsYVP/rvXp/Px582Tgl9WyajW44iwZQFxusPXWh+xPJ8AFgBtnd2nwXPp3Rte+5+m/tsPSDwzOtqKpKCDGDuW4mmXSMOf8pyWfUlJsmrXV/nzT7h8mX9rdGHrVncbk4UBAwC4p+KCayWDfYgFC+Cjj2wczBjh+6rDV0qVUUqVzXgN9AC2ObNPg2dTpw48VS0a9e238PLL0Lq18zo7eJByXCCAK9TgaLb9Psvy5aAUT//YibvvdrcxWQgJgVatSPt2PuvW4dxSi24kOlquuVY5fFhCiz6clnkdEKOU2gKsB37WWi92cp8GD+Wll2DHiuPw6KNw443wzDPO7bB27Wyb5yhrdb9PsXw5tGzJ1C8qMH26u43JwYAB+K9fR78Ox9m7193GOA+bN6zx8ZKhU7y4S+3JilMdvtZ6n9a6heXRVGs90Zn9GTyXgwdh8mTwf/IxWW756aeiKeJMJk6E0qXRwC4akECw/Bon+ujX8NIlkWns0oW6dS0L2jyJPn0A+GXML+4c5DqNw4dlYdk//9hp4MZwDhi1TOHAAVnpefy4JNIGBYm0a4sWbr0a+xK1a8Oxj38k8I65IoZmcymiA7HkJKqxYzlzoDztWA//fQXPyFV0An/8AcnJ7KrehS3fSPq71eX97iIsDKpXp9XRn6HsKHdb43AOHpSQzu2322gQHw/167vUpmvQWnvMo3Xr1tplpKdrHROj9YABWiultSyLyP4oVUrrfv203rDBdXb5IGlpWuuzZ7WuUUPr0FCtr1xxvRGnTmkdEKD1Aw+4vm9XMW6c1n5++tFRZ3XFivIV9zjuvVenBpbTy35NdrclTiE93c7nXr681g8/7JR+gVidBx9bNBdeHT8utfQiI0V3/b//FZ3euDi5LT54UJKF771XBLzbtBFNkE2b3G25VzJ2LPwQ+jz6yBEJ5ZQo4XojKlTgUt8hpHwR7bsKXqtXQ8uWTP6oHOvW2SgT6W769MH/wjk+HB7jbkucglI2PvdHzlU4AAAgAElEQVSLF6UUm5tDOkXP4W/dKkWW//wT3nlHVgFNnCirPOvUEd31WrVkuf+0abB/vxz/4w9532uv+W6KgZNombqBvoc+QI0ZI5+hm/i6zH0Uv3Sec59+4zYbnEZysgxaIiMpUcL9kQObdOtGevESfNDnZ3db4nDGj4e337Zx0AMWXUFRc/g//SS1UVNTZTT06KNQpoz995QrJ8v/9+0Tqdfnn5eSexmlygz2SUvjtuUP4letqsTu3UjviZFcCWlAuQVfutUOp7BpE1y+TFytjrz6qqzi90gCA/HrEkXlP33P4W/ZksuELZgRvstYs0YWfzRoAOvX5z//OygIvv5aKm2vWSO6vn//7RxbfYHoaHSdEPYVqy9VqwYNKrwKZiGpXkNRcsTtUljlxAm32uJwYiREsiI1khdf9NBwjgV9cx/YuZON3/hWbub330vE0ioZq2zNCN8FHDsmo/OQECnsXNCrrFIS11+/XhZQdO4st9GG7ERHw+jRbDgYTCVOcoSq8kvwAEmD+PaDIT2ds18sdLcpjmX1aqhfn1HPXsfp06JK7KmotFQAtt8+oejoG5kRvotIscjvnjkj5ZXKly/8OUNDZURVqRJ07Qq//174c/oSY8dCUhKt2UQgFwjirEyGe4Ckwemazdit6pM8e567TXEc6ely12kRqXHzjZR9oqNh3DiSKc4dfO0z+kYrV0plTpuLuA8flihBbiFkJ+P7Dv/ZZ2X08/HH0KyZ484bEiLnveEGyeBZtsxx5/Z2LN96f9LxJ50yXMq2352ENlPUeXIwwVuXeXCgO5/s3AknT3KqaUdGjJB67h6LZTBQghT8sSQ/+IC+0dmzkt9h05/Hx7s9nAO+7vBjYmDKFHjkEecstqlaVZayN2ggqwirVStaMry2qFWLM5TjPIHZ93uApIFSUGLYYCm19f337jbHMVji9/uqR/L775Kw47FYLvonkRKWx6iSbb+3cuutMqVXqZKNBh6wyhZ82eGnp8Pjj8uHPGmS07q5VKoiicMeEVnaY8dkyZaP3KYWmA4dKM853iBL9WwPkjRIqNmSo6XqcvQ9HwnrrF4N111H+NAbOHoUWrZ0t0F2sFz0T1CFSwRwjqBs+30W4/CdzFdfSXbIpEkOjZstXSolzDJ47DGoP24oGXX0zhPIWzyB9oHb1AJx6BD8+CO6VWueqDlfhtR16khFKw+RNKhYSbG0wmCqbF0Cp0+725zCExMj8XulbC/88RQs+kYN2I0/qTRgt0cNBgpKz56yrMcqqakyGDQhHSdx4YKsnm3bFu64o1CnunhRrh2pkljAxo2ScHLunGyPGAHT0sdkti9BMj35DQVw8CB//20p1F1UeOIJtNao7+ZT8dAWudOKi/MYZw+i2XbngsH4p6XAjz+625zCER8PcXGkduhIZKTUgPdohg+HGTPwr1OLElh+VP/7n0d9P/JLejqUKmVnAfmxY9LIjPCdxOuvw9GjUjjVr3B/4m+/SfU9S5lQHn1UlBkyMiE6doQRdVZlti9JMqHI6otT1UOJjIQnniiUCd7DL7/A/PlMLvECaw/Xcbc19mnTBl27NmnfzHe3JYXDEr8/1SQSf/9Cf91dw/DhEBfH2hmW2WU3Z64UFj8/udA++KCNBh5Q6SoDb/h65I8jR6RO6h13QIcO+X77pUswatTVBRR9+8pvqls32Q4IsPKjstym5qRCZFM+/RQeeki2L16UhASf5NIleOQRLtdtxOp2T3HDDe42yD4axTdJt5D66xK4fNnd5hScmBgIDKRK9xaZqYHeQsypJhxRNUhd9Ju7TXEuHiKrAL7o8N9/XyZQX345X2+7cEGeAwIkYSAjY694cVFjsBsXtdymUqeONKxdG9q3R30zl8FlfslUAn7oIan7ceVK/v8sj2fSJNi3j4BP3ufHX0tQpYq7DbKPUuB3a19KpiaJgJ63EhMjUt4epYOcN574P0W1kT0otmKJV8c933tPFt7bHDd4yKIr8DWHn5QE06dDv35w/fV5ftuUKSI2dfGiOIKlSwtQjMlym0p6umTpLF0KzZvL/v37M5uMGgUlS+bz3J7Ov//CpEmcvvkOzoXf5G5r8syQ96Pkzuynn9xtSsE4d05yASMiaNfO7VJF+aZ4cVC9esrEeWysu80pMJUri/8ICLDRID5eAvyVK7vULmv4lsP/6is4dSpPQfNt26QpyABp+PCrE7MOyXIoXRrmz5cLwODBcOkSPXpIpijI79Rb/Uw2tIZHHkEHBHDLrrfo18/dBuWDgABSO3cl5fufM7OsvApLcdi09hG0aOGdmY2TNnRFKwW//upuUwrM0KGipm6TjJRMT0ifyotofmEeQC9gF7AHeM5e20IVQElL07pRI61btcq18sOhQ1Lz5MUXC95dnvnxRymmctdd2ezq21frunW1vnzZBTY4k1mz5O979129fr3Wq1e726D88fr1H4n927a525T8M3681n5+Wp87525LCkzv3lrvrxyudUSEu01xHp07ax0Z6dQuyGMBFGc7e39gL1APKAFsAZrYal9ghz9rltZVqsifU6mSbOfgf//T+r//vbr99ddaJyYWrLt888ILYtsnn2TuOnNG6z17XNS/szh5UuvgYK3btdM6NdXd1hSIldGH5H/z+uvuNiX/dO2qdViYWwqIOZSxY7X295cfhZdx4YLWFSpo/emndhpdf73Wt9/uVDvy6vCdHdJpC+zRUsw8GZgDOPam36LMqE+cIB0ls62jR/PzU8t56qmrzfbvh71Z1FiHDbOzDNrRTJggImuPPCIFWBAdpeuvl0jC22+L9pXX8fTTcOoUh8bN4Nnn/b1ScbjTHTWldvHPXqbPnpoqIZ2ICG65RbLJvJbu3WXS1gsnzy9flpCOzSlDrSWk4wEZOuD8GH4N4FCW7XjLPsdhEWNSwAu8yhVKQFISmz+NZc4cyRYE+OijXOJszsTfXy5MFSpIPD9j1RYyUTx9ukw/eBUrV8Jnn8GTT7LkRHOmTbs6B+JtJLbvS3rMGu9adbt1q3x5IiLo39+70jGzcugQ9J/UnrSA0rBkibvNyTeVKsEHH4hSulVOnZKrggdk6IDzHb61WYpss2NKqdFKqVilVGxCQkL+e7CILh3lOmpxkHTLn/TsmeeJj5cVcNJP/k/tUK67DubMkduM0aMzJwkDAyWz7oMP3Gxffrh8Ge6/H+rWhRdf5K67ZPlD9eruNqxgzDjcB7/0NNIWedHEYcYtYUQEDz4oXylvpFw52BtfksQmnbzS4ec6yLFk6BES4mxT8oSzHX48UCvLdk3gSNYGWusZWutwrXV4cHBw/nuwpCZU4zgP8hGlkGTYYnU844qajU6dZJHW3LnZPHyVKrKYKyFBoiQpKW60MS9MmAC7dsH06SQXkwVnFSq416TCMPTttqRVrIz/L16UNrVmDdSsSUKp2pl3sd5IUJBkrF13RzeRec7IWfcS7rtPsq9tEhcnz3XrusKcXHG2w98A1FdK1VVKlQCGAj84tAdrq1w9WYzpmWdESvmJJ2DDhmyHVq2SRRwbN7rJtrywfj1Mngz33ENKlx40biwLm72ZevX98b+5Fyxe7D0LgNasgYgIxo+HWrW8M6s0GxlL2Zcuda8d+aRnT9HTsklRGuFrrVOBR4BfgR3AN1prW2V+C0bOVa4epsx4DX5+8MUXop1/223Z4saDBsGePbIuwCO5cgXuuktiN2+9RVKSTBbaHeF4Cbvq9pIJ/02b3G1K7hw8KIt5IiIYNkyko9wesiwEX38Nze5ohg4O9rqwztChclduk7g4qbLniEp7DsDp67G11ouARU7tZPhwz3Xw1qhUCb75RpTXRo0S5SXLLzZjbufXXyE4WJZsewwvvwzbt8OiRRAURBB2JGG9jKV+3WkIJC34ldJt2rjbHPtkid93aiWRQm8mKAjqN/TjSsOuBCxZIrcrXnAFS02V6azAQDuN9u/3mHAO+NpKW2+iXTsJjfzwgzxn4coVmROdMME9plll3ToZSo4cCb17s3mzxF59hVHPVCG9VWtKr1rsblNyZ80aKFOG+IrN2b5dFnN7M336SLnpgD7dROV2xw53m5QntmyBsmVzWTG/f7/HhHPAOHz38uijMGSIaPdnqYlbsqQoDc+Z40bbsnL+vNxB1awpktPACy9A797em4qZk9Klwa93L7mwnTnjbnPss2YNtG/PZ18WIzRU/j0+Qdeu8uwlYZ0qVUTK32ZIU2sJ6ZgRvgGQ29ZPP4WGDeH22yUp2ULjxuKEUlIyJc/dx6OPyhf3q68yY5FffAHffuuVIo02+bNCT0hLI+VXD544PHtWcvA7dmTkSPkfBAW526jCM2QI3P5siKxg8hKHX6uWjNVsahgdPy4xH+PwDZmULQsLFkgcZ/Dga7STx42TgY/bajx/8w3MnAnPPy9zDhYqVSpQuQGP5kTd9pz3K8flBR4c1rEIphEZSZ06MtHvC7RuLQ+6dZMVt15w6xgfj/2U2IyUTBPSMWSjYUMZMq9fL2VzsuTYPf20hHbcooS4f79MJrRrB+PHA1L5q0cPr0uXzhO3DCxO2f7dKLv2V8/Nc4yJAX9/jtZux8KFV+s4eDvPPWeRJO/WTWJUOVKWPZH+/bGvDpuRkmlG+IZrGDBAhvOffy7iOhYqVZJDIKtZXeaHkpJg4EB5HR0t4uXI4rDERBfqELmaXr0ktOapE4erV0PLlvy8MpABA2SO01fQGlIiu1wtSuHhvPBCLkrsHpaDD8bhexYTJkgw8+mnrymuvWuXxPU//NAFdmgNDzwgaQjR0dmUoW67TRaG2Sz24OUsL9ETgNNzPDCsk5wMf/4JkZHceSesXYvHl5LMK4cPy1zElz9XgrAwr4jj9+8viQs2iYuT3GoPqtlrHL4n4ecn8fJWraQmr0VZE6BBA3j4YUlhczrvvy8TtBMmwM03AxI2XrnSa1KkC0y1drWJL9eYEss80OFv2iSTgJGRBATIHIqv/C+qVZM1fY0aIZNWf/zh0QWgExNFCcLuVIOH5eCDcfieR+nS8P33Mtzp1Qv27QPkh/2//8lCYnBi3e0lS+Q+tW9fuWe1MH8+REV5n4pwfmnUCGre3ZMysas8z+FY0rVON43k9delkqav4Ocni/giIhCHn5zsAelptlmwQO644+PtNPKwlEwwDt8zqVFDltpeuSKTWEey6c0xZgzccosTZF9iY2XCoHFjGeH7Xf16DBgAs2ZlDvh9m1694MoVUpetcrcl2YmJgfr12Rh/Hc8951sOP4OEBCQbrHhxj47j9+gBX35pJ5kiLU3+QR4Uvwfj8D2Xpk1l9VVCgny7MgrwAi1bQtu2Du5v927x5pUri4hYFu2PtDTJtx8+PNs1wGdZRScuEcDRzz0orKO1OPzISLp1k6+Fx2ouFZD335fFTAlJZeSP82CHX6eOiKbZ/D0cOSKLaMwI35Bn2raV8M6ePXDTTXDsGAB33y1ioP7+DlpWf/CgXFRA7iyyCNuvXQtNmoiETlGhVUQp4q/vzHVbPEgff9cuEXeLjATkulyihJttcjCdO8OUKZbFfF27ypxFloGOJ7FixTU33tnxwBx8MA7f87nppqtOPyIiW53GffskoWHdukKcf9s2uPFGUe1ctEhmh7OgtSgquGUdgJsIDIT6D/ekxN6dV3+47sYSz77SJpJ77pElG75GaCg8/riltkLXrvLl88CyhykpUpXxvffsNPLAHHwwDt876NlTtHbOnhXnbBHMDwyUjK8CZ2qsWiUjRq0lvzs8/JomERFyZ21XEdAHSe/RC4Dz8zxklL96NQQHs0fV5/vvZdW+L3LunMVXtm0rX24PDOsoJdehu+6y0yhjoJCRZeEhGIfvLbRtK6O8gABx+lOnUqVyOmvXykJYyMdq9PR0Sejv0UPy4f74A5o1y9YkOhomTfLcBafOZrd/Iw5Si4RZHuLwLRfnpqGKEyd8d/L8llvgzjuReFWnTh7p8IsVk4FQ/fp2Gu3fL6HRkiVdZldeMA7fm2jUSDJpevWS1MlevVBHJZD48cfQpo3kB9vlwAFx9A89JD+omBir8Zply2TO2AskTZxCg4aKtG69CNm7xP01J+Pi5NGlCyAThf7+brXIaTz/PLz4omWjWzeZu7Cb++h6Nm+G33/PZTDkgSmZYBy+9xEcLAVTpk8XZ33DDTBmDI1LxVG3LpT7ebZMFPn5yXN0tLzvwAEYO1YCpX/+CR99JBO0NjQSPvlEcu4tigpFDqWg7gM98btwvpCTJA5g5UoAUiKiiIq6ZhG2T9Gz59X8gUy55CzS4Z7Ahx/CsGG5hFI9cNEVGIfvnSglomZbt8o376OPiBx1A9/FtaLEfSO5fOAoe3WIOPm77pKVu3XrSoyme3eZqB09+ppv7PbtslT89Gk5VNTi9jm5dGNX0v38OfaFm9MzV6yASpU4VqkpKSm+HWZLTYW//rIohTdrJgMcD5NZeOUVGSvZJCVF/gAPy9AB4/C9mxtuED39ffvgscekBFVKCgEkcz2WLIGUFLkwjB0ro47vvrM5kZSQIJphvqiEWSDKl2edbk/qTx7g8Dt3plYdP9asgVtvda85zuTiRRmfzJqF3KV27SoO34OuclWqWKScbXHokMyTFaURvlJqglLqsFJqs+Xho9NMHkDNmvDWW5lLb09SgVVEZh7en1Yb/fIrVmP1Bw7IolqQPOhduyTqY4BSpaDh472peXxT5hoIl5MRv4+K8iSf5zSCgiQL+c47LTu6eVbZw4sXYcaMXFY579olzzlSnD0BZ4/wp2itwywP5xYyN2Q69EqcphOStx1La25gN59+Kk0OHRLp/dOnZfuddyQ6lLHtYUkFbqfSfyxqdb/84h4DLPH71Mgo6tWTqRdf59ZbpZoU4HFlD3ftkt9LbGwujcCiBOdZmJCOLzFxooivZaFBqXim37MhU8Z182YYNerq+q3nnpPvZ4UKrjXVW0hv1oKzZWsQ94GbVOMs8ftztZoSFVU0FsAdPw7z5lmKv4WEeFTZw7Cwq4luNtm5U5IhKld2mV15xdkO/xGl1Fal1GdKKeNSnM3w4XK/WaeOzLrWqUO5j9/ivk/aU6OGNOnSRZx9RuHlKlWyjKYM1+Dnr1gecDPXbflNFBxdjSV+X7GyH59/nov+uo+wYoWUhciM4nhQ2UM/P7noli1rp9HOnVLFzgMplMNXSi1RSm2z8ugHfAhcD4QBR4G3bJxjtFIqVikVm5CQUBhzDCBOPy5OJo3i4mQ7C4GBUK+e7+mwOJNbpvehVMp518v1Zonfnz3r2q7dSffuspi8SRPLDg8qezhrlmRF22XnTo8M50AhHb7WupvWOtTK43ut9XGtdZrWOh34GLCq76i1nqG1DtdahwcHBxfGHIPBKfj36CpXSFcXA7DE75NvjKJmTYnYFQUqVpRMncxBSRdL2UMPCOu8+abUKLLJmTMSk/JFh28PpVS1LJsDgG3O6stgcCqBgeysGsWRT1zs8C3x++T6TRk3LnOhbZEgJgbmzLFsVKokmuAe4PBjY+Gzz+w08OAJW3BuDP8NpdTfSqmtQBfAXrlfg8GjiWvah+rndmVTK3UqWssK086dCSznxzPPiIRSUeHjj+HJJ7Ps6NZNNJ8uXHCbTSA6OhUr2mmwc6c8FzWHr7UeobVuprVurrW+VWt91Fl9GQzOpte7lvRMV4V1du6UOgU9e/Lnn+6ZL3YnkyblqMHQrZssIlzlvipkf/4J48dfTWG2ys6dokfigYuuwKRlGgx54/rroWFDUr53kcNfLKt7jzbvSfv2MG2aa7r1FKpVk0VYmURGilLs77+7zabYWHjttVz0pXbulBXwxYq5zK78YBy+wZBHVgX1JX3ZCtJOn3N+Z4sXQ+PGlG9RhwULJE2xKJGWJosCM9WRS5USddfffnObTQ8/LCtt7WpM7drlseEcMA7fYMgzZe7oT0mSSfvRyYvGk5IkQ6d3b0qVgv79Pa6OhtPx84NXX4Uffsiys0cPifMcOuQ2u+ymM6ekSGU64/ANBu+n9ZgboWpVSvwwz7kdrVgBV66Q1r0Xn3ziPhkfd6IU7N4to/xMMpa3uiGsk54OI0fm0vX+/eL0PXTRFRiHbzDkHT8/0voNIPWnX0g+k+S8fhYvhlKl2Fi6I/fd5/r1Xp5C+fI5doSGSnDfDWGdxES56bIrmubhGTpgHL7BkC821BpEsStJ/D3ZiZLJixdDly606RjA9u1S4KwosmsXjBkjyUqADPt79JBhtkUZ1lVUqSKLnu+5x06jDIdvRvgGg2/Q6onOXClbibC9853Twd69Esvo1QuloHHjoluI5vx5WdW6Z0+WnT17wqlTsGmTW2yyW+Vq1y6oWtXKrYnnYBy+wZAPSpQuRskh/fD/5SeLnKODsZRSOtikF48/7nHlXF1Kq1Zw9izcdFOWnd26ybOLwzqvvQZPPZVLIw/W0MnAOHyDIZ8k3zIIzp3j7ylOWOq/eDHUq8efJ2/go49ksrCo4ucnj2wEB8uVwG6NQcdz5EiW0JI1tBZ5Tw8O54Bx+AZDvvHr3pVzqhxJXzk4rHPhgujF9O7NkNsUiYlFQ//eHt9+C0OH5tjZs6fILJxzwXoIC+++C998Y6dBYqIswTUjfIPBtyhWpiTFB91Ku2PfSxqeo/jpJ7h0CW67DYAyZRx3am/lxAmJlGST0OnRQ7Txly93m13XkKEDYRy+weB7lBp5u0weOlJbZ84cqF6dV1dE0q+fyxNRPJKHH5Yqbdkmrm+8USqQLHJN1dSYGKn3/O+/dhplTCK3bOkSmwqKcfgGQ0Ho1YuLQdVYe8+njikufuaM1M297TbKlPWjfHnw93fAeX2REiWkSsqiRbiisntKijzKlbPTaNMmqFEDrrvO6fYUBuPwDYaCUKwY+zqOot2pRZzfebjw51u4UCQxhw7liSek0LxBePRRePzxHDv79JEUpq1bnd5/ly6wdq1kXNpk0yaZTPZwjMM3GApIsyl340865RY4wDvPnQshIRyv09YVg1avQikr+e833yzPrq5CZo2LF2WiwTh8g8GHueEGiIoi9ePPOH2yEPmTiYnw+++kDb6d8DaK++93nIm+wDvvwJQpOXZWrQqtWzvd4aemijL2jBl2Gm3dKvmzxuEbDL7NuSH3UCxuLz89vbLgJ5k/H9LSSL9tKOPHw7BhjrPPp+nTB9atg5MnndbFhQsQESHheZtkTNgah28w+Dbl7hrElVJB3Jr4acFPMncuNGxI8fAW3Hdf0apdmxfOnYMWLeDDD3Mc6NNHRtaLnadrVL48fPmldGWTTZtkQZjdq4JnYBy+wVAYSpWi5F3DCfptXsFGmtu3w4oVHIy8gzlzlUnFtELZspLeXqVKjgPh4bLTiWGdPP0/MiZs7QrteAaFcvhKqSFKqX+UUulKqfAcx/6rlNqjlNqllOpZODMNBg/moYfQycn81u2N/NfYfv11KFWKyRcf4qmnTO69NZSSm6BBg3Ic8POD3r1lhJ+a6pS+b71VHja5cgW2bfOKcA4UfoS/DRgIZKssrJRqAgwFmgK9gA+UUiar2OCbNG1KYo/hdNw8jc0/5yNFMy4OoqNh9Gjeia7MypW5VFQq4qSlWdEW6tNHJA3WrXNKn716Xa27YpVt2+RiUxQcvtZ6h9Z6l5VD/YA5WusrWuv9wB6gbWH6Mhg8meAPXiKgWCqRy1/J+5smTwY/P9KfeBI/P8kGMVhnyRIpar5lS44DPXpIwfBstRAdx5gx8Mgjdhp40YQtOC+GXwPIWngy3rLvGpRSo5VSsUqp2ISEBCeZYzA4mXr1UKNHw6efEr9iT+7tjx2DTz/l0E0juSGqJn/+6XwTvZn69eHuu63UBggKgq5dJdPJwQsYLl6UtXB22bRJZnbr1nVo384iV4evlFqilNpm5dHP3tus7LP639Baz9Bah2utw4ODg/Nqt8HgebzwAql+xVl903g2b86l7dSpkJLChYeeoVUraN7cJRZ6LXXqwLRp4vivYdAg2LfP4atuP/xQLjBnzthp5EUTtpAHh6+17qa1DrXy+N7O2+KBWlm2awJHCmusweDRVKtG6kOPMUzPJvSInQIdO3bA++/DkCE0vrU+8+ZBqVKuM9Nb0RqOHrVyoF8/mcCd71i56ogIGDfOTgGrlBSJMXlJOAecF9L5ARiqlCqplKoL1AfWO6kvg8FjCHjpv9C8OcWGDCDpt5irRa+joyEkREaCzZpxITWAt4InFekCJ/nlzTcl1f0aGfwqVaBjR4c7/A4dxOHbZOdOydIpKg5fKTVAKRUPdAB+Vkr9CqC1/gf4BtgOLAYe1lqbhDOD71OunJTfq1kT3acPb9wWi54lmTiZ3j8tjY9TRrJxo9dEAjyCnj0lrGOVQYNkTUNGIfFCkpIitXTtXpDXrJHnNm0c0qcrUNqDlJrCw8N1bGysu80wGApPfDyX23aEM2cI4Ar60iXiCKEOB/BDc55AiteuTsABa0luhnxz+DDUrAmvvgpjxxb6dJs3i7T93LmZ9Wiu5bbbJB30wAG3X7mVUhu11uG5tTMrbQ0GZ1CzJgExSwno3B4uXSKFYmgUq+gEQFkuEHBot5uN9D7OnrWSmgkS62nfHr77ziH91KgBn3wCkZE2GqSnS8Wtm25yu7PPD8bhGwzOol49KWpSpw4lSKUe+4kii8haUS9YWwAefVRS760GJgYOlKyZ/fsL3U9wMNxzD1SvbqPBtm2icnrTTYXuy5UYh28wOJuJE6F06ez7SpeW/YZ8MWYMzJplw+FnaC84YPJ25cpcpJGWLZNnL1O6Mw7fYHA2w4eLoHqdOnL7X6eObA8f7m7LvI7wcKlu6GfNc9WrJw1mzSpUH5cuQbdukhVkk2XLZFFArVp2GnkexuEbDK5g+HDRzklPl2fj7AvMli1SWNwqo0ZJg1xXvtmmeHFYulRW9lolNVVuAbwsnAPG4RsMBi9jzBh4+mkbB4cOFZ9ipIgAAAtMSURBVI9diKLAxYpBp042VvWCzBOcO+d14RwwDt9gMHgZ774Lc+bYOFipkugZR0dLMn0B+P57+OsvOw0y4vdRUQU6vzsxDt9gMHgVLVrINIhNRo6EhATJkMonWsMDD1ipoZuVZcsgNBSuuy7f53c3xuEbDAavQmtZELVkiY0GvXqJ3EIBwjpKyej+pZdsNLhyRSYQvDB+D8bhGwwGL0Mp0biZPt1Gg+LFZVL8xx8LVHayalU7asfr1kkaj3H4BoPB4Bp+/91OHB8krJOSAl9/na/zzpkDs2fbaTB/PpQs6ZXxezBaOgaDwVcJD4cLF0RUzWri/rVkJN4sX27lYEqKLL3t0gW++cZxdjoAo6VjMBh8Fq1lofKXX9pp9OSTsGsX/PRTns+7dCnMm2fj4OLFIqfwn//ky1ZPwjh8g8HgdSglZWxXr7bTaMgQSed54408n9fPTzI7rfLVVyKy07Nnvmz1JIzDNxgMXklMDHz8sZ0GxYrB//2f6Nb/8Ueu55s7F/77Xxsa+GfOyBVm2DCZFPZSjMM3GAxeSZ787t13Q4UKMHlyrk03bJDoj9Vw/7ffSkrmiBH5ttOTMA7fYDB4JVqLhLFd0dHAQHjoIVi4EP791+753nxTVBOs8tVX0LgxtG5dYHs9AePwDQaDV6IUJCVJWrxdxoyBEiXgtddyPafVu4b9+2WyYMQIryp2Yg3j8A0Gg9cye7ZUNbTLddfBI4/AzJk2ZTafeALuu8/G+6dOFUfvAwqnhS1iPkQp9Y9SKl0pFZ5lf4hS6pJSarPlYWtNnMFgMBSa5ORcGkyYIBXG7r/fauNSpeRxDdu2wfvvy/t8oEJZsUK+fxswEPjIyrG9WuuwQp7fYDAY7NK/v4Rivv3WTqPAQPjgA+jbVyZwcxQ6/9//rLxHawkHBQXl4TbCOyjUCF9rvUNrvctRxhgMBkN+iYyEiIg8NOzTR3LzX3kFdl8tIJ+UZKP9t9/CihUyK2wzOd+7cIi0glJqBfCU1jrWsh0C/AP8C5wDXtBaW10ioZQaDYwGqF27dusDBw4U2h6DwWCwypEjkm3ToIGsnK1UiTZtoGlTCfFncvEiNGokC602bAB/f3dZnCfyKq2Qa0hHKbUEqGrl0Fit9fc23nYUqK21PqmUag0sVEo11Vqfy9lQaz0DmAGipZObPQaDwZCTtDRJqWzTJpeG1atLzdshQ6B5czSKoUeGUj0uGaLbycTsyZMivhYfL2pqHu7s80OuDl9r3S2/J9VaXwGuWF5vVErtBRoARhnNYDA4nDfflFWyBw7koa74LbfAU0/BxIko4EnegkRg9KewY4cM9RMSZLI2T7Ei76Gwk7ZWUUoFA6e01mlKqXpAfWCfM/oyGAyGYcPg+uslApMnZs0C4AolKIklaycpSeL19euLFEOrVs4x1o0UNi1zgFIqHugA/KyU+tVyqBOwVSm1BZgHPKC1PlU4Uw0Gg8E6tWvD4MEQEJDHNxw8yN+EUpuDLKZH9mMbN/qks4dCjvC11guABVb2zwfmF+bcBoPBkB8uXJDa5VFR0LBhLo1r16bJge1M5wHasf7q/jp1oGxZZ5rpVsxKW4PB4BNcviwLan/9Nfe2TJyIf+kABrCQCpyRfaVL5yLM4/0Yh28wGHyCypWlAPmYMbm3fe3gcD66fZmM6JWS5xkzfEI+wR5OmbQ1GAwGdxAaKs+JiaKKbC2jUmspYVi9ejvuj4tzqX3uxozwDQaDT7Fvn6yr+sia4AsyoP/tN5heBBW+jMM3GAw+Rd26MHq0TN5mRWt47z1ZbAv5yOjxIYzDNxgMPoVSMGkSNGkilQknTZIQz6FDsjirKI7sMzAxfIPB4LMsWSJOvkcPSa3fsEHCPUUV4/ANBoPPMniwxPTr1pXtRo3ca4+7MSEdg8Hg02Q4e4Nx+AaDwVBkMA7fYDAYigjG4RsMBkMRwTh8g8FgKCIYh28wGAxFBOPwDQaDoYhgHL7BYDAUEYzDNxgMhiKC0lq724ZMlFIJwIFCnKIyUo7Y0zB25Q9jV/4wduUPX7SrjtY614q+HuXwC4tSKlZrHe5uO3Ji7Mofxq78YezKH0XZLhPSMRgMhiKCcfgGg8FQRPA1hz/D3QbYwNiVP4xd+cPYlT+KrF0+FcM3GAwGg218bYRvMBgMBht4ncNXSvVSSu1SSu1RSj1n5XhJpdRcy/E/lVIhLrCpllJquVJqh1LqH6XUY1baRCmlziqlNlse451tV5a+45RSf1v6jbVyXCmlplk+s61KqVZOtqdhls9hs1LqnFLq8RxtXPZ5KaU+U0qdUEpty7KvolLqd6XUbstzBRvvHWlps1spNdIFdk1WSu20/J8WKKXK23iv3f+5E+yaoJQ6nOX/dbON99r9/TrBrrlZbIpTSm228V5nfl5W/YNbvmNaa695AP7AXqAeUALYAjTJ0eYhYLrl9VBgrgvsqga0srwuC/xrxa4o4Cc3fW5xQGU7x28GfgEU0B7408X/02NIHrFbPi+gE9AK2JZl3xvAc5bXzwGvW3lfRWCf5bmC5XUFJ9vVAyhmef26Nbvy8j93gl0TgKfy8L+2+/t1tF05jr8FjHfD52XVP7jjO+ZtI/y2wB6t9T6tdTIwB+iXo00/4AvL63lAV6WUcqZRWuujWutNltfngR1ADWf26WD6AV9qYR1QXilVzUV9dwX2aq0Ls+CuUGitVwGncuzO+j36Auhv5a09gd+11qe01qeB34FezrRLa/2b1jrVsrkOqOmo/gpjVx7Jy+/XKXZZfMBtwGxH9ZdX7PgHl3/HvM3h1wAOZdmO51rHmtnG8sM4C1RyiXWAJYTUEvjTyuEOSqktSqlflFJNXWUToIHflFIblVKjrRzPy+fqLIZi+0fors8L4Dqt9VGQHyxQxUobd35uAHcjd2bWyO1/7gwesYSaPrMRnnDn59UROK613m3juEs+rxz+weXfMW9z+NZG6jnTjPLSxikopQKB+cDjWutzOQ5vQsIWLYB3gYWusMlChNa6FdAbeFgp1SnHcbd8ZkqpEsCtwLdWDrvz88or7vyujQVSgWgbTXL7nzuaD4HrgTDgKBI+yYnbPi9gGPZH907/vHLxDzbfZmVfgT8zb3P48UCtLNs1gSO22iiligFBFOz2M18opYoj/8xorfV3OY9rrc9prS9YXi8CiiulKjvbLkt/RyzPJ4AFyK11VvLyuTqD3sAmrfXxnAfc+XlZOJ4R1rI8n7DSxi2fm2Xiri8wXFsCvTnJw//coWitj2ut07TW6cDHNvpz1+dVDBgIzLXVxtmflw3/4PLvmLc5/A1AfaVUXcvocCjwQ442PwAZM9mDgWW2fhSOwhIf/BTYobV+20abqhlzCUqptshnf9KZdln6KqOUKpvxGpn025aj2Q/Af5TQHjibcavpZGyOutz1eWUh6/doJPC9lTa/Aj2UUhUsIYweln1OQynVC3gWuFVrnWSjTV7+5462K+uczwAb/eXl9+sMugE7tdbx1g46+/Oy4x9c/x1zxqy0Mx9IRsm/yGz/WMu+l5EfAEAAEiLYA6wH6rnApkjkNmsrsNnyuBn4//btHoeAKArD8KvVSHSU1jCV3aCZwnZ0Cok96PRaREVvERrFPZNMCIXEFbnv04jJlTk5c3xkfmqgjjVz4ES6M2EHjDP1axT73Mf+m561a+sAi+jpEagy1NUlBXivte0n/SL96FyBG+kf1Yx03WcLnOO1H2srYNn67DRm7QJMMtR1IZ3TbeasuSNtCGzeHfMv17WO2TmQgmzwWFe8f/r+frOu2L5q5qq1Nme/XuVD9hnzSVtJKsS/ndKRJH3IwJekQhj4klQIA1+SCmHgS1IhDHxJKoSBL0mFMPAlqRB3sTmLQacfpz8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f_exact(x):\n",
    "    return np.sin(x)*x\n",
    "\n",
    "N = 10\n",
    "x = np.linspace(0, 20, N)\n",
    "\n",
    "y = f_exact(x)\n",
    "\n",
    "fInterp = interpolate.interp1d(x, y, kind=3)\n",
    "\n",
    "# use finer points when we plot\n",
    "xplot = np.linspace(0, 20, 10*N)\n",
    "\n",
    "plt.plot(x, y, \"ro\", label=\"known points\")\n",
    "plt.plot(xplot, f_exact(xplot), \"b:\", label=\"exact function\")\n",
    "plt.plot(xplot, fInterp(xplot), \"r-\", label=\"interpolant\")\n",
    "\n",
    "plt.legend(frameon=False, loc=\"best\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi-d interpolation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example of mult-d interpolation from the official tutorial.\n",
    "\n",
    "First we define the \"answer\" -- this is the true function that we will sample at a number of points and then try to use interpolation to recover"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x, y):\n",
    "    return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "here will use mgrid to create the grid of (x,y) where we know func exactly -- this will be for plotting.  Note the fun trick here, this is not really a function, but rather something that can magically look like an array, and we index it with the start:stop:stride.  If we set stride to an imaginary number, then it is interpreted as the number of points to put between the start and stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 200)\n",
      "(100, 200)\n"
     ]
    }
   ],
   "source": [
    "print(grid_x.shape)\n",
    "print(grid_y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "here's what the exact function looks like -- note that our function is defined in x,y, but imshow is meant for plotting an array, so the first index is the row.  We take the transpose when plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x18193d8208>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin=\"lower\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now we'll define 1000 random points where we'll sample the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "points = np.random.rand(1000, 2)\n",
    "values = func(points[:,0], points[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what those points look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(points[:,0], points[:,1], s=1)\n",
    "plt.xlim(0,1)\n",
    "plt.ylim(0,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The interpolate.griddata() function provides many ways to interpolate a collection of points into a uniform grid.  There are many different interpolation methods within this function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x107bf2898>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid_z0 = interpolate.griddata(points, values, (grid_x, grid_y), method='nearest')\n",
    "plt.imshow(grid_z0.T, extent=(0,1,0,1), origin=\"lower\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x107c6e860>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid_z0 = interpolate.griddata(points, values, (grid_x, grid_y), method='linear')\n",
    "plt.imshow(grid_z0.T, extent=(0,1,0,1), origin=\"lower\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x181961a7f0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid_z0 = interpolate.griddata(points, values, (grid_x, grid_y), method='cubic')\n",
    "plt.imshow(grid_z0.T, extent=(0,1,0,1), origin=\"lower\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Root Finding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often we need to find a value of a variable that zeros a function -- this is _root finding_.  Sometimes, this is a multidimensional problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `brentq()` routine offers a very robust method for find roots from a scalar function.  You do need to provide an interval that bounds the root."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$f(x) = \\frac{x e^x}{e^x - 1} - 5$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.965114231744287\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import scipy.optimize as optimize\n",
    "\n",
    "def f(x):\n",
    "    # this is the non-linear equation that comes up in deriving Wien's law for radiation\n",
    "    return (x*np.exp(x)/(np.exp(x) - 1.0) - 5.0)\n",
    "\n",
    "root, r = optimize.brentq(f, 0.1, 10.0, full_output=True)\n",
    "\n",
    "print(root)\n",
    "print(r.converged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1819710a58>]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD8CAYAAABjAo9vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAHRlJREFUeJzt3XlAVXX+//HnRxARFTcUF0RU3HfFNVtHK8vK0sq+bdNUTr+Z+aaZOWpNNZlT6ZRjU9OM01hTOe5Oltlqlm1WGIgKLiiioIJoIKKs9/P7A/r9rFwQ7r3nLq/HP8Llcs7rJLw6nvdZjLUWEREJHHWcDiAiIu6lYhcRCTAqdhGRAKNiFxEJMCp2EZEAo2IXEQkwKnYRkQCjYhcRCTAqdhGRABPqxEqjoqJsXFycE6sWEfFbmzZtyrPWtjjX+xwp9ri4OBITE51YtYiI3zLGZFbnfToUIyISYFTsIiIBRsUuIhJgVOwiIgFGxS4iEmBU7CIiAUbFLiISYFTsIiJeUHCijMff2kZhcZnH16ViFxHxsG8yjjJ6/gbe2JjJNxlHPb4+R648FREJBmUVLp5ft4sX16cT2yyClf9nOH3bNfH4elXsIiIesO/ICSYtTSJpXz7jB8bw+LU9aVjPO5WrYhcRcbP/JmXxhze3YQz89Zb+XNO3jVfXr2IXEXGTwuIy/vDmVt5MPsCguKbMu7kfMU0jvJ5DxS4i4gabMr9n8tIkDuQXM2VUF35zSSdCQ5w5P0XFLiJSCxUuy4vr05m/bhetG4ez7NdDGdi+maOZVOwiIjWUnX+SB5Yk883eo1zXrw2zxvYiMryu07FU7CIiNbEm5QAzVm3BWph3c1+u7x/jdKT/R8UuInIeikrKefytbSzflEW/dk2YP6Ef7Zs3cDrWj6jYRUSqKSUrn0lLktl7pIjfXRrPpJGdqevQgPRsVOwiIufgcln+sWEPz36wgxaN6rH43qEM7djc6VhnpGIXETmLQwXFTFmWzJe7j3BV71Y8dX0fGkc4PyA9GxW7iMgZvLf1ENNXpVBS5mLOuD7cmBCDMcbpWOekYhcR+YmTpRXMeieV/3y9j15tI5k/oT+dWjR0Ola1qdhFRE6x7UAB9y9OYvfhIn59cUceHNWVsFDfG5CejYpdRITKAenCLzKY894OmkTU5Y27hzCic5TTsWpExS4iQS+3sJgHl23ms115jOwezZzxfWjWIMzpWDWmYheRoPbx9hweWp7C8ZJynhzbi1uHxPrFgPRs3FbsxpgQIBHIttaOcddyRUQ8obisgqff3c6rX+6lW6tGLJk4lM7RjZyO5Rbu3GOfBKQBkW5cpoiI2+04VMj9i5PYkVPIry7owLQruxJeN8TpWG7jlmI3xsQAVwOzgSnuWKaIiLtZa3ntq0xmr00jMjyUV+4axKVdWzody+3ctcf+F2AacMZ/xxhjJgITAWJjY920WhGR6jlyvIRpK1JYtz2XS7q2YO74vrRoVM/pWB5R62I3xowBcq21m4wxl5zpfdbaBcACgISEBFvb9YqIVNeGnYd5cPlmCk6U8dg1Pfjl8Di/H5CejTv22C8ArjXGXAWEA5HGmDestbe5YdkiIjVWUl7B3Pd28PLnGXRu2ZDXfjWY7q0DfwxY62K31s4AZgBU7bFPVamLiNPSc49z/+IkUg8e4/ah7Xn46u4BNSA9G53HLiIBxVrL4m/288SabdSvG8I/70hgVI9op2N5lVuL3Vr7CfCJO5cpIlJd3xeVMn1VCu9vy2FEfBTP3tSX6Mhwp2N5nfbYRSQgfLk7jylLN3OkqISZV3XjnhEdqVMncAekZ6NiFxG/Vlbh4rkPd/L3T3fToXkDXr7zAnq1bex0LEep2EXEb+3NK2LSkiQ2ZxUwYVA7Hr2mBxFhqjX9FxARv2OtZcWmLB57axt1Q+rw0q0DGN27tdOxfIaKXUT8SsHJMh7+7xbWpBxkSIdmzLu5H22a1Hc6lk9RsYuI3/h271EmL0nm0LFiHrqiK/dd3ImQIB2Qno2KXUR8XnmFi+c/TueFj3cR0zSCFfcNo39sU6dj+SwVu4j4tP1HTzBpSRLf7cvnhgFt+eO1PWkUXtfpWD5NxS4iPmt1cjaP/HcrAPMn9OO6fm0dTuQfVOwi4nMKi8t4bPU2ViVlM7B9U/5ycz/aNYtwOpbfULGLiE9J2vc9k5Ykk/X9CSb9ojP/e1k8oSF1nI7lV1TsIuITKlyWlz5JZ95Hu2gVGc7SXw9jUFwzp2P5JRW7iDguO/8kDyxN5puMo1zTtw1Pju1F4/oakNaUil1EHLV2y0Gmr0yhwmV59sa+3DCgbUA/3cgbVOwi4oiiknKeeDuVpYn76RvTmPkT+hMX1cDpWAFBxS4iXrclq4D7lySx90gRv7mkEw+M6kJdDUjdRsUuIl7jclkWfLaHZz/YQfMG9fjPPUMZ1qm507ECjopdRLwi51gxU5Yl80X6Ea7s2Yqnx/WmSUSY07ECkopdRDzug22H+P3KFIrLXDx1Q28mDGqnAakHqdhFxGNOllYwe20qb2zcR882kcyf0J/4lg2djhXwVOwi4hGpB45x/5Ik0nOPc++FHZh6RVfqhYY4HSsoqNhFxK1cLsvCLzKY894OGkfU5bVfDeaiLi2cjhVUVOwi4ja5x4p5cPlmPtuVx8ju0cwZ34dmDTQg9TYVu4i4xUepOUxbmcKJ0nKeHNuLW4fEakDqEBW7iNTKqQPS7q0j+est/Yhv2cjpWEFNxS4iNXbqgPSeER146EoNSH2Bil1EzpsGpL5NxS4i5+WnA9JnxvWmecN6TseSU6jYRaTaNCD1Dyp2ETknDUj9i4pdRM5KA1L/o2IXkdPSgNR/qdhF5Gc0IPVvKnYR+ZF1aTk8tEIDUn+mYhcRAIrLKpj9Thqvb8zUgNTP1brYjTHtgNeAVoALWGCtnV/b5YqI96QeOMakJUns0oA0ILhjj70ceNBa+50xphGwyRjzobU21Q3LFhEP0oA0MNW62K21B4GDVR8XGmPSgLaAil3Eh+UWFjN1eQobdh5mZPeWPDOujwakAcKtx9iNMXFAf+Brdy5XRNzrhwFpUUk5s8b24jYNSAOK24rdGNMQWAlMttYeO83XJwITAWJjY921WhE5DxqQBge3FLsxpi6Vpb7IWrvqdO+x1i4AFgAkJCRYd6xXRKov7eAx7l9cOSC9e0QHpmlAGrDccVaMAf4FpFlrn6t9JBFxJ5fL8sqXe3nm3e0akAYJd+yxXwDcDmwxxiRXvTbTWrvWDcsWkVrQgDQ4ueOsmM8BTV1EfMy6tBymrUjhuAakQUdXnooEmOKyCv60No3XvqockC6Z0I/O0RqQBhMVu0gA0YBUQMUuEhA0IJVTqdhF/JwGpPJTKnYRP6YBqZyOil3ED2lAKmejYhfxM2kHK2+xuzNHA1I5PRW7iJ+w1vLKF3t5+r3tNK6vAamcmYpdxA/kFhbz0PIUPtWAVKpBxS7i4z5KzeH3KzUglepTsYv4qJOlFTz5TiqLvt5HDw1I5Tyo2EV80JasAiYtTSIjr4iJF3Xkwcu7aEAq1aZiF/EhFS7LPzbs5rkPdhLVsB6L7h7C8Pgop2OJn1Gxi/iI7PyTTFmazNcZR7m6d2tmX9+LJhFhTscSP6RiF/EBb20+wMP/3YLLZfnzjX0ZN6CtBqRSYyp2EQcVFpfx2OptrErKpn9sE/5ycz/aN2/gdCzxcyp2EYck7j3K5KXJHCwoZvLIzvzu0nhCQ+o4HUsCgIpdxMvKKlw8v24XL65PJ6ZpBMt+PYyB7Zs6HUsCiIpdxIsy8oqYvDSZzfvzGT8whsev7UnDevo1FPfST5SIF1hrWZa4nz++nUrdkDr87dYBXNW7tdOxJECp2EU87PuiUqavSuH9bTkM79ScZ2/qS+vG9Z2OJQFMxS7iQZ/tOszU5Zs5WlTKzKu6cc+IjtSpo9MYxbNU7CIeUFxWwdz3d/CvzzOIb9mQhb8cRM82jZ2OJUFCxS7iZjsOFTJpSRLbDxVyx7D2zBjdnfphus+LeI+KXcRNXC7Lq19WPggjMjyUV345iEu7tXQ6lgQhFbuIG+QeK2bqihQ27DzMZd1aMmd8H6L0IAxxiIpdpJY+2HaI6au2cKJUD8IQ36BiF6mhE6XlzFqTyuJv9tOzTSTzJ/QnvmVDp2OJqNhFaiIlK5/JS5LJOFLEfRd3YsqoLoSF6j4v4htU7CLnocJl+funu5n34U5aNKrHf+4ZyrBOzZ2OJfIjKnaRatp/9ARTliXz7d7vGdOnNbPH9qZxRF2nY4n8jIpd5BystazYlMUf307FAM/d1Jfr++tBGOK7VOwiZ3G0qJSZq7bw3rZDDOnQjGdv6ktM0winY4mclYpd5AzW78hl2ooU8k+UMmN0N+65sCMhus+L+AEVu8hPnCyt4E9r03h9YyZdoxvx77sG06NNpNOxRKrNLcVujLkSmA+EAC9ba592x3JFvG3z/nweWJrMnrwi7hnRgalXdCW8ru7zIv6l1ifeGmNCgBeB0UAP4BZjTI/aLlfEKxYtgrg4bJ06HItuy6u/m83Jsgr+c88QHhnTQ6UufskdV1QMBtKttXustaXAEuA6NyxXxLMWLYKJEyEzE2MtkbkHeOa9F1jXKpvh8VFOpxOpMXcUe1tg/ymfZ1W9JuLT7MyZcOLEj14LKy0m4o+POpRIxD3cUeynO03A/uxNxkw0xiQaYxIPHz7shtWK1Fze8RLYt//0X9y3z7thRNzMHcWeBbQ75fMY4MBP32StXWCtTbDWJrRo0cINqxWpmY9Sc7hi3gYORJ7h5zA21ruBRNzMHcX+LdDZGNPBGBMGTADecsNyRdyqqKScGatSuOe1RFpGhmOe+hNE/ORio4gImD3bmYAiblLr0x2tteXGmN8B71N5uuNCa+22WicTcaPv9n3PlKXJZB49wX0Xd+KBUZ2pF3ohNA6Hhx+uPPwSG1tZ6rfe6nRckVox1v7scLjHJSQk2MTERK+vV4JPWYWLv67bxQvr02nduD7P3dSXIR11N0bxT8aYTdbahHO9T1eeSsDaffg4U5YmszmrgHEDYnjs2h5EhutujBL4VOwScKy1vLExk9lr0wivG8JLtw5gdO/WTscS8RoVuwSUgwUnmbYihc925XFRlxbMHd+H6Mhwp2OJeJWKXQKCtZbVyQf4w+qtlFdYnhzbi1v1UGkJUip28XtHjpfwyJtbeXfrIQa2b8qzN/YlLqqB07FEHKNiF7/2YWoOM1alcOxkOdNHd+Ne3TNdRMUu/qmwuIwn3k5l+aYsurVqxOt3D6F7a90zXQRU7OKHvtp9hKnLN3Ow4CS/vbQTk37RhbBQd1xELRIYVOziN4rLKpjz3g4WfpFBh6gGLL9vOAPbN3U6lojPUbGLX9i8P58py5LZfbiIO4a1Z/robkSE6cdX5HT0myE+razCxQsfp/PC+nRaNKzH63cP5sLOujuoyNmo2MVn7copZMqyzWzJLuCG/m157NqeNK6vWwKInIuKXXyOy2VZ+EUGc97fQcN6ofz9tgFc2Uu3BBCpLhW7+JT9R08wdflmvs44ysju0Tx1Q29aNKrndCwRv6JiF59grWXR1/v409o06hjD3PF9GD8wRrcEEKkBFbs4Luv7E0xfuYXP0/MYER/F0+N6E9M04tzfKCKnpWIXx1hrWfLtfma/k4a1ltnX9+J/BuvGXSK1pWIXRxzIP8nvV1beXnd4p+Y8M64P7ZppL13EHVTs4lXWWpYl7ufJNWmUuyyzruvJrUPaU0c37hJxGxW7eM3BgpNMX7mFT3ceZkiHZswd35fY5tpLF3E3Fbt4nLWWFZuyeGJNKmUVLh6/pgd3DIvTXrqIh6jYxaNyjhUzY9UWPt6ey6C4pswdr4dgiHiail08wlrLf5OyefytbZRWuPjDmB7cNVx76SLeoGIXt8stLGbmqq18lJbDwPZNmTu+Dx1bNHQ6lkjQULGL21hrWfldNrPWpFJcVsEjV3fnrgs66FF1Il6mYhe3yM4/ycxVlWe8DGzflGfG9SG+pfbSRZygYpdacbksi77Zx9Nr07DA49f04PZhcdpLF3GQil1qLCOviN+vTOGbjKOMiI/iqRt66+pRER+gYpfzVl7hYuEXGTz7wU7CQuswZ1wfbkzQnRhFfIWKXc7LjkOFTFuxmc1ZBYzqEc2TY3sRHRnudCwROYWKXaqltNzF3z5J58X16USG1+Wvt/RnTJ/W2ksX8UEqdjmnlKx8pq1IYfuhQq7r14bHrulJswZhTscSkTNQscsZFZdVMO+jnfxzwx5aNgrn5TsSGNkj2ulYInIOKnY5rc935fHwm1vIPHKCWwa3Y8ZV3YkMr+t0LBGpBhW7/MiR4yXMfieNVUnZdIhqwH/uHcLwTlFOxxKR81CrYjfGzAWuAUqB3cBd1tp8dwQT77LWsuq7bJ58J5XjJeXcf1k8v7k0nvC6IU5HE5HzVNs99g+BGdbacmPMM8AM4Pe1jyXetDeviIff3MIX6UcY2L4pT93Qmy7RjZyOJSI1VKtit9Z+cMqnG4HxtYsj3lRW4WLBhj08v24XYSF1mDW2F7cOjtWtdUX8nDuPsf8KWOrG5YkHfbfve2as3MKOnEJG92rF49f21IVGIgHinMVujPkIaHWaLz1srV1d9Z6HgXJg0VmWMxGYCBAbG1ujsFJ7hcVlzH1/B69vzCS6UTgLbh/I5T1P99crIv7qnMVurR15tq8bY+4ExgC/sNbasyxnAbAAICEh4YzvE8+w1vLu1kM88XYqOYXF3Dksjgcv70IjncIoEnBqe1bMlVQOSy+21p5wTyRxt715RTz61jY27DxM99aRvHTbAPrHNnU6loh4SG2Psb8A1AM+rLpnyEZr7X21TiVuUVxWwd8/3c3fPtlNWEgdHh3TgzuGtSc0pI7T0UTEg2p7Vky8u4KIe3268zCPrt5K5pETXNO3DY9c3V3DUZEgoStPA8yhgmKeWLONtVsO0TGqAW/cPYQRnXXlqEgwUbEHiLIKF//+ci/zPtxJucsy9fIu3HtRR+qF6spRkWCjYg8AiXuP8sibW9l+qJDLurXkj9f21CPqRIKYit2P5R4r5ul3t7MqKZu2Teqz4PaBjOoRrYdfiAQ5FbsfKimv4JUv9vLXdbsoq7D89tJO/PbSeCLC9NcpIip2v7N+ey5PrEklI6+Ikd2j+cOY7rRv3sDpWCLiQ1TsfiIjr4hZa1L5eHsuHVs04NW7BnFJ15ZOxxIRH6Ri93HHS8p54eN0/vX5HuqFhvDwVd25c3gcYaG6yEhETk/F7qNcLsvqzdk8tXY7uYUljB8Yw7Qru9KykS4yEpGzU7H7oMS9R5n1Thqb9+fTN6Yx/7h9oO7tIiLVpmL3IZlHinj63e28u/UQrSLD+fONfbmhf1s9+EJEzouK3QcUnCjjhfW7ePXLvdQNqcOUUV2498KO1A/TVaMicv5U7A4qq3CxaGMmf1m3i4KTZdw0sB0PXt6FlrpZl4jUgordAdZaPkrL5am1aezJK2JEfBQzr+pOjzaRTkcTkQCgYveyTZnfM+e97XydcZT4lg155ZeDuKRrC90GQETcRsXuJbtyCpnz/g4+TM0hqmE9Zo3txS2D2umhFyLidip2D8vOP8m8D3ey6rssGoSFMvXyLvxqRAfd10VEPEbt4iFHi0p5cX06r3+VCQbuHtGB31wST9MGYU5HE5EAp2J3s6KSchZ+nsGCDXsoKi1n3IAYJo/qQtsm9Z2OJiJBQsXuJidLK3hjYyZ//3Q3R4pKubxHNA9d0ZXO0Y2cjiYiQUbFXkvFZT8U+h7yjpdwYecoJo/swsD2ugWAiDhDxV5DxWUVLP5mHy99spvcwhKGd2rOS7cNYFBcM6ejiUiQU7Gfp5LyCpZ+u58X16eTc6yEIR2a8fwt/RnasbnT0UREABV7tZ0srWDpt/v4x4Y9HCwoZlBcU+bd3I/hnaKcjiYi8iMq9nM4VlzG619lsvDzDI4UlZLQvilzx/flgvjmulpURHySiv0MjhwvYeEXGbz2ZSaFJeVc3KUFv700nsEddAxdRHybiv0nDuSf5J+f7WHxN/soKXcxulcrfnNJPL3aNnY6mohItajYq6QdPMa/Ps9gdXI21sLY/m257+JOxLds6HQ0EZHzEtTFbq3l052HefmzDD5Pz6N+3RD+Z3As917UkZimEU7HExGpkaAs9uKyClYnZ/PyZxnsyj1OdGQ9pl3Zlf8ZHEuTCN3LRUT8W1AV+5HjJbyxcR+vb9xL3vFSureO5Lmb+jKmTxvCQnX7XBEJDAFf7NZakvfn8/pXmaxJOUhphYvLurXknhEdGNZJpyyKSOAJ2GI/WVrB25sP8NrGvWzNPkbDeqHcMrgdtw+L00BURAJawBX73rwi3tiYyfJNWRScLKNLdENmje3F9f3b0rBewG2uiMjPBETTlZRX8MG2HJYl7uezXXmE1jFc0asVdwxtz+AOzXS4RUSCiluK3RgzFZgLtLDW5rljmdWRdvAYS7/dz5vJ2eSfKKNtk/pMHtmZWwbHEh0Z7q0YIiI+pdbFboxpB4wC9tU+zrkdKy7jreQDLEvcT0pWAWEhdRjVM5qbE9pxQXwUIXW0dy4iwc0de+zzgGnAajcs66yeX7eLv32STnGZi26tGvHomB5c37+tniMqInKKWhW7MeZaINtau9kbx7FbNw7nhgEx3JzQjj4xjXXsXETkNM5Z7MaYj4BWp/nSw8BM4PLqrMgYMxGYCBAbG3seEf+/GxPacWNCuxp9r4hIsDDW2pp9ozG9gXXAiaqXYoADwGBr7aGzfW9CQoJNTEys0XpFRIKVMWaTtTbhXO+r8aEYa+0WoOUpK9wLJHjzrBgREfk53SBFRCTAuO0CJWttnLuWJSIiNac9dhGRAKNiFxEJMCp2EZEAo2IXEQkwNT6PvVYrNeYwkHke3xIFBONplMG43cG4zRCc2x2M2wy12+721toW53qTI8V+vowxidU5KT/QBON2B+M2Q3BudzBuM3hnu3UoRkQkwKjYRUQCjL8U+wKnAzgkGLc7GLcZgnO7g3GbwQvb7RfH2EVEpPr8ZY9dRESqyeeL3RhzpTFmhzEm3Rgz3ek8nmaMaWeMWW+MSTPGbDPGTHI6k7cYY0KMMUnGmDVOZ/EWY0wTY8wKY8z2qr/zYU5n8gZjzANVP99bjTGLjTEB95BiY8xCY0yuMWbrKa81M8Z8aIzZVfVnU0+s26eL3RgTArwIjAZ6ALcYY3o4m8rjyoEHrbXdgaHAb4Ngm38wCUhzOoSXzQfes9Z2A/oSBNtvjGkL3E/lbb57ASHABGdTecSrwJU/eW06sM5a25nK51l4ZGfVp4sdGAykW2v3WGtLgSXAdQ5n8ihr7UFr7XdVHxdS+Yve1tlUnmeMiQGuBl52Oou3GGMigYuAfwFYa0uttfnOpvKaUKC+MSYUiKDyIT0BxVq7ATj6k5evA/5d9fG/gbGeWLevF3tbYP8pn2cRBCX3A2NMHNAf+NrZJF7xFyofiu5yOogXdQQOA69UHYJ62RjTwOlQnmatzQb+DOwDDgIF1toPnE3lNdHW2oNQuRPHKQ8rcidfL/bTPa06KE7jMcY0BFYCk621x5zO40nGmDFArrV2k9NZvCwUGAC8ZK3tDxThoX+a+5Kq48rXAR2ANkADY8xtzqYKLL5e7FnAqU+v/uG5qgHNGFOXylJfZK1d5XQeL7gAuLbq8YpLgMuMMW84G8krsoAsa+0P/yJbQWXRB7qRQIa19rC1tgxYBQx3OJO35BhjWgNU/ZnriZX4erF/C3Q2xnQwxoRROWB5y+FMHmWMMVQec02z1j7ndB5vsNbOsNbGVD2FawLwsbU24Pfgqh76vt8Y07XqpV8AqQ5G8pZ9wFBjTETVz/svCIKhcZW3gDurPr4TWO2Jlbjt0XieYK0tN8b8Dnifysn5QmvtNodjedoFwO3AFmNMctVrM621ax3MJJ7zv8Ciqh2XPcBdDufxOGvt18aYFcB3VJ4FlkQAXoVqjFkMXAJEGWOygMeAp4Flxpi7qfwf3I0eWbeuPBURCSy+fihGRETOk4pdRCTAqNhFRAKMil1EJMCo2EVEAoyKXUQkwKjYRUQCjIpdRCTA/F8oy41334QGjgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0.1, 10.0, 1000)\n",
    "plt.plot(x, f(x))\n",
    "plt.plot(np.array([root]), np.array([f(root)]), 'ro')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ODEs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many methods exist for integrating ordinary differential equations.  Most will want you to write your ODEs as a system of first order equations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This system of ODEs is the Lorenz system:\n",
    "\n",
    "$$\\frac{dx}{dt} = \\sigma (y - x)$$\n",
    "$$\\frac{dy}{dt} = rx - y - xz$$\n",
    "$$\\frac{dz}{dt} = xy - bz$$\n",
    "\n",
    "the steady states of this system correspond to:\n",
    "\n",
    "$${\\bf f}({\\bf x}) = \n",
    "\\left (\n",
    "\\sigma (y -x), \n",
    "rx - y -xz, \n",
    "xy - bz\n",
    "\\right )^\\intercal\n",
    "= 0$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# system parameters\n",
    "sigma = 10.0\n",
    "b = 8./3.\n",
    "r = 28.0\n",
    "\n",
    "def rhs(t, x):\n",
    "    \"\"\" Builds the right hand side of the equation\n",
    "        parameters:\n",
    "        ---------- \n",
    "        t = time (not really needed in this function, but for a general rhs it would be)\n",
    "        x = 3d vector of components x,y,z\n",
    "        output:\n",
    "        -------\"\"\"\n",
    "    xdot = sigma*(x[1] - x[0])\n",
    "    ydot = r*x[0] - x[1] - x[0]*x[2]\n",
    "    zdot = x[0]*x[1] - b*x[2]\n",
    "\n",
    "    return np.array([xdot, ydot, zdot])\n",
    "\n",
    "def jac(t, x):\n",
    "    \"\"\" for any vectorial equation\n",
    "        J_{i,j} = df_i/dy_j\"\"\"\n",
    "\n",
    "    return np.array(\n",
    "        [ [-sigma, sigma, 0.0], \n",
    "          [r - x[2], -1.0, -x[0]],\n",
    "          [x[1], x[0], -b] ])\n",
    "\n",
    "def f(x):\n",
    "    return rhs(0.,x), jac(0.,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SciPy >= 1.0.0 has a uniform interface to the different ODE solvers, `solve_ivp()` -- we use that here.  Note, some (but not all) solvers provide a way to get the solution data at intermediate times (called dense output)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ode_integrate(X0, dt, tmax):\n",
    "    \"\"\" integrate using the VODE method, storing the solution each dt \"\"\"\n",
    "\n",
    "    r = integrate.solve_ivp(rhs, (0.0, tmax), X0,\n",
    "                            method=\"RK45\", dense_output=True)\n",
    "\n",
    "    # get the solution at intermediate times\n",
    "    ts = np.arange(0.0, tmax, dt)\n",
    "    \n",
    "    Xs = r.sol(ts)\n",
    "    return ts, Xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t, X = ode_integrate([1.0, 1.0, 20.0], 0.02, 30)\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "ax.plot(X[0,:], X[1,:], X[2,:])\n",
    "fig.set_size_inches(8.0,6.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi-variate root find"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can find the steady points in this system by doing a multi-variate root find on the RHS vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[ 8.48528137  8.48528137 27.        ]\n",
      "[-8.48528137 -8.48528137 27.        ]\n"
     ]
    }
   ],
   "source": [
    "sol1 = optimize.root(f, [1., 1., 1.], jac=True)\n",
    "print(sol1.x)\n",
    "\n",
    "sol2 = optimize.root(f, [10., 10., 10.], jac=True)\n",
    "print(sol2.x)\n",
    "\n",
    "sol3 = optimize.root(f, [-10., -10., -10.], jac=True)\n",
    "print(sol3.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'z')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "ax.plot(X[0,:], X[1,:], X[2,:])\n",
    "\n",
    "ax.scatter(sol1.x[0], sol1.x[1], sol1.x[2], marker=\"x\", color=\"r\")\n",
    "ax.scatter(sol2.x[0], sol2.x[1], sol2.x[2], marker=\"x\", color=\"r\")\n",
    "ax.scatter(sol3.x[0], sol3.x[1], sol3.x[2], marker=\"x\", color=\"r\")\n",
    "\n",
    "ax.set_xlabel(\"x\")\n",
    "ax.set_ylabel(\"y\")\n",
    "ax.set_zlabel(\"z\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stiff system of ODEs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A stiff system of ODEs is one where there are multiple disparate timescales for change and we need to respect all of them to get an accurate solution\n",
    "\n",
    "Here is an example from Chemical Kinetics (see, ex. Byrne & Hindmarsh 1986, or the VODE source code)\n",
    "\n",
    "\\begin{equation}\n",
    "\\frac{d}{dt} \\left (\n",
    "   \\begin{array}{c} y_1 \\newline y_2 \\newline y_3 \\end{array}\n",
    "  \\right ) =\n",
    "%\n",
    "\\left (\n",
    " \\begin{array}{rrr}\n",
    "  -0.04 y_1 & + 10^4 y_2 y_3  & \\newline\n",
    "   0.04 y_1 & - 10^4 y_2 y_3 & -3\\times 10^7 y_2^2 \\newline\n",
    "   &  & 3\\times 10^7 y_2^2 \n",
    "\\end{array}\n",
    "\\right )\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "{\\bf J} = \\left (\n",
    "\\begin{array}{ccc}\n",
    "  -0.04 & 10^4 y_3 & 10^4 y_2 \\newline\n",
    "   0.04 & -10^4 y_3 - 6\\times 10^7 y_2 & -10^4 y_2 \\newline\n",
    "   0 & 6\\times 10^7 y_2 & 0 \n",
    "\\end{array}\n",
    "\\right )\n",
    "\\end{equation}\n",
    "\n",
    "start with $y_1(0) = 1, y_2(0) = y_3(0) = 0$.  Long term behavior is $y_1, y_2 \\rightarrow 0; y_3 \\rightarrow 1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rhs(t, Y):\n",
    "    \"\"\" RHS of the system -- using 0-based indexing \"\"\"\n",
    "    y1 = Y[0]\n",
    "    y2 = Y[1]\n",
    "    y3 = Y[2]\n",
    "\n",
    "    dy1dt = -0.04*y1 + 1.e4*y2*y3\n",
    "    dy2dt =  0.04*y1 - 1.e4*y2*y3 - 3.e7*y2**2\n",
    "    dy3dt =                         3.e7*y2**2\n",
    "\n",
    "    return np.array([dy1dt, dy2dt, dy3dt])\n",
    "\n",
    "\n",
    "def jac(t, Y):\n",
    "    \"\"\" J_{i,j} = df_i/dy_j \"\"\"\n",
    "\n",
    "    y1 = Y[0]\n",
    "    y2 = Y[1]\n",
    "    y3 = Y[2]\n",
    "\n",
    "    df1dy1 = -0.04\n",
    "    df1dy2 = 1.e4*y3\n",
    "    df1dy3 = 1.e4*y2\n",
    "\n",
    "    df2dy1 = 0.04\n",
    "    df2dy2 = -1.e4*y3 - 6.e7*y2\n",
    "    df2dy3 = -1.e4*y2\n",
    "\n",
    "    df3dy1 = 0.0\n",
    "    df3dy2 = 6.e7*y2\n",
    "    df3dy3 = 0.0\n",
    "\n",
    "    return np.array([ [ df1dy1, df1dy2, df1dy3 ],\n",
    "                      [ df2dy1, df2dy2, df2dy3 ],\n",
    "                      [ df3dy1, df3dy2, df3dy3 ] ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vode_integrate(Y0, tmax):\n",
    "    \"\"\" integrate using the NDF method \"\"\"\n",
    "\n",
    "    r = integrate.solve_ivp(rhs, (0.0, tmax), Y0,\n",
    "                            method=\"BDF\", jac=jac, rtol=1.e-7, atol=1.e-10)\n",
    "\n",
    "    # Note: this solver does not have a dens_output method, instead we \n",
    "    # access the solution data where it was evaluated internally via\n",
    "    # the return object\n",
    "    \n",
    "    return r.t, r.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x181a05bda0>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Y0 = np.array([1.0, 0.0, 0.0])\n",
    "tmax = 4.e7\n",
    "\n",
    "ts, Ys = vode_integrate(Y0, tmax)\n",
    "\n",
    "ax = plt.gca()\n",
    "ax.set_xscale('log')\n",
    "ax.set_yscale('log')\n",
    "\n",
    "plt.plot(ts, Ys[0,:], label=r\"$y_1$\")\n",
    "plt.plot(ts, Ys[1,:], label=r\"$y_2$\")\n",
    "plt.plot(ts, Ys[2,:], label=r\"$y_3$\")\n",
    "\n",
    "plt.legend(loc=\"best\", frameon=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fitting\n",
    "\n",
    "Fitting is used to match a model to experimental data.  E.g. we have N points of $(x_i, y_i)$ with associated errors, $\\sigma_i$, and we want to find a simply function that best represents the data.\n",
    "\n",
    "Usually this means that we will need to define a metric, often called the residual, for how well our function matches the data, and then minimize this residual.  Least-squares fitting is a popular formulation.\n",
    "\n",
    "We want to fit our data to a function $Y(x, \\{a_j\\})$, where $a_j$ are model parameters we can adjust.  We want to find the optimal $a_j$ to minimize the distance of $Y$ from our data:\n",
    "$$\\Delta_i = Y(x_i, \\{a_j\\}) - y_i$$\n",
    "\n",
    "Least-squares minimizes $\\chi^2$:\n",
    "$$\\chi^2(\\{a_j\\}) = \\sum_{i=1}^N \\left ( \\frac{\\Delta_i}{\\sigma_i} \\right )^2$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### general linear least squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we'll make some experimental data (a quadratic with random fashion).  We use the randn() function to provide Gaussian normalized errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<ErrorbarContainer object of 3 artists>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def y_experiment2(a1, a2, a3, sigma, x):\n",
    "    \"\"\" return the experimental data in a quadratic + random fashion,                              \n",
    "        with a1, a2, a3 the coefficients of the quadratic and sigma is                             \n",
    "        the error.  This will be poorly matched to a linear fit for                                \n",
    "        a3 != 0 \"\"\"\n",
    "\n",
    "    N = len(x)\n",
    "\n",
    "    # randn gives samples from the \"standard normal\" distribution                                  \n",
    "    r = np.random.randn(N)\n",
    "\n",
    "    y = a1 + a2*x + a3*x*x + sigma*r\n",
    "\n",
    "    return y\n",
    "\n",
    "N = 40\n",
    "sigma = 5.0*np.ones(N)\n",
    "\n",
    "x = np.linspace(0, 100.0, N)\n",
    "y = y_experiment2(2.0, 1.50, -0.02, sigma, x)\n",
    "\n",
    "plt.scatter(x,y)\n",
    "plt.errorbar(x, y, yerr=sigma)#, fmt=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.26204501  1.57857146 -0.02029986]\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'NoneType' object has no attribute 'lower'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m--------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                           Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-37-c768ed924b42>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mafit\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mafit\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mafit\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrorbar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myerr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfmt\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36merrorbar\u001b[0;34m(x, y, yerr, xerr, fmt, ecolor, elinewidth, capsize, barsabove, lolims, uplims, xlolims, xuplims, errorevery, capthick, data, **kwargs)\u001b[0m\n\u001b[1;32m   2575\u001b[0m         \u001b[0mlolims\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlolims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muplims\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muplims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxlolims\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mxlolims\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2576\u001b[0m         \u001b[0mxuplims\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mxuplims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0merrorevery\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0merrorevery\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcapthick\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcapthick\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2577\u001b[0;31m         **({\"data\": data} if data is not None else {}), **kwargs)\n\u001b[0m\u001b[1;32m   2578\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2579\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1808\u001b[0m                         \u001b[0;34m\"the Matplotlib list!)\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlabel_namer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1809\u001b[0m                         RuntimeWarning, stacklevel=2)\n\u001b[0;32m-> 1810\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1811\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1812\u001b[0m         inner.__doc__ = _add_data_doc(inner.__doc__,\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36merrorbar\u001b[0;34m(self, x, y, yerr, xerr, fmt, ecolor, elinewidth, capsize, barsabove, lolims, uplims, xlolims, xuplims, errorevery, capthick, **kwargs)\u001b[0m\n\u001b[1;32m   3047\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_process_unit_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mydata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3048\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3049\u001b[0;31m         \u001b[0mplot_line\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mfmt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m'none'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3050\u001b[0m         \u001b[0mlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"label\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3051\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'lower'"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def resid(avec, x, y, sigma):\n",
    "    \"\"\" the residual function -- this is what will be minimized by the\n",
    "        scipy.optimize.leastsq() routine.  avec is the parameters we\n",
    "        are optimizing -- they are packed in here, so we unpack to\n",
    "        begin.  (x, y) are the data points \n",
    "\n",
    "        scipy.optimize.leastsq() minimizes:\n",
    "\n",
    "           x = arg min(sum(func(y)**2,axis=0))\n",
    "                    y\n",
    "\n",
    "        so this should just be the distance from a point to the curve,\n",
    "        and it will square it and sum over the points\n",
    "        \"\"\"\n",
    "\n",
    "    a0, a1, a2 = avec\n",
    "    \n",
    "    return (y - (a0 + a1*x + a2*x**2))/sigma\n",
    "\n",
    "\n",
    "# initial guesses\n",
    "a0, a1, a2 = 1, 1, 1\n",
    "\n",
    "afit, flag = optimize.leastsq(resid, [a0, a1, a2], args=(x, y, sigma))\n",
    "\n",
    "print(afit)\n",
    "\n",
    "plt.plot(x, afit[0] + afit[1]*x + afit[2]*x*x )\n",
    "plt.scatter(x,y)\n",
    "plt.errorbar(x, y, yerr=sigma, fmt=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\chi^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chisq = sum(np.power(resid(afit, x, y, sigma),2))\n",
    "normalization = len(x)-len(afit)\n",
    "print(chisq/normalization)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a nonlinear example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "our experiemental data -- an exponential"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a0 = 2.5\n",
    "a1 = 2./3.\n",
    "sigma = 5.0\n",
    "\n",
    "a0_orig, a1_orig = a0, a1\n",
    "\n",
    "x = np.linspace(0.0, 4.0, 25)\n",
    "y = a0*np.exp(a1*x) + sigma*np.random.randn(len(x))\n",
    "\n",
    "plt.scatter(x,y)\n",
    "plt.errorbar(x, y, yerr=sigma)#, fmt=None, label=\"_nolegend_\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "our function to minimize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def resid(avec, x, y):\n",
    "    \"\"\" the residual function -- this is what will be minimized by the                             \n",
    "        scipy.optimize.leastsq() routine.  avec is the parameters we                               \n",
    "        are optimizing -- they are packed in here, so we unpack to                                 \n",
    "        begin.  (x, y) are the data points                                                         \n",
    "                                                                                                   \n",
    "        scipy.optimize.leastsq() minimizes:                                                        \n",
    "                                                                                                   \n",
    "           x = arg min(sum(func(y)**2,axis=0))                                                     \n",
    "                    y                                                                              \n",
    "                                                                                                   \n",
    "        so this should just be the distance from a point to the curve,                             \n",
    "        and it will square it and sum over the points                                              \n",
    "        \"\"\"\n",
    "\n",
    "    a0, a1 = avec\n",
    "\n",
    "    # note: if we wanted to deal with error bars, we would weight each                             \n",
    "    # residual accordingly                                                                         \n",
    "    return y - a0*np.exp(a1*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a0, a1 = 1, 1\n",
    "afit, flag = optimize.leastsq(resid, [a0, a1], args=(x, y))\n",
    "\n",
    "print(flag)\n",
    "print(afit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, afit[0]*np.exp(afit[1]*x),\n",
    "           label=r\"$a_0 = $ %f; $a_1 = $ %f\" % (afit[0], afit[1]))\n",
    "plt.plot(x, a0_orig*np.exp(a1_orig*x), \":\", label=\"original function\")\n",
    "plt.legend(numpoints=1, frameon=False)\n",
    "plt.scatter(x,y, c=\"k\")\n",
    "plt.errorbar(x, y, yerr=sigma)#, fmt=None, label=\"_nolegend_\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FFTs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fourier transforms convert a physical-space (or time series) representation of a function into frequency space.  This provides an equivalent representation of the data with a new view.\n",
    "\n",
    "The FFT and its inverse in NumPy use:\n",
    "$$F_k = \\sum_{n=0}^{N-1} f_n e^{-2\\pi i nk/N}$$\n",
    "\n",
    "$$f_n = \\frac{1}{N} \\sum_{k=0}^{N-1} F_k \n",
    "   e^{2\\pi i n k/N}$$\n",
    "   \n",
    "\n",
    "Both NumPy and SciPy have FFT routines that are similar.  However, the NumPy version returns the data in a more convenient form.\n",
    "\n",
    "It's always best to start with something you understand -- let's do a simple sine wave.  Since our function is real, we can use the rfft routines in NumPy -- the understand that we are working with real data and they don't return the negative frequency components.\n",
    "\n",
    "One important caveat -- FFTs assume that you are periodic.  If you include both endpoints of the domain in the points that comprise your sample then you will not match this assumption.  Here we use endpoint=False with linspace()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def single_freq_sine(npts):\n",
    "\n",
    "    # a pure sine with no phase shift will result in pure imaginary                                         \n",
    "    # signal                                                                                                \n",
    "    f_0 = 0.2\n",
    "\n",
    "    xmax = 10.0/f_0\n",
    "    \n",
    "    xx = np.linspace(0.0, xmax, npts, endpoint=False)\n",
    "\n",
    "    f = np.sin(2.0*np.pi*f_0*xx)\n",
    "\n",
    "    return xx, f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make our life easier, we'll define a function that plots all the stages of the FFT process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_FFT(xx, f):\n",
    "\n",
    "    npts = len(xx)\n",
    "\n",
    "    # Forward transform: f(x) -> F(k)                                                                       \n",
    "    fk = np.fft.rfft(f)\n",
    "\n",
    "    # Normalization -- the '2' here comes from the fact that we are                                         \n",
    "    # neglecting the negative portion of the frequency space, since                                         \n",
    "    # the FFT of a real function contains redundant information, so                                         \n",
    "    # we are only dealing with 1/2 of the frequency space.                                                  \n",
    "    #                                                                                                       \n",
    "    # technically, we should only scale the 0 bin by N, since k=0 is                                        \n",
    "    # not duplicated -- we won't worry about that for these plots                                           \n",
    "    norm = 2.0/npts\n",
    "\n",
    "    fk = fk*norm\n",
    "\n",
    "    fk_r = fk.real\n",
    "    fk_i = fk.imag\n",
    "\n",
    "    # the fftfreq returns the postive and negative (and 0) frequencies                                      \n",
    "    # the newer versions of numpy (>=1.8) have an rfftfreq() function                                       \n",
    "    # that really does what we want -- we'll use that here.                                                 \n",
    "    k = np.fft.rfftfreq(npts)\n",
    "\n",
    "    # to make these dimensional, we need to divide by dx.  Note that                                        \n",
    "    # max(xx) is not the true length, since we didn't have a point                                          \n",
    "    # at the endpoint of the domain.                                                                        \n",
    "    kfreq = k*npts/(max(xx) + xx[1])\n",
    "\n",
    "    # Inverse transform: F(k) -> f(x) -- without the normalization                                          \n",
    "    fkinv = np.fft.irfft(fk/norm)\n",
    "\n",
    "    # plots\n",
    "    plt.subplot(411)\n",
    "\n",
    "    plt.plot(xx, f)\n",
    "    plt.xlabel(\"x\")\n",
    "    plt.ylabel(\"f(x)\")\n",
    "\n",
    "    plt.subplot(412)\n",
    "\n",
    "    plt.plot(kfreq, fk_r, label=r\"Re($\\mathcal{F}$)\")\n",
    "    plt.plot(kfreq, fk_i, ls=\":\", label=r\"Im($\\mathcal{F}$)\")\n",
    "    plt.xlabel(r\"$\\nu_k$\")\n",
    "    plt.ylabel(\"F(k)\")\n",
    "\n",
    "    plt.legend(fontsize=\"small\", frameon=False)\n",
    "\n",
    "    plt.subplot(413)\n",
    "\n",
    "    plt.plot(kfreq, np.abs(fk))\n",
    "    plt.xlabel(r\"$\\nu_k$\")\n",
    "    plt.ylabel(r\"|F(k)|\")\n",
    "\n",
    "    plt.subplot(414)\n",
    "\n",
    "    plt.plot(xx, fkinv.real)\n",
    "    plt.xlabel(r\"$\\nu_k$\")\n",
    "    plt.ylabel(r\"inverse F(k)\")\n",
    "\n",
    "    f = plt.gcf()\n",
    "    \n",
    "    f.set_size_inches(10,8)\n",
    "    plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "npts = 128\n",
    "xx, f = single_freq_sine(npts)\n",
    "plot_FFT(xx, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A cosine is shifted in phase by pi/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def single_freq_cosine(npts):\n",
    "\n",
    "    # a pure cosine with no phase shift will result in pure real                                            \n",
    "    # signal                                                                                                \n",
    "    f_0 = 0.2\n",
    "\n",
    "    xmax = 10.0/f_0\n",
    "\n",
    "    xx = np.linspace(0.0, xmax, npts, endpoint=False)\n",
    "\n",
    "    f = np.cos(2.0*np.pi*f_0*xx)\n",
    "\n",
    "    return xx, f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xx, f = single_freq_cosine(npts)\n",
    "plot_FFT(xx, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at a sine with a pi/4 phase shift"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def single_freq_sine_plus_shift(npts):\n",
    "\n",
    "    # a pure sine with no phase shift will result in pure imaginary                                         \n",
    "    # signal                                                                                                \n",
    "    f_0 = 0.2\n",
    "\n",
    "    xmax = 10.0/f_0\n",
    "\n",
    "    xx = np.linspace(0.0, xmax, npts, endpoint=False)\n",
    "\n",
    "    f = np.sin(2.0*np.pi*f_0*xx + np.pi/4)\n",
    "\n",
    "    return xx, f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xx, f = single_freq_sine_plus_shift(npts)\n",
    "plot_FFT(xx, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A frequency filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we'll setup a simple two-frequency sine wave and filter a component"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def two_freq_sine(npts):\n",
    "\n",
    "    # a pure sine with no phase shift will result in pure imaginary             \n",
    "    # signal                                                                    \n",
    "    f_0 = 0.2\n",
    "    f_1 = 0.5\n",
    "\n",
    "    xmax = 10.0/f_0\n",
    "\n",
    "    # we call with endpoint=False -- if we include the endpoint, then for       \n",
    "    # a periodic function, the first and last point are identical -- this       \n",
    "    # shows up as a signal in the FFT.                                          \n",
    "    xx = np.linspace(0.0, xmax, npts, endpoint=False)\n",
    "\n",
    "    f = 0.5*(np.sin(2.0*np.pi*f_0*xx) + np.sin(2.0*np.pi*f_1*xx))\n",
    "\n",
    "    return xx, f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "npts = 256\n",
    "\n",
    "xx, f = two_freq_sine(npts)\n",
    "\n",
    "plt.plot(xx, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we'll take the transform: f(x) -> F(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# normalization factor: the 2 here comes from the fact that we neglect          \n",
    "# the negative portion of frequency space because our input function            \n",
    "# is real                                                                       \n",
    "norm = 2.0/npts\n",
    "fk = norm*np.fft.rfft(f)\n",
    "\n",
    "ofk_r = fk.real.copy()\n",
    "ofk_i = fk.imag.copy()\n",
    "\n",
    "# get the frequencies\n",
    "k = np.fft.rfftfreq(len(xx))\n",
    "\n",
    "# since we don't include the endpoint in xx, to normalize things, we need       \n",
    "# max(xx) + dx to get the true length of the domain\n",
    "#\n",
    "# This makes the frequencies essentially multiples of 1/dx\n",
    "kfreq = k*npts/(max(xx) + xx[1])\n",
    "\n",
    "\n",
    "plt.plot(kfreq, fk.real, label=\"real\")\n",
    "plt.plot(kfreq, fk.imag, \":\", label=\"imaginary\")\n",
    "plt.legend(frameon=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filter out the higher frequencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fk[kfreq > 0.4] = 0.0\n",
    "\n",
    "# element 0 of fk is the DC component                                           \n",
    "fk_r = fk.real\n",
    "fk_i = fk.imag\n",
    "\n",
    "\n",
    "# Inverse transform: F(k) -> f(x)                                               \n",
    "fkinv = np.fft.irfft(fk/norm)\n",
    "\n",
    "plt.plot(xx, fkinv.real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### general manipulations of matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can use regular NumPy arrays or you can use a special matrix class that offers some short cuts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1.0, 2.0], [3.0, 4.0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(a.transpose())\n",
    "print(a.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ainv = np.linalg.inv(a)\n",
    "print(ainv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.dot(a, ainv))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the eye() function will generate an identity matrix (as will the identity())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.eye(2))\n",
    "print(np.identity(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can solve Ax = b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([5, 7])\n",
    "x = np.linalg.solve(a, b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The matrix class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.matrix('1.0 2.0; 3.0 4.0')\n",
    "print(A)\n",
    "print(A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.matrix('5.0 7.0')\n",
    "Y = X.T\n",
    "\n",
    "print(A*Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A.I*Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tridiagonal matrix solve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we'll solve the equation:\n",
    "\n",
    "$$f^{\\prime\\prime} = g(x)$$\n",
    "\n",
    "with $g(x) = sin(x)$, and the domain $x \\in [0, 2\\pi]$, with boundary conditions $f(0) = f(2\\pi) = 0$.  The solution is simply $f(x) = -sin(x)$.\n",
    "\n",
    "We'll use a grid of $N$ points with $x_0$ on the left boundary and $x_{N-1}$ on the right boundary.\n",
    "\n",
    "We difference our equation as:\n",
    "\n",
    "$$f_{i+1} - 2 f_i + f_{i-1} = \\Delta x^2 g_i$$\n",
    "\n",
    "We keep the boundary points fixed, so we only need to solve for the $N-2$ interior points.  Near the boundaries, our difference is:\n",
    "$$f_2 - 2 f_1 = \\Delta x^2 g_1$$\n",
    "\n",
    "and\n",
    "\n",
    "$$-2f_{N-1} + f_{N-2} = \\Delta x^2 g_{N-1}$$.\n",
    "\n",
    "We can write the system of equations for solving for the $N-2$ interior points as:\n",
    "\n",
    "\\begin{equation}\n",
    "A = \\left (\n",
    "\\begin{array}{ccccccc}\n",
    "-2 &  1 &    &        &         &           &          \\newline\n",
    "1  & -2 &  1 &        &         &           &          \\newline\n",
    "   &  1 & -2 & 1      &         &           &          \\newline\n",
    "   &         & \\ddots & \\ddots & \\ddots  &           &          \\newline\n",
    "   &         &        & \\ddots & \\ddots  & \\ddots  &          \\newline\n",
    "   &         &        &        & 1       & -2 & 1  \\newline\n",
    "   &         &        &        &         & 1  & -2 \\newline\n",
    "\\end{array}\n",
    "\\right )\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "x = \\left (\n",
    "\\begin{array}{c}\n",
    "f_\\mathrm{1} \\\\\\\n",
    "f_\\mathrm{2} \\\\\\\n",
    "f_\\mathrm{3} \\\\\\\n",
    "\\vdots \\\\\\\n",
    "\\vdots \\\\\\\n",
    "f_\\mathrm{N-2} \\\\\\\n",
    "f_\\mathrm{N-1} \\\\\\\n",
    "\\end{array}\n",
    "\\right )\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "b = \\Delta x^2 \\left (\n",
    "\\begin{array}{c}\n",
    "g_\\mathrm{1} \\\\\\\n",
    "g_\\mathrm{2} \\\\\\\n",
    "g_\\mathrm{3} \\\\\\\n",
    "\\vdots \\\\\\\n",
    "\\vdots \\\\\\\n",
    "g_\\mathrm{N-2} \\\\\\\n",
    "g_\\mathrm{N-1}\\\\\\\n",
    "\\end{array}\n",
    "\\right )\n",
    "\\end{equation}\n",
    "\n",
    "Then we just solve $A x = b$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.linalg as linalg\n",
    "\n",
    "# our grid -- including endpoints\n",
    "N = 100\n",
    "x = np.linspace(0.0, 2.0*np.pi, N, endpoint=True)\n",
    "dx = x[1]-x[0]\n",
    "\n",
    "# our source\n",
    "g = np.sin(x)\n",
    "\n",
    "# our matrix will be tridiagonal, with [1, -2, 1] on the diagonals\n",
    "# we only solve for the N-2 interior points\n",
    "\n",
    "# diagonal\n",
    "d = -2*np.ones(N-2)\n",
    "\n",
    "# upper -- note that the upper diagonal has 1 less element than the\n",
    "# main diagonal.  The SciPy banded solver wants the matrix in the \n",
    "# form:\n",
    "#\n",
    "# *    a01  a12  a23  a34  a45    <- upper diagonal\n",
    "# a00  a11  a22  a33  a44  a55    <- diagonal\n",
    "# a10  a21  a32  a43  a54   *     <- lower diagonal\n",
    "#\n",
    "\n",
    "u = np.ones(N-2)\n",
    "u[0] = 0.0\n",
    "\n",
    "# lower\n",
    "l = np.ones(N-2)\n",
    "l[N-3] = 0.0\n",
    "\n",
    "# put the upper, diagonal, and lower parts together as a banded matrix\n",
    "A = np.matrix([u,d,l])\n",
    "\n",
    "# solve A sol = dx**2 g for the inner N-2 points\n",
    "sol = linalg.solve_banded((1,1), A, dx**2*g[1:N-1])\n",
    "\n",
    "plt.plot(x[1:N-1], sol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-fd21cf3374f7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_line_magic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'timeit'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'v + 1'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "v = np.random.randint(0, 100, 1000)\n",
    "%timeit v + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = list(v)\n",
    "%timeit [ val + 2 for val in lst]"
   ]
  },
  {
   "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": 1
}