3-IntrodJulia-4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metaprogramming\n",
    "\n",
    "Julia nos permite manipular objetos en Julia que representan código en Julia. De esta manesa, podemos producir código de una manera automática.\n",
    "\n",
    "Consideremos los polinomios de Wilkinson\n",
    "\n",
    "$$ p_{20} (x) := (x-1)\\cdot(x-2)\\dotsm (x-20) = \\prod_{i=1}^{20} (x-i) $$ \n",
    "\n",
    "Supongamos que queremos definir este polinomio en Julia. La forma más simple sería explícitamente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "p_5(x) = (x-1)*(x-2)*(x-3)*(x-4)*(x-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero se sale de control muy rápidamente esta forma de hacer las cosas, para el momento en que lleguemos a $p_{30}$ estaremos deseando que exista una forma más fácil de hacerlo. El punto es que, la hay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "function wilkinson(n, x)\n",
    "    result = x - 1\n",
    "    \n",
    "    for i in 2:n\n",
    "        result *= (x - i)\n",
    "    end\n",
    "    \n",
    "    result\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar una función anónima, para tener la función objeto $p_n$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "wilkinson(n) = x -> wilkinson(n, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo las funciones anónimas son lentas. Nosotros desearíamos que hubiera alguna forma de hacer un loop que escriba el código de nuestra función"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Expresiones\n",
    "\n",
    "En otros lenguajes de programación, se manipula al código como cadenas. Julia aborda el problema desde otro punto. Consideremos la cadena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s = \"(x-1) * (x-2)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para convertir esto a un objeto usamos **parse**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ex = parse(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "typeof(ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*ex* es un objeto de tipo Expr. Puede pensarse como la representación de un \"árbol de sintaxis abstracta\" representando la estructura interna de la expresión. Podemos ver esto de dos maneras, utilizando `dump`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dump(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "que muestra todo en detalle, o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Meta.show_sexpr(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "que nos muestra una versión compacta.\n",
    "\n",
    "vemos además que los objetos `Expr` tienen un formato jerárquico que representa el código. Dado que son simplemente objetos de Julia, podemos utilizar Julia para manipularlos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interpolación de código\n",
    "\n",
    "En nuestro caso no necesitamos meternos con la estructura interna del código, sino construir el código a partir de bits preexistentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ex = :(x-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ex = :(($ex)*(x - 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí, del mismo modo que en la interpolación de cadenas, hemos insertado el valor actual de ex dentro de la expresión"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ex = :(($ex)*(x - 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora podemos hacer nuestro loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = 10\n",
    "ex = :(x-1)\n",
    "for i in 2:n\n",
    "    ex = :( ($ex) * (x-i) )\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero lo que nosotros queremos es el valor, no el código"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = 10\n",
    "ex = :(x-1)\n",
    "for i in 2:n\n",
    "    ex = :( ($ex) * (x-$i) )\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que necesitamos ahora es dar nombre a la función"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nombre = symbol(string(\"W_\", n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así que el código se ve más o menos así"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "código = :( $nombre(x) = $ex )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora deseamos evaluar eso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "eval(código)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparemos las dos funciones evaluándolas en una malla dada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f1(range) = [W_10(x) for x in range]\n",
    "f2(range) = [wilkinson(10, x) for x in range]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "range = -10:0.000001:10\n",
    "@time f1(range);\n",
    "@time f2(range);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Macros\n",
    "\n",
    "Hasta ahora hemos estado usando ciertos objetos con un @ que los precede, uno estaría tentado a decir que son funciones; sin embargo en el sentido estricto de la palabra no son funciones sino **macros**. Que son funciones cuyos argumentos son código, y que transforman una expresión de código en otra. Esta nueva expresión es entonces evaluada como si el nuevo código hubiera sido tecleado directamente.\n",
    "\n",
    "Para ver con más claridad esto definamos una macro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "macro simple(expr)\n",
    "    @show expr\n",
    "    0  # for the moment\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "@simple x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "vemos que el código de Julia que sigue a la llamada de la macro es pasado a la macro como si ya le hubiéramos hecho *parse*.\n",
    "\n",
    "Supongan que ahora redefinimos la macro como"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "macro simple(expr)\n",
    "    @show expr\n",
    "    expr  # returns expr\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entonces tenemos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "@simple x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que pasa es que la macro regresa :(x+y), y esto es evaluado utilizando `eval`. El resultado es que Julia intenta calcular el valor de la expresión x+y, pero la variable x no está definida. Definamos $y$ y $z$, pero no $x$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y = 3; z = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "@simple x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "?esc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Un último ejemplo\n",
    "\n",
    "Supongamos que queremos evaluar el polinomio \n",
    "\n",
    "$$ p(x) = a_n x^n + a_{n-1}x^{n-1} + \\dotsm + a_1x^1 + a_0  $$\n",
    "\n",
    "una forma eficiente de hacer esto es con el [método de Honer](https://en.wikipedia.org/wiki/Horner%27s_method), de la siguiente forma\n",
    "\n",
    "$$ p(x) = a_0 + x(a_1 + x(a_{n-2} + \\dotsm + x(a_{n-1} + xa_n))) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# copiado de base/math.jl\n",
    "macro horner(x, p...)\n",
    "    ex = esc(p[end])\n",
    "    for i = length(p)-1:-1:1\n",
    "        ex = :( $(esc(p[i])) + t * $ex )\n",
    "    end\n",
    "    Expr(:block, :(t = $(esc(x))), ex)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para evaluar el polinomio $p(x) = 2+3x+4x^2$ en $x=3$, hacemos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 3\n",
    "@horner(x, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio\n",
    "\n",
    "Implemente el factorial utilizando metaprogramming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graficando, salvando y leyendo de un archivo\n",
    "\n",
    "Pasando a otras cosas, creemos un arreglo de números aleatorios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "using PyPlot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = [1:1:100]\n",
    "arreglo1 = rand(100)\n",
    "arreglo2 = rand(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plot(x,arreglo1, \"rp\", label = \"Arreglo 1\")\n",
    "plot(x,arreglo2, \"g*\", label = \"Arreglo 2\")\n",
    "legend(loc=\"upper right\",fancybox=\"true\")\n",
    "axis([0,100,0,1])\n",
    "title(\"Gráfica sencilla\")\n",
    "ylabel(\"Número generado\", size = 16)\n",
    "xlabel(L\"x\", size = 18)\n",
    "grid(\"on\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig = figure(\"pyplot_subplot_mixed\",figsize=(14,7))\n",
    "subplot(131)\n",
    "grid(\"on\")\n",
    "bar(x,arreglo1)\n",
    "axis([0,100,0,1])\n",
    "title(\"Barras\")\n",
    "subplot(132)\n",
    "title(\"Barras horizontales\")\n",
    "barh(x,arreglo2)\n",
    "axis([0,1,0,100])\n",
    "ax = subplot(133)\n",
    "plot(x,arreglo1)\n",
    "plot(x,arreglo2)\n",
    "title(\"Dos a la vez\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para grabar estos arreglos en un archivo hacemos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "writedlm(\"arreglo1.txt\", arreglo1)\n",
    "writedlm(\"arreglo2.txt\", arreglo2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para leer utilizamos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "arregloLeido1 = readdlm(\"arreglo1_prueba.txt\")\n",
    "arregloLeido2 = readdlm(\"arreglo2_prueba.txt\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para que vean que no hay trampa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plot(x,arregloLeido1, \"g^\", label = \"Arreglo 1\")\n",
    "plot(x,arregloLeido2, \"bh\", label = \"Arreglo 2\")\n",
    "legend(loc=\"upper right\",fancybox=\"true\")\n",
    "axis([0,100,0,1])\n",
    "title(\"Arreglos leídos\")\n",
    "ylabel(\"Número generado\", size = 16)\n",
    "xlabel(L\"x\", size = 18)\n",
    "grid(\"on\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Referencias\n",
    "\n",
    "1. [Introducing Julia](https://en.wikibooks.org/wiki/Introducing_Julia/Metaprogramming)\n",
    "2. [Documentación de Julia](http://julia.readthedocs.org/en/latest/manual/metaprogramming/)}\n",
    "3. [D. Sanders - Invitation to julia](https://github.com/dpsanders/invitation_to_julia/blob/master/3.%20Metaprogramming.ipynb)\n",
    "4. [D. Sanders - ScyPy 2014](https://github.com/dpsanders/scipy_2014_julia/blob/master/Metaprogramming.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.3.10-pre",
   "language": "julia",
   "name": "julia-0.3"
  },
  "language_info": {
   "name": "julia",
   "version": "0.3.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}