notebook5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Python para ciencias e ingenierías (notebook 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ing. Martín Gaitán\n",
    "\n",
    "Email: `gaitan@gmail.com`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Links útiles**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repositorio del curso:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### http://bit.ly/cursopy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python \"temporal\" online:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### http://try.jupyter.org"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Descarga de [Python \"Anaconda\"](http://continuum.io/downloads#py34)\n",
    "- Resumen de [sintaxis markdown](https://github.com/jupyter/strata-sv-2015-tutorial/blob/master/resources/Working%20With%20Markdown%20Cells.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Una yapa de Numpy: Vectorizar funciones "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Sabemos que Numpy opera vectorialmente, es decir, ejecutando la operación aritmetica o la \"función universal\" (ufunc)\n",
    "a cada uno de los elementos de los operadores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "x = np.array([1, 2., 3.])\n",
    "y = np.array([.3, -5, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También sabemos que cuando operamos un vector con un escalar se aplica el broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True], dtype=bool)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x >= 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pero no podemos hacer un \"casting\" automático de un array tipo booleano a un sólo booleano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-e301f242580e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "bool(x >= 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese \"cast\" se puede hacer con funciones de agregación booleanas, como `all`, `allclose`, `any`, etc. pero muchas veces eso implica cambiar código que ya tenemos escrito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(x >= 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemlo, veamos este par de funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func1(a):\n",
    "    return a ** 2\n",
    "\n",
    "\n",
    "def func2(a):\n",
    "    \"\"\"Return the same value if it's negative, otherwise returns its square\"\"\"\n",
    "    \n",
    "    if a < 0:\n",
    "        return a\n",
    "    else:\n",
    "        return a**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "obviamente ambas funcionan con escalares,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, -4)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func1(10), func2(-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y `func1` funciona también para arrays, debido a que la operación que hace (potencia) admite broadcasting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func1(np.arange(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, como el casting de un array de booleanos a un sólo booleano no es automático, `func2` no es \"universal\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-9251847b0339>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunc2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\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<ipython-input-5-3886a6ae5a87>\u001b[0m in \u001b[0;36mfunc2\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;34m\"\"\"Return the same value if it's negative, otherwise returns its square\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "func2(np.arange(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que necesitamos es **vectorizar la función**. `vectorize` transforma una función cualquiera en una de tipo universal: esto es, cuando un parámetro es un array y la aplicación directa no funciona, automáticamente se realiza una iteración implicita elemento a elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_func2 = np.vectorize(func2)\n",
    "v_func2(np.arange(10))    # para cada elemento de x, aplica func2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(v_func2), v_func2.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y sigue funcionando para escalares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_func2(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Defina como función universal de numpy la siguiente función definida por partes y grafique entre -5 y -5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "  y = f(x) =\n",
    "   \\left \\{\n",
    "   \\begin{array}{rcl}\n",
    "      x + 3, & \\mbox{si } & x < -1 \\\\\n",
    "      x^2+1, & \\mbox{si } & -1 \\le x \\le 2 \\\\\n",
    "      5, & \\mbox{si } &  x > 2\n",
    "   \\end{array}\n",
    "   \\right .\n",
    "$$\n",
    "\n",
    "<!--\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def _f(x):\n",
    "    if x < -1:\n",
    "        return x + 3\n",
    "    elif -1 <= x <= 2:\n",
    "        return x**2 + 1\n",
    "    else:\n",
    "        return 5\n",
    "f = np.vectorize(_f)\n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "ax = plt.subplot(1,1,1)\n",
    "\n",
    "x = np.linspace(-5,5,100)\n",
    "ax.plot(x,f(x))\n",
    "ax.set_ylim(top=6);\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scipy: parado sobre hombros de gigantes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La biblioteca Scipy se basa en los arrays multidimensionales de Numpy e implementa cientos de algoritmos científicos de alto nivel, clasificados en subpaquetes temáticos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "* Integración y ecuaciones diferenciales ([scipy.integrate](http://docs.scipy.org/doc/scipy/reference/integrate.html))\n",
    "* Optimización ([scipy.optimize](http://docs.scipy.org/doc/scipy/reference/optimize.html))\n",
    "* Interpolación ([scipy.interpolate](http://docs.scipy.org/doc/scipy/reference/interpolate.html))\n",
    "* Transformada de Fourier ([scipy.fftpack](http://docs.scipy.org/doc/scipy/reference/fftpack.html))\n",
    "* Procesamiento de señales ([scipy.signal](http://docs.scipy.org/doc/scipy/reference/signal.html))\n",
    "* Álgebra lineal (mejor que `numpy.linalg`) ([scipy.linalg](http://docs.scipy.org/doc/scipy/reference/linalg.html))\n",
    "* Algoritmos optimizados para matrices ralas ([scipy.sparse](http://docs.scipy.org/doc/scipy/reference/sparse.html))\n",
    "* Estadística ([scipy.stats](http://docs.scipy.org/doc/scipy/reference/stats.html))\n",
    "* Procesamiento de imágenes ([scipy.ndimage](http://docs.scipy.org/doc/scipy/reference/ndimage.html))\n",
    "* Entrada/salida de archivos ([scipy.io](http://docs.scipy.org/doc/scipy/reference/io.html))\n",
    "* Funciones especiales ([scipy.special](http://docs.scipy.org/doc/scipy/reference/special.html))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y hay más! Toda la documentación en http://docs.scipy.org/doc/scipy/reference/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos algunas aplicaciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Integrales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La evaluación numérica de integrales de la forma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\displaystyle \\int_a^b f(x) dx$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "se llaman *cuadratura numérica*, o simplemente *cuadratura*. SciPy tiene las funciones  `quad`, `dblquad` y `tplquad` para cuadraturas simples, dobles o triples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "quad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.integrate import quad\n",
    "\n",
    "# definimos f f(x)\n",
    "def f(x):\n",
    "    return 2*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val, abserr = quad(f, 0, 3)\n",
    "print(\"integral value =\", val, \", absolute error =\", abserr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ya que estamos definiendo \"funciones objetivo\", hay otra manera de definir funciones simples en python, que sólo si queremos las asignamos a un nombre. \n",
    "Por ejemplo \n",
    "\n",
    "```python\n",
    "def f(x): \n",
    "    return x+2\n",
    "```\n",
    "\n",
    "se podría definir así"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# otro ejemplo de funcion lambda\n",
    "f = lambda x: x+2     #  -> def f(x): return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo útil es que esta forma de crear **funciones anónimas** permite definirlas directamente al pasarla como argumento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quad(lambda x: x**2, 0, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integración de funciones con parámetros adicionales\n",
    "\n",
    "\n",
    "Si necesitaramos pasarle parámetros a nuestra función lo hacemos en un tupla en el argumento `args`. Por ejemplo, supongamos que tenemos una función de la forma $g(x) = x^n$ donde `x` es la variable independiente y `n` es un parámetro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def g(x, n):\n",
    "    return x**n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si quisieramos evaluar la integral de esta función de x fijando n en 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# evalua la integral x**3\n",
    "quad(g, 0, 5, args=(3,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from scipy import integrate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate.dblquad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ecuaciones diferenciales ordinarias\n",
    "\n",
    "El paquete de integración también tiene funciones para resolver [ecuaciones diferenciales ordinarias](https://en.wikipedia.org/wiki/Ordinary_differential_equation)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, para resolver \n",
    "\n",
    "$$\\frac{\\mathrm{d}y}{\\mathrm{d}t} = -2y$$\n",
    "\n",
    " con $t  \\in [-1, 5]$  y la condición inicial $y(0) = 1$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline \n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from scipy.integrate import odeint\n",
    "\n",
    "t = np.linspace(-1, 5, 100)\n",
    "y = odeint(lambda y,t: -2*y, 1, t)\n",
    "plt.plot(t,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vemos, [el resultado es correcto](http://www.wolframalpha.com/input/?i=y%27+%3D+-2y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios\n",
    "\n",
    "1. Dado el ejemplo de [gráfico \"fill\"](http://matplotlib.org/examples/lines_bars_and_markers/fill_demo.html) calcular el área de toda la superficie sombreada en rojo\n",
    "\n",
    "<!-- solucion\n",
    "\n",
    "https://gist.githubusercontent.com/mgaitan/36d4dbce14ab4dc69f52/raw/9d040d916ebb77bf7ff2618a59e9b6ad95db71e8/area.py\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# otra manera: directamente aplicar el método de trapezoides (teniendo datos y no la funcion)\n",
    "np.trapz(np.abs(y), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimización y ajuste de curvas\n",
    "\n",
    "### encontrar mínimos\n",
    "\n",
    "Supongamos que tenemos una función cualquiera de una o más variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fpol(x):\n",
    "    return x**4 + 5*x**3 + (x-2)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax  = plt.subplots()\n",
    "x = np.linspace(-5, 2, 100)\n",
    "ax.plot(x, fpol(x));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos encontrar un mínimo local con la función `minimize`, que recibe como parámetro la función objetivo y un *valor de estimación inicial* a partir del cual se comienza a \"ajustar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import optimize\n",
    "result = optimize.minimize(fpol, -3, method='BFGS') # http://en.wikipedia.org/wiki/BFGS\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result['x']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`minimize` es una \"función paraguas\" para diferentes algoritmos, que se pueden elegir mediante el parámetro `method` o bien utilizar la función explícita de minimización que lo implementa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimize.minimize(fpol, 0, method='hBFGS')['x']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ojo que hay métodos que son muy sensibles al valor de estimación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimize.minimize(fpol, 0, method='Powell')['x']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio \n",
    "\n",
    "1. Encuentre el mínimo y el máximo de la función \n",
    "\n",
    "$$f(x,y) = xe^{-x^2 - y^2}$$\n",
    "\n",
    "2- Basado en los ejemplos de gráficos de [superficie](http://matplotlib.org/examples/mplot3d/surface3d_demo.html), y [scatter 3d](http://matplotlib.org/examples/mplot3d/scatter3d_demo.html) grafique la superficie para $x, y \\in [(-2, 2),(-2,2)]$ con un punto triangular en los puntos encontrados anteriormente\n",
    "\n",
    "<!-- \n",
    "https://gist.githubusercontent.com/mgaitan/faa930a5874311a6f888/raw/ec7ff8268935ab53095c3067c12210d26c40b406/min_and_max.py\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load https://gist.githubusercontent.com/mgaitan/faa930a5874311a6f888/raw/ec7ff8268935ab53095c3067c12210d26c40b406/min_and_max.py\n",
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from matplotlib import cm\n",
    "\n",
    "x = y = np.linspace(2, -2, 100)\n",
    "xx,yy = np.meshgrid(x, y)\n",
    "\n",
    "f = lambda var: var[0]*np.exp(-var[1]**2 - var[0]**2)\n",
    "\n",
    "z = f([xx,yy])\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches(10,10)\n",
    "ax = fig.gca(projection='3d')\n",
    "ax.plot_surface(xx,yy,z, rstride=1, cstride=1, cmap=cm.coolwarm,\n",
    "        linewidth=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# ----\n",
    "from scipy import optimize\n",
    "minimum = optimize.minimize(f, [-1, 1])\n",
    "maximum = optimize.minimize(lambda x: -f(x), [1, 1])\n",
    "minimum, maximum\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# ----\n",
    "\n",
    "ax.scatter(minimum['x'][0], minimum['x'][1], minimum['fun'], marker='v', s=200)\n",
    "ax.scatter(maximum['x'][0], maximum['x'][1], f(maximum['x']), marker='^', s=200)\n",
    "fig\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Curve fitting\n",
    "\n",
    "\n",
    "Otra tarea frecuente es ajustar parámetros de una función objetivo a partir de un *dataset* de puntos conocidos. \n",
    "\n",
    "Supongamos que tenemos una serie de datos medidos\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = np.array([[ 0.        ,  3.07127661],\n",
    "                   [ 0.08163265,  2.55730445],\n",
    "                   [ 0.16326531,  2.28438915],\n",
    "                   [ 0.24489796,  1.91475822],\n",
    "                   [ 0.32653061,  2.00380351],\n",
    "                   [ 0.40816327,  1.89419135],\n",
    "                   [ 0.48979592,  1.74713349],\n",
    "                   [ 0.57142857,  1.68237822],\n",
    "                   [ 0.65306122,  1.44749977],\n",
    "                   [ 0.73469388,  1.67511522],\n",
    "                   [ 0.81632653,  1.34023054],\n",
    "                   [ 0.89795918,  1.1209472 ],\n",
    "                   [ 0.97959184,  1.41692478],\n",
    "                   [ 1.06122449,  0.88480583],\n",
    "                   [ 1.14285714,  0.9939094 ],\n",
    "                   [ 1.2244898 ,  1.02293629],\n",
    "                   [ 1.30612245,  1.11983417],\n",
    "                   [ 1.3877551 ,  0.77520734],\n",
    "                   [ 1.46938776,  0.88371884],\n",
    "                   [ 1.55102041,  1.24492445],\n",
    "                   [ 1.63265306,  0.8275613 ],\n",
    "                   [ 1.71428571,  0.60846983],\n",
    "                   [ 1.79591837,  0.73019407],\n",
    "                   [ 1.87755102,  0.75139707],\n",
    "                   [ 1.95918367,  0.6496137 ],\n",
    "                   [ 2.04081633,  0.59122461],\n",
    "                   [ 2.12244898,  0.61734269],\n",
    "                   [ 2.20408163,  0.61890166],\n",
    "                   [ 2.28571429,  0.68647436],\n",
    "                   [ 2.36734694,  0.47551378],\n",
    "                   [ 2.44897959,  0.89850013],\n",
    "                   [ 2.53061224,  0.53029377],\n",
    "                   [ 2.6122449 ,  0.74853936],\n",
    "                   [ 2.69387755,  0.371923  ],\n",
    "                   [ 2.7755102 ,  0.43536233],\n",
    "                   [ 2.85714286,  0.40515777],\n",
    "                   [ 2.93877551,  0.52171142],\n",
    "                   [ 3.02040816,  0.53069869],\n",
    "                   [ 3.10204082,  0.71363042],\n",
    "                   [ 3.18367347,  0.54962316],\n",
    "                   [ 3.26530612,  0.7133841 ],\n",
    "                   [ 3.34693878,  0.27204244],\n",
    "                   [ 3.42857143,  0.56572211],\n",
    "                   [ 3.51020408,  0.29310287],\n",
    "                   [ 3.59183673,  0.50044492],\n",
    "                   [ 3.67346939,  0.60938301],\n",
    "                   [ 3.75510204,  0.55696286],\n",
    "                   [ 3.83673469,  0.59409416],\n",
    "                   [ 3.91836735,  0.30335525],\n",
    "                   [ 4.        ,  0.24230362]]\n",
    "                  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y =  dataset[:,0], dataset[:,1]\n",
    "\n",
    "fig  = plt.figure(figsize=(9,6))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "ax.scatter(dataset[:,0], dataset[:,1], marker='^');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos que tiene forma de exponencial decreciente, es decir\n",
    "\n",
    "$$\n",
    "    f(x) = ae^{-bx} + c\n",
    "$$\n",
    "\n",
    "El objetivo es encontrar cuales son los valores de los parámetros `a`, `b` y `c` que mejor ajustan la curva a los puntos dados. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x, a, b, c):   # x es la variable independiente, a b y c los parametros a encontrar\n",
    "    return a*np.exp(-b*x) + c\n",
    "\n",
    "\n",
    "popt, pcov = optimize.curve_fit(func, x, y)\n",
    "popt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por lo tanto la curva que mejor ajusta a nuestros datos es\n",
    "\n",
    "$$f(x) = 2.33e^{-1.18x} + 0.25$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax.plot(x, func(x, *popt), 'r', label='fitted')\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Procesamiento de imágenes\n",
    "\n",
    "Una imágen digital tipo [raster](https://en.wikipedia.org/wiki/Raster_graphics) (matriz de pixeles) puede ser facilmente interpretable como un array multidimensional. Por ejemplo, una imágen de 512x512 pixeles a color puede alamcenarse en una \"matriz\" de 3x512x512 donde cada una las 3 matrices representa una capa de colo RGB (rojo, verde, azul)\n",
    "\n",
    "Para una imágen monocromática, obviamente una sóla matriz nos alcanza. \n",
    "\n",
    "Scipy trae el array de una [imágen clásica](https://en.wikipedia.org/wiki/Lenna) (fragmento de una foto de PlayBoy de 1972) para ejemplos de procesamiento de imágenes, en escala de grises. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.misc import lena\n",
    "image =  lena()\n",
    "image.shape,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt\n",
    "plt.gray()\n",
    "plt.imshow(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos procesar imágenes simplemente aplicando máscaras \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mascara = (image > image.max() * .75)\n",
    "plt.imshow(mascara)   # blanco == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos aplicar la máscara a la imágen original, por ejemplo, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(np.where(mascara, image, 255))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask = np.tril(np.ones(image.shape))  #tril / triu seleccionan triangulos inf y sup\n",
    "plt.imshow(np.where(mask, image, 255))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scipy trae un paquete para manipulación de **imágenes multidimensionales** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from scipy import ndimage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(ndimage.convolve(image, np.ones((12,12))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transformaciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lena = image\n",
    "shifted_lena = ndimage.shift(lena, (50, 50))\n",
    "shifted_lena2 = ndimage.shift(lena, (50, 50), mode='nearest')\n",
    "rotated_lena = ndimage.rotate(lena, 30)\n",
    "cropped_lena = lena[50:-50, 50:-50]\n",
    "zoomed_lena = ndimage.zoom(lena, 5)\n",
    "imgs = (shifted_lena, shifted_lena2, rotated_lena, cropped_lena, zoomed_lena)\n",
    "fig, axes = plt.subplots(1, 5, figsize=(20,100))\n",
    "for ax, img in zip(axes, imgs):\n",
    "    ax.tick_params(left=False, bottom=False, labelleft=False)\n",
    "    ax.imshow(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filtros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "\n",
    "noisy_lena = np.copy(lena).astype(np.float)\n",
    "noisy_lena += lena.std()*0.5*np.random.standard_normal(lena.shape)\n",
    "blurred_lena = ndimage.gaussian_filter(noisy_lena, sigma=3)\n",
    "median_lena = ndimage.median_filter(blurred_lena, size=5)\n",
    "wiener_lena = signal.wiener(blurred_lena, (5,5))\n",
    "imgs = (noisy_lena, blurred_lena, median_lena, wiener_lena)\n",
    "fig, axes = plt.subplots(1, 4, figsize=(20,80))\n",
    "for ax, img in zip(axes, imgs):\n",
    "    ax.tick_params(left=False, bottom=False, labelleft=False)\n",
    "    ax.imshow(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si les interesa esta área deberian ver los paquetes especializados [Scikit-image](http://scikit-image.org/), [Pillow](http://pillow.readthedocs.org) y [OpenCV](http://opencv.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformada de Fourier\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEKCAYAAAAFJbKyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2c4d530b70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "f = 10     # Frequency, in cycles per second, or Hertz\n",
    "f_s = 100  # Sampling rate, or number of measurements per second\n",
    "\n",
    "t = np.linspace(0, 2, 2 * f_s, endpoint=False)\n",
    "x = np.sin(f * 2 * np.pi * t) + np.sin(np.pi * t)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(t, x)\n",
    "ax.set_xlabel('Time [s]')\n",
    "ax.set_ylabel('Signal amplitude');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left ( -5, \\quad 110\\right )$$"
      ],
      "text/plain": [
       "(-5, 110)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2c4d47d2b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy import fftpack\n",
    "\n",
    "X = fftpack.fft(x)\n",
    "freqs = fftpack.fftfreq(len(x)) * f_s\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(freqs, np.abs(X))\n",
    "ax.set_xlabel('Frequency in Hertz [Hz]')\n",
    "ax.set_ylabel('Frequency Domain (Spectrum) Magnitude')\n",
    "ax.set_xlim(-f_s / 2, f_s / 2)\n",
    "ax.set_ylim(-5, 110)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A now, something completely different: SymPy!\n",
    "\n",
    "([intertextualidad :D](https://en.wikipedia.org/wiki/And_Now_for_Something_Completely_Different)) De paso, sabías que el Python se llama así porque el holandés que lo creo es fanático de Monty Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy es una biblioteca Python para matemática simbólica, similar a software como Mathematica o Mathcad. La documentación se encuentra en http://sympy.org/ ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Anaconda (full) ya viene instalado, o se puede instalar via pip o conda con"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "      $ pip install sympy   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿que es la computación simbólica?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comunmente, las computadoras usan una [coma flotante](http://en.wikipedia.org/wiki/Floating_point) para **representar** numeros reales (y complejos) y calcular operaciones matemáticas. Esto implica que la precisión es limitada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.8284271247461903"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.sqrt(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los sistemas de cálculo simbólico (o álgebra computacional, CAS), utilizan una **representación simbólica** (presentada de la manera más simplicifada posible)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2*sqrt(2)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sympy\n",
    "\n",
    "raiz8 = sympy.sqrt(8)\n",
    "raiz8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos, por supuesto, **evaluar** la expresión simbólica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.82842712474619"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raiz8.evalf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.82842712474619009760337744841939615713934375075389614635335947598146495692421407770077506865528314547002769246182459404984967211170147442528824299420"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raiz8.evalf(n=150)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por defecto la evaluación numérica se lleva a cabo con un precisión de 15 decimales.\n",
    "Pero puede ajustarse la precisión al número de decimales que uno desee, enviando el número de decimales como argumento a evalf() o a la función `N()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy utiliza como background la biblioteca [mpmath](http://code.google.com/p/mpmath/) que le permite realizar cálculos con aritmética de **precisión arbitraria**, de forma tal que ciertas constantes especiales, como pi, el número e, oo (infinito), son tratadas como símbolos y pueden ser evaluadas con aritmética de alta precisión:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Salida enriquecida"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para continuar, haremos que el \"output matemático\" se vea más bonito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy\n",
    "from sympy.interactive import printing\n",
    "printing.init_printing(use_latex='mathjax')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esa función inicializa el output en le mejor modo disponible en el entorno. Como los notebooks saben mostrar LaTex, lo hará así, mostrando *outputs* muy bonitos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$2 \\sqrt{2}$$"
      ],
      "text/plain": [
       "2⋅√2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.sqrt(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SymPy como una calculadora"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy tiene tres tipos de datos predefinidos: el real (Real), el racional (Rational) y el entero (Integer).\n",
    "El tipo `Rational` representa a un número racional como un par de números enteros: el numerador y el denominador.\n",
    "Por ejemplo: `Rational(1, 2)` representa la fracción $1/2$, `Rational(5, 3)` a $5/3$, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{1}{2}$$"
      ],
      "text/plain": [
       "1/2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = sympy.Rational(1, 2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1$$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\pi^{2}$$"
      ],
      "text/plain": [
       " 2\n",
       "π "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.pi**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930382$$"
      ],
      "text/plain": [
       "3.1415926535897932384626433832795028841971693993751058209749445923078164062862\n",
       "089986280348253421170679821480865132823066470938446095505822317253594081284811\n",
       "174502841027019385211055596446229489549303820"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.pi.evalf(n=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$5.85987448204884$$"
      ],
      "text/plain": [
       "5.85987448204884"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(sympy.pi+sympy.exp(1)).evalf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También existe una clase para representar al infinito matemático, llamada oo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\mathrm{True}$$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.oo > 99999"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\infty$$"
      ],
      "text/plain": [
       "∞"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.oo + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$0$$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / sympy.oo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "otra manera de ejecutar `evalf` de una expresión es con la función `sympy.N`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641573$$"
      ],
      "text/plain": [
       "1.4142135623730950488016887242096980785696718753769480731766797379907324784621\n",
       "07038850387534327641573"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.N(sympy.sqrt(2), 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicios:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Calcular 1/2 + 1/3 con aritmética racional.\n",
    "2. Calcular $2^e$ con 200 decimales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Símbolos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El alma del Cálculo Simbólico son, naturalmente, las variables simbólicas, que en SymPy son instancias de la clase `Symbol`. Una explicación intuitiva es que, mientras que las variables ordinarias tienen un valor que puede ser un número, una cadena, un valor verdadero / falso, una secuencia, etc. las variables simbólicas juegan el papel de \"contenedores\": no sabemos a priori lo que pueden ser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = sympy.Symbol('x')\n",
    "y = sympy.Symbol('y')\n",
    "n = sympy.Symbol('n', integer=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luego, pueden ser manipuladas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$2 x$$"
      ],
      "text/plain": [
       "2⋅x"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + y + x - y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(x + y\\right)^{2}$$"
      ],
      "text/plain": [
       "       2\n",
       "(x + y) "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x + y)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una manera más compacta de definir variables simbólicas es con la función `symbols`, que permite pasar una cadena con muchas variables a generar separadas por espacios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(a - b\\right)^{2}$$"
      ],
      "text/plain": [
       "       2\n",
       "(a - b) "
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b = sympy.symbols('a b')\n",
    "(a - b)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traducir expresiones a otros lenguajes\n",
    "\n",
    "Podemos aprovechar toda la funcionalidad de \"impresión\" que trae Sympy para traducir cualquier expresión a otros formatos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$$\\frac{1}{x} e^{\\cos^{x}{\\left (x \\right )}} \\sin{\\left (x \\right )}$$\n"
     ]
    }
   ],
   "source": [
    "from sympy import sin, exp, cos\n",
    "\n",
    "formula = sin(x)*exp(cos(x)**x)/x\n",
    "print(sympy.latex(formula, mode='equation', itex=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sólo nos queda copiar y pegar esa expresión en markdown\n",
    "\n",
    "$$\\frac{1}{x} e^{\\cos^{x}{\\left (x \\right )}} \\sin{\\left (x \\right )}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'exp(pow(cos(x), x))*sin(x)/x'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.ccode(formula)   # codigo C ansi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'      exp(cos(x)**x)*sin(x)/x'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.fcode(formula)   # codigo fortran iso"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulación algebráica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy tiene una gran potencia para realizar cálculos en forma algebráica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$x^{2} + 2 x y + y^{2}$$"
      ],
      "text/plain": [
       " 2            2\n",
       "x  + 2⋅x⋅y + y "
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.expand((x+y)**2, deep=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "también se pueden hacer especificaciones adicionales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\Re{x} + \\Re{y} + i \\Im{x} + i \\Im{y}$$"
      ],
      "text/plain": [
       "re(x) + re(y) + ⅈ⋅im(x) + ⅈ⋅im(y)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.expand(x + y, complex= True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A veces es útil darle \"pistas\" al sistema para que sepa por qué \"camino matemático\" andar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\cos{\\left (x + y \\right )}$$"
      ],
      "text/plain": [
       "cos(x + y)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.expand(sympy.cos(x + y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$- \\sin{\\left (x \\right )} \\sin{\\left (y \\right )} + \\cos{\\left (x \\right )} \\cos{\\left (y \\right )}$$"
      ],
      "text/plain": [
       "-sin(x)⋅sin(y) + cos(x)⋅cos(y)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.expand(sympy.cos(x + y), trig=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simplificación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sympy.simplify(x**2 + 2*x*y + y**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La simplificación se realiza de la mejor manera que SymPy encuentra y a veces la respuesta puede no ser lo que uno espera (demasiado trivial o no en la forma que se necesita). Las pistas la estrategia de simplificación que debe utilizar:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* powsimp: simplifica exponentes.\n",
    "* trigsimp: simplifica expresiones trigonométricas\n",
    "* logcombine\n",
    "* randsimp\n",
    "* together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicios:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Calcular la forma expandida de $(x+y)^6.$\n",
    "2. Simplificar la expresión trigonométrica $\\frac{sen(x)}{cos(x)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Límites"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los límites se pueden calcular con mucha facilidad usando SymPy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    limit(f(x), x, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import limit, sin, oo\n",
    "limit(sin(x)/x, x, 0), limit(sin(x)/x, x, oo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diferenciación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede derivar cualquier expresión de Sympy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import diff, tan, exp, cos, sin\n",
    "\n",
    "diff(sin(x), x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff(exp(sin(x**3)**x), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden calcular derivadas de orden superior especificando el orden de derivación como tercer argumento de diff:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff(sin(2*x), x, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff(sin(2*x), x, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expansión en serie de Taylor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy puede expandir funciones en serie de Taylor mediante la función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sympy.series(sympy.cos(x), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicios:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Calcular el límite de $$\\lim_{x \\to 0} sen(x)\\frac{exp(cos(x)^x)}{x}$$\n",
    "2. Calcular las tres primeras derivadas de $$log{ (x^{2} - tan{(x)})}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integración"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy es capaz de calcular integrales definidas e indefinidas para funciones elementales, trascendentes y especiales, mediante la herramienta integrate()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integración de funciones elementales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import integrate, log\n",
    "integrate(6*x**5, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate(sin(x), x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import sinh\n",
    "integrate(2*x + sinh(x), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integración de funciones especiales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate(exp(-x**2)*sympy.erf(x), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es posible calcular integrales definidas. La función es la misma: `integrate(función, (varialble, límite inferior, límite superior))`, sólo que como segundo argumento se utiliza una tupla cuyo primer elemento es la variable de integración, su segundo elemento es el límtie inferior de integración y el último es el límite superior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate(x**3, (x, -1, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate(cos(x), (x, -sympy.pi/2, sympy.pi/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¡Incluso se puden calcular integrales impropias!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate(exp(-x), (x, 0, sympy.oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrate(exp(-x**2), (x, -sympy.oo, sympy.oo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resolución de ecuaciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy es capaz de resolver ecuaciones algebráicas de una y de varias variables. Para eso existe la función `solve(ecuación, variable)`, donde ecuación es una expresión que es igual a cero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, para resolver la ecuación $x^4−1=0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sympy.solve(x**4 - 1, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se pueden resolver sistemas de ecuaciones en varias variables. Ahora el primer argumento de solve es una lista cuyos elementos son las ecuaciones a resolver, y el segundo argumento es otra lista formada por las variables o incógnitas del sistema. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sympy.solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede resolver ecuaciones en las que intervengan funciones trascendentes, pero su capacidad es limitada y, a veces, no encuentra la solución."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sympy.solve(exp(x) + 1, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Factorizacion \n",
    "\n",
    "Es posible factorizar polinomios en términos de factores irreducibles con la función `factor(función)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import factor\n",
    "f = x**4 - 3*x**2 + 1\n",
    "factor(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ecuaciones diferenciales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, g = sympy.symbols('x g')\n",
    "expresion = g(x).diff(x, x) + g(x)\n",
    "expresion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sympy.dsolve(expresion, g(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si uno quiere la ecuación diferencial sea resuelta de un modo en particular, puede incluir \"pistas\" como segundo argumento de dsolve para guiarlo en la resolución:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expresion = sin(x)*cos(g(x)) + cos(x)*sin(g(x))*g(x).diff(x)\n",
    "sympy.dsolve(expresion, g(x), hint='separable')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sympy, numpy y otras yerbas\n",
    "\n",
    "Sympy es capaz de evaluar numéricamente una expresión usando Numpy. Para esto se usa la función `lambdify` que sabe generar una función universal\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "expr = sin(x)/x\n",
    "f = sympy.lambdify(x, expr, \"numpy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.linspace(0.0001, 10, 100)\n",
    "f(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero sympy va más lejos y sabe compilar una expresión, usando lenguajes como Fortran o Cython que son aún más rápidos que usar C. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.utilities.autowrap import ufuncify\n",
    "f2 = ufuncify([x], expr, backend='f2py')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para los incrédulos\n",
    "np.all(f(a) == f2(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit f(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit f2(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# C'est fini\n",
    "\n",
    "Pero hay mucho más en este curso para seguir por tu cuenta\n",
    "\n",
    "- Gráficos más lindos con Seaborn y análisis de datos con Pandas [Clase](/notebooks/Clase%208.ipynb)\n",
    "- Interactivad y contenidos enriquecidos en el notebook [Clase](/notebooks/Clase%207.ipynb)\n",
    "- Integrar Python con código Fortran (puaj!) [Clase]((/notebooks/Clase%205b.ipynb)\n",
    "- Acelerando Python con Cython y Numba [Clase](/notebooks/Clase%206.ipynb)\n",
    "- Cómo instalar otros paquetes y distribuir los tuyos [Clase](/notebooks/Clase%208.ipynb)\n",
    "\n",
    "\n",
    "Además, hay cientos de bibliotecas científicas para temáticas específicas, que en general se basan en Numpy/Scipy\n",
    "\n",
    "- Machine Learning: [Scikit-learn](http://scikit-learn.org/stable/)\n",
    "- Procesamiento de imágenes avanzado: [Scikit-Image](http://scikit-image.org/) y [OpenCV](http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_tutorials.html)\n",
    "- Paralelización/GPU: [Theano](http://deeplearning.net/software/theano/)\n",
    "- Astronomía: [Astropy](http://www.astropy.org/)\n",
    "- Biología molecular: [Biopython](http://biopython.org/)\n",
    "- Química molecular: [Chemlab](http://chemlab.readthedocs.org/)\n",
    "- Y [decenas](https://scikits.appspot.com/scikits), qué digo, [cientos](http://www.scipy.org/topical-software.html), qué digo, [miles](https://pypi.python.org/pypi?%3Aaction=search&term=science&submit=search) paquetes más!\n",
    "\n",
    "\n",
    "## Tareas Importantes\n",
    "\n",
    "- Sumate a la comunidad de Python más copada del mundo\n",
    "\n",
    "<section class=\"list-group\">\n",
    "            <header class=\"list-group-item\">\n",
    "              <h4 class=\"list-group-item-heading\">Suscribite a la lista <a href=\"http://python.org.ar\">Python Argentina</a></h4>\n",
    "            </header>\n",
    "            <article class=\"list-group-item\">\n",
    "              <form id=\"newsletter-form\" class=\"inline-form\" action=\"http://listas.python.org.ar/mailman/subscribe/pyar\" method=\"POST\">\n",
    "                <div class=\"form-group\">\n",
    "                  <input class=\"form-control\" name=\"email\" placeholder=\"Email\">\n",
    "                </div>\n",
    "                <input class=\"btn btn-primary\" type=\"submit\" value=\"Inscribirme a Pyar!\">\n",
    "              </form>\n",
    "            </article>\n",
    "          </section>\n",
    "          \n",
    "- Vení a la conferencia anual! es Gratis!                 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y dame feedback (sincero) sobre el curso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"500\"\n",
       "            src=\"https://docs.google.com/forms/d/1e2zHvV6ae3bQAjLsZuyZ_C5AJ2PGDkdpUD2pBH3mMRE/viewform?embedded=true\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f2c6065bb38>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IFrame(src=\"https://docs.google.com/forms/d/1e2zHvV6ae3bQAjLsZuyZ_C5AJ2PGDkdpUD2pBH3mMRE/viewform?embedded=true\", width=\"100%\", height=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}