como_debuggear.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cómo debuggear código en Julia\n",
    "\n",
    "Los mensajes de error de **Julia** son bastante crípticos y en general no son fáciles de entender. Si has utilizado **Python**, vas a notar una gran diferencia y vas a extrañar lo explícitos que eran los mensajes de error en ese lenguaje. Sin embargo, un par de nociones generales de cómo funciona **Julia** y sobre todo mucha práctica, son útiles para entender qué es lo que está fallando en nuestro código.\n",
    "\n",
    "Para empezar es útil decir que, como con cualquier lenguaje de programación, los errores en **Julia** se pueden clasificar en cuatro categorías:\n",
    "\n",
    "1. Errores de **sintáxis** o de **compilación** : escribí algo mal y el compilador de **Julia** no me entiende. Puede ser por un *eror de ded o*, un signo de puntuación que olvidé o que utilicé un `elseif` sin antes haber llamado `if`. Mi progama no se ejecuta.\n",
    "\n",
    "2. Errores de **ejecución** : mi programa está \"bien\" escrito, se compila y se comienza a ejecutar pero se detiene en algún momento porque se encuentra con una instrucción invalida. El ejemplo típico es una división entre cero, pero **en Julia esto no es un error, el progama regresa el número (especial) `Inf`**. Un ejemplo de un error de ejecución que sí se da en **Julia** es llamar una variable antes de que sea definida.\n",
    "\n",
    "3. Errores **lógicos** : los más difíciles de corregir. Mi programa se ejecuta sin fallar aparentemente, pero el resultado que escupe es completamente ilógico. Ejemplo: `mi_raiz(16) = 109.23` (se supone que `mi_raiz` implementa la raíz cuadrada...).\n",
    "\n",
    "4. Errores de **PyPlot** : bueno, estos no aparecen en todos los lenguaje sino que son particulares de **Julia**. Tmabién es cierto, estrictamente un error de **PyPlot** entra en alguna de las categorías de arriba. Lo que pasa es que **PyPlot** puede ser realmente molesto y va a concentrar buena parte de los errores que uno comete, así que merece una sección propia.\n",
    "\n",
    "Vamos a discutir un par de consejos para saber cómo encontrar y corregir estos errores. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Inf"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 0\n",
    "10/a #OJO: en Julia dividir entre cero no escupe un error!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(Inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Errores de sintáxis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "syntax: incomplete: \"function\" at In[7]:1 requires end\nwhile loading In[7], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "syntax: incomplete: \"function\" at In[7]:1 requires end\nwhile loading In[7], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "function mi_raiz(y)\n",
    "    a = sin(y)\n",
    "    a = 2a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quizás es un ejemplo burdo, es evidente que lo que falta es un `end` y además esto es lo que dice el mensaje de error. Pero el mensaje dice más cosas que pueden ser interesantes: el error es de sintáxis, hay algo que está incompleto, y lo que falló fue la ejecución de la celda `In[7]`, en particular en la línea `1`. Esto último no es tan evidente, uno podría esperar que el error fuera en la última línea de la celda, pero en la línea `1` fue donde quise definir la función que que quedó incompleta.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "syntax: unexpected end\nwhile loading In[5], in expression starting on line 3",
     "output_type": "error",
     "traceback": [
      "syntax: unexpected end\nwhile loading In[5], in expression starting on line 3",
      ""
     ]
    }
   ],
   "source": [
    "function mi_raiz(y)\n",
    "    a = sin(\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De nuevo, el mensaje dice que el error es de sintáxis y que la instrucción `end` de la función es inesperado. Este mensaje sin embargo, tiene una complicación comparado con el ejemplo anterior: no hace referencia a la línea `2` que es donde claramente está el problema. \n",
    "\n",
    "Siempre que no encuentre un error en la línea de la que se queja **Julia**, es útil revisar lo que escribí justo antes. Al hacerlo aquí encuentro que la instrucción de `end` no se esperaba porque tengo un paréntesis abierto. **Julia** espera encontrar el paréntesis que cierra antes de `end`.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "syntax: incomplete: invalid string syntax\nwhile loading In[6], in expression starting on line 3",
     "output_type": "error",
     "traceback": [
      "syntax: incomplete: invalid string syntax\nwhile loading In[6], in expression starting on line 3",
      ""
     ]
    }
   ],
   "source": [
    "xs = [0:0.1:10]\n",
    "\n",
    "for x in xs\n",
    "    println(x, \"x)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El mensaje dice que el error es de sintáxis, que hay algo incompleto y que el problema es con una cadena. Si sé que es con una cadena, voy a buscar directamente el problema cerca de donde estoy usando cadenas. Nótese que el mensaje dice que el problema está cerca de la línea `3`, pero mi celda ya tiene suficiente código para que empiece a ser molesto contar a mano las líneas. En el modo de edición del notebook (celda seleccionada debe de estar en gris), puedo apretar `l` (házlo) y aparece el número de las líneas a la izquierda.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "syntax: incomplete: premature end of input\nwhile loading In[8], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "syntax: incomplete: premature end of input\nwhile loading In[8], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "sin(mi_funcion(x,mi_raiz(length(y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un error más difícil de encontrar: hay algo incompleto pero de entrada no salta a la vista qué es lo que es. \n",
    "\n",
    "Cuando compongo funciones siempre tengo que cuidar que todas las parentesis, corchetes, etc, estén cerrados. Para ésto aprovecho que al editar la celda y poner el cursor del lado derecho de un paréntesis o corchete, él y su pareja se resaltan en verde. Así puede encontrar el paréntesis que no cerré.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Errores de ejecución"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mi_funcion (generic function with 1 method)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function mi_funcion(x,a)\n",
    "    if a > 0\n",
    "        z = 10\n",
    "    end\n",
    "    \n",
    "    x*a*z\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La definición de arriba no escupe ningún error, sus sintáxis está bien. Pero si le doy un argumento negativo, obtengo un error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "z not defined\nwhile loading In[15], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "z not defined\nwhile loading In[15], in expression starting on line 1",
      "",
      " in mi_funcion at In[14]:6"
     ]
    }
   ],
   "source": [
    "mi_funcion(10,-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El mensaje de error hace referencia a dos lugares: \n",
    "1. A la celda que acabo de correr `In[15]`, línea `1`.\n",
    "2. A una celda anterior `In[14]`, línea `6`, dónde según el mensaje algo tiene que ver `mi_funcion`.\n",
    "\n",
    "El mensaje es extraño porque en lo que acabo de correr no hay ninguna z. Reviso en orden las celdas a las que el mensaje hace referencia, empezando por la última que se utilizó y subiendo hasta la primera. \n",
    "\n",
    "En `In[15]`, línea `1`, no parece haber ningún error. El problema debe ser en la otra celda. Ahí sí hay una z, y me doy cuenta que la instrucción `z = 10` sólo se ejecuta si `a > 0`. Ahí está el problema, cuando `a < 0`, la función intenta regreasar `x*a*z` pero no sabe cuál es el valor de `z`.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "`^` has no method matching ^(::Function, ::Array{Float64,1})\nwhile loading In[20], in expression starting on line 3",
     "output_type": "error",
     "traceback": [
      "`^` has no method matching ^(::Function, ::Array{Float64,1})\nwhile loading In[20], in expression starting on line 3",
      ""
     ]
    }
   ],
   "source": [
    "xs = linspace(0,2pi,10)\n",
    "\n",
    "ys = sin^2(xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un mensaje mucho más extraño. No tengo mucha idea de qué es lo que dice, algo de un método, y sé que el problema parece estar en la línea `3`. En este momento recuerdo que **Julia** se maneja con *métodos* y según lo que el mensaje dice problema podría ser que la función `^` (exponente) no tiene un método para lo que le estoy pidiendo.  \n",
    "\n",
    "####Unas palabras sobre los métodos:\n",
    "\n",
    "Supongamos que `a` y `b` son variables. Yo estoy acostumbrado a escribir \n",
    "\n",
    "`a + b`\n",
    "\n",
    "pero en **Julia** los operadores, aún los más sencillos como `+`, son funciones, así que la sintáxis normal `mi_funcion(los,argumentos)` también sirve:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 10\n",
    "b = 12\n",
    "\n",
    "+(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De hecho esta es la manera \"fundamental\" de usar el operador, y con ésto explico lo que veo en el mensaje de error: no existe un método `^(cosa1, cosa2)` (donde `cosa1` es del tipo `Function` y `cosa2` el del tipo `Array{Float64,1}`).\n",
    "\n",
    "Puedo intentar otra cosa. Tal vez a esta altura ya se me ocurrió que `sin^2(xs)` es la notación en matemáticas, pero que a **Julia** puede no gustarle que eleve al cuadrado entre la función (`sin`) y el argumento de la función (`xs`). Así que intento algo más \"computacional\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "`*` has no method matching *(::Array{Float64,1}, ::Array{Float64,1})\nwhile loading In[18], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "`*` has no method matching *(::Array{Float64,1}, ::Array{Float64,1})\nwhile loading In[18], in expression starting on line 1",
      "",
      " in power_by_squaring at intfuncs.jl:56",
      " in ^ at intfuncs.jl:86"
     ]
    }
   ],
   "source": [
    "ys = sin(xs)^2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¡Otro error! Bueno, pero este es diferente, y ya entendí un poco el mensaje de los métodos: en este caso, **Julia** no tiene un método para multiplicar (con la sintáxis  `*(a,b)`) dos arreglos. Claro, ¡esto tiene sentido! ¿A poco en matemáticas puedo escribir $\\vec{v} \\,^2$?\n",
    "\n",
    "Conclusión, lo que estoy intentando hacer es inválido y lo tengo que hacer de otro modo, por ejemplo con una comprensión de arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Array{Any,1}:\n",
       " 0.0        \n",
       " 0.413176   \n",
       " 0.969846   \n",
       " 0.75       \n",
       " 0.116978   \n",
       " 0.116978   \n",
       " 0.75       \n",
       " 0.969846   \n",
       " 0.413176   \n",
       " 5.99904e-32"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ys = [sin(x)^2 for x in xs]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "[] cannot grow. Instead, initialize the array with \"T[]\", where T is the desired element type.\nwhile loading In[23], in expression starting on line 6",
     "output_type": "error",
     "traceback": [
      "[] cannot grow. Instead, initialize the array with \"T[]\", where T is the desired element type.\nwhile loading In[23], in expression starting on line 6",
      "",
      " in push! at array.jl:457",
      " in anonymous at no file:7"
     ]
    }
   ],
   "source": [
    "aproxima(x,n) = x*n\n",
    "\n",
    "aproximaciones = []\n",
    "x = 10\n",
    "\n",
    "for n in 1:10\n",
    "    push!(aproximaciones, aproxima(x,n))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un error de lo más común para los que venimos de **Python**. Queremos usar `push!` para llenar una lista vacía, pero **Julia** necesita saber de qué tipo son los objetos que quiero guardar en la lista para hacerlo lo más eficientemente posible. Las listas vacías no las declaro sólo como `[]`, necesito decir qué tipo de elementos van a contener cuando las llene. utilizo por ejemplo, `Int[]`, o `Float64[]`.\n",
    "\n",
    "---\n",
    "\n",
    "Por cierto, hablando de llenar listas..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "InexactError()\nwhile loading In[27], in expression starting on line 4",
     "output_type": "error",
     "traceback": [
      "InexactError()\nwhile loading In[27], in expression starting on line 4",
      "",
      " in push! at array.jl:460"
     ]
    }
   ],
   "source": [
    "l = Int[]\n",
    "\n",
    "push!(l,2.0)\n",
    "push!(l,4.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un mensaje completamente oscuro, quién sabe qué es un `InexactError`. Lo único que sé es que el problema está en la línea `4`. ¿Sí? O bueno, tal vez en la línea de arriba, ya vimos que a veces el error está arriba de la línea a la que se refiere **Julia**. Mejor vamos a hacerlo por partes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{Int64,1}:\n",
       " 2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = Int[]\n",
    "\n",
    "push!(l,2.0)\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, el primer `push!` funciona. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "InexactError()\nwhile loading In[29], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "InexactError()\nwhile loading In[29], in expression starting on line 1",
      "",
      " in push! at array.jl:460"
     ]
    }
   ],
   "source": [
    "push!(l,4.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El segundo es el que está fallando. Ok... ¿Qué puede ser? Pienso mucho, reviso mi código y me doy cuenta `l` era originalmente una lista que iba a contener enteros, y que yo estoy tratando de meterle flotantes. Pero meterle el flotante `2.0` no produjo un error, y `4.5` sí, ¿cómo puede ser esto posible?\n",
    "\n",
    "Lo que hace **Julia** es que como dije que la lista iba a contener enteros, trata de convertir los argumentos de `push!` a tipo entero. `2.0` es \"casi\" un entero, sólo me deshago del punto y me quedo con `2`, pero ¿`4.5`? ¿Lo redondeo hacia 4 o hacia 5? **Julia** no va a tomar esa decisión arbitraria por nosotros, y nos escupe este error.\n",
    "\n",
    "Por cierto, puedo revisar la documentación de la función `convert`, que se está llamando a escondidas dentro de `push!`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "convert(Int,2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "InexactError()\nwhile loading In[32], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "InexactError()\nwhile loading In[32], in expression starting on line 1",
      "",
      " in convert at int.jl:299"
     ]
    }
   ],
   "source": [
    "convert(Int,4.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##3. Errores lógicos\n",
    "\n",
    "Como podrás imaginar, estos errores son distintos en cada caso concreto, así que no hay un método general para corregirlos. Sin embargo, hay una serie de \"trucos\" para tratar de ubicar un error de este tipo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "condicion_proba (generic function with 1 method)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function condicion_proba(p, num_iters)\n",
    "    # Genera varios números aleatorios y cuenta cuantos son menores que p ∈ [0,1]\n",
    "    \n",
    "    numeros  = rand(num_iters) # Esto genera num_iters números\n",
    "    # Defino un contador que no contiene nada importante en un principio\n",
    "    contador = rand()\n",
    "    \n",
    "    for num in numeros\n",
    "        # Icializo el contador, al principio vale cero\n",
    "        contador = 0\n",
    "        if num < p\n",
    "            contador += 1\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    contador\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función se definió sin errores de sintáxis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 0.5\n",
    "num_iters = 10\n",
    "\n",
    "condicion_proba(p, num_iters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condicion_proba(p, num_iters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay algo raro, estoy haciendo básicamente \"volados\" y de diez que hice, ninguno cayó en el intervalo $[0, \\frac{1}{2}]$. Yo esperaría algo como del orden de $5$, pero tal vez me tocó una fluctuación. ¿Y si llamo varias veces a la función?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "1\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "for i in 1:5\n",
    "    println(condicion_proba(p, num_iters))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definitivamente hay algo incorrecto, no es una fluctuación. En un llamado a la función, que hace diez iteraciones, a lo mucho se cuenta un número que satiface la condición `num < p`, y peor aún un par de veces no se satisface nunca. \n",
    "\n",
    "Voy a agregar `println`, o aún mejor, el macro `@show` (que da el nombre de la variable y su valor), en algunos lugares estratégicos de mi definición."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "condicion_proba (generic function with 1 method)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function condicion_proba(p, num_iters)\n",
    "    # Genera varios números aleatorios y cuenta cuantos son menores que p ∈ [0,1]\n",
    "    \n",
    "    numeros  = rand(num_iters) # Esto genera num_iters números\n",
    "    @show numeros\n",
    "    # Defino un contador que no contiene nada importante en un principio\n",
    "    contador = rand()\n",
    "    @show contador\n",
    "    \n",
    "    for num in numeros\n",
    "        # Icializo el contador, al principio vale cero\n",
    "        contador = 0\n",
    "        if num < p\n",
    "            contador += 1\n",
    "            @show contador\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    contador\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numeros => [0.9984232116077258,0.9688789040881209,0.7452930986662594,0.4108716281618454,0.04008953082680344]\n",
      "contador => 0.197904275755715\n",
      "contador => 1\n",
      "contador => 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 0.5\n",
    "num_iters = 5\n",
    "\n",
    "condicion_proba(p, num_iters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veo que la lista `numeros` contiene (como debe de ser), $5$ números aleatorios y puedo contar \"a mano\" que los que son menores que $p = 0.5$ son $2$ (los últimos). Puedo ver que cuando inicializo `contador` no contiene nada interesante, pero después aparece dos veces con el valor $1$, que es el que finalmente se regresa. Aquí tiene que estar el problema.\n",
    "\n",
    "Pensándolo un poco más, el `@show` que puse sólo se ejecuta cuando agarro de la lista un número que sí satisface `num < p`, así que estoy cachando contador dos veces, después de que se le suma uno. Ésto significa que las dos veces que lo caché, tenía originalmente el valor cero. ¡Ahí está el problema! Al emepezar la codición `if`, `contador` ¡siempre es igual a cero! \n",
    "\n",
    "Reviso mi código y encuentro el problema: la instrucción `contador = 0` se ejecuta en cada iteración del bucle. Esta línea no debería de estar dentro del `for`, sino antes de él."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function condicion_proba(p, num_iters)\n",
    "    # Genera varios números aleatorios y cuenta cuantos son menores que p ∈ [0,1]\n",
    "    \n",
    "    numeros  = rand(num_iters) # Esto genera num_iters números\n",
    "    # Icializo el contador, al principio vale cero\n",
    "    contador = 0\n",
    "    \n",
    "    for num in numeros\n",
    "        if num < p\n",
    "            contador += 1\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    contador\n",
    "end\n",
    "\n",
    "p = 0.5\n",
    "num_iters = 10\n",
    "\n",
    "condicion_proba(p, num_iters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente ejemplo no es un error, pero se puede convertir en uno cuando utilizamos el código que sigue, creyendo que hacemos otra cosa: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 19\n",
       "  2\n",
       " -2"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Los datos originale\n",
    "a = [1:3]\n",
    "\n",
    "# Guardo una copia de los datos\n",
    "b = a\n",
    "\n",
    "# Y luego modifico los datos originales\n",
    "a[1] = 19\n",
    "a[3] = -2\n",
    "\n",
    "# Qué sucedió con la copia?\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¡La copia cambió, a pesar de que sólo modificamos a `a`! **1Cuidado!** Lo que sucede es que la línea `b = a` no está duplicando lo que `a` tiene guardado, más bien dice \"haz que el símbolo `b` apunte al lugar donde está guardado `a`\". Cuando `a`cambia, `b` sigue apuntando al mismo lugar. \n",
    "\n",
    "Suena completamente ilógico, pero uno de las principales motivaciones en el diseño de **Julia** es que sea lo más rápido posible, y que pueda competir con `C` o `Fortran`. Para que así sea, hay una buena razón para que funcione de esta manera. Hacer que `b` \"apunte\" a la memoria donde está guardado `a` es mucho más rápido que copiar `a` a un nuevo lugar en la memoria y guardarlo por duplicado. Imagina que `a` tuviera cientos de miles o millones de elementos...\n",
    "\n",
    "Puedo darle la vuelta a este comportamiento, usando la función `copy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Los datos originale\n",
    "a = [1:3]\n",
    "\n",
    "# Guardo una copia de los datos\n",
    "b = copy(a)\n",
    "\n",
    "# Y luego modifico los datos originales\n",
    "a[1] = 19\n",
    "a[3] = -2\n",
    "\n",
    "# Qué sucedió con la copia?\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##4. Errores de PyPlot\n",
    "\n",
    "Hay toneladas de errores relacionados con `PyPlot`... A continuación unos pocos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Loading help data...\n"
     ]
    }
   ],
   "source": [
    "using PyPlot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Datos\n",
    "xs = [1:10]\n",
    "\n",
    "# Inicializo una lista\n",
    "ys = [1]\n",
    "\n",
    "# Y la lleno haciéndolo algo a los datos originales\n",
    "for x in xs\n",
    "    push!(ys, x^2)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "PyError (:PyObject_Call) <type 'exceptions.ValueError'>\nValueError(u'x and y must have same first dimension',)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 3099, in plot\n    ret = ax.plot(*args, **kwargs)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_axes.py\", line 1373, in plot\n    for line in self._get_lines(*args, **kwargs):\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 304, in _grab_next_args\n    for seg in self._plot_args(remaining, kwargs):\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 282, in _plot_args\n    x, y = self._xy_from_xy(x, y)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 223, in _xy_from_xy\n    raise ValueError(\"x and y must have same first dimension\")\n\nwhile loading In[66], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "PyError (:PyObject_Call) <type 'exceptions.ValueError'>\nValueError(u'x and y must have same first dimension',)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 3099, in plot\n    ret = ax.plot(*args, **kwargs)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_axes.py\", line 1373, in plot\n    for line in self._get_lines(*args, **kwargs):\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 304, in _grab_next_args\n    for seg in self._plot_args(remaining, kwargs):\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 282, in _plot_args\n    x, y = self._xy_from_xy(x, y)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 223, in _xy_from_xy\n    raise ValueError(\"x and y must have same first dimension\")\n\nwhile loading In[66], in expression starting on line 1",
      "",
      " in getindex at /Users/rodrigo/.julia/v0.3/PyCall/src/PyCall.jl:255",
      " in pysequence_query at /Users/rodrigo/.julia/v0.3/PyCall/src/conversions.jl:778",
      " in pytype_query at /Users/rodrigo/.julia/v0.3/PyCall/src/conversions.jl:794",
      " in convert at /Users/rodrigo/.julia/v0.3/PyCall/src/conversions.jl:844",
      " in pycall at /Users/rodrigo/.julia/v0.3/PyCall/src/PyCall.jl:416",
      " in fn at /Users/rodrigo/.julia/v0.3/PyCall/src/conversions.jl:188",
      " in close_queued_figs at /Users/rodrigo/.julia/v0.3/PyPlot/src/PyPlot.jl:296"
     ]
    }
   ],
   "source": [
    "plot(xs,ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obtenemos un mensaje de error enorme, con muchas líneas incomprensible. Sin embargo, hay una línea interesante, justo arriba de `while loading In[66]...`:\n",
    "\n",
    "`raise ValueError(\"x and y must have same first dimension\")`.\n",
    "\n",
    "Poniendo un poco más de atención este mensaje aparece de hecho (casi idéntico) en la segunda línea del error: `ValueError(u'x and y must have same first dimension',)`.\n",
    "\n",
    "Cuando manejamos `PyPlot` y obtenemos un error, las líneas que en general me van a decir algo son esas dos, la segunda y la que está justo antes de `while loading...`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso, una vez que encontré el único pedazo de información útil en el gran mensaje de error, es bastante claro cuál es el problema: `xs` y `ys` no tienen el mismo número de elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,11)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(xs) , length(ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "PyError (:PyObject_Call) <type 'exceptions.ValueError'>\nValueError(u'third arg must be a format string',)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 3099, in plot\n    ret = ax.plot(*args, **kwargs)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_axes.py\", line 1373, in plot\n    for line in self._get_lines(*args, **kwargs):\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 304, in _grab_next_args\n    for seg in self._plot_args(remaining, kwargs):\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 266, in _plot_args\n    raise ValueError('third arg must be a format string')\n\nwhile loading In[72], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "PyError (:PyObject_Call) <type 'exceptions.ValueError'>\nValueError(u'third arg must be a format string',)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 3099, in plot\n    ret = ax.plot(*args, **kwargs)\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_axes.py\", line 1373, in plot\n    for line in self._get_lines(*args, **kwargs):\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 304, in _grab_next_args\n    for seg in self._plot_args(remaining, kwargs):\n  File \"/Applications/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.py\", line 266, in _plot_args\n    raise ValueError('third arg must be a format string')\n\nwhile loading In[72], in expression starting on line 1",
      "",
      " in getindex at /Users/rodrigo/.julia/v0.3/PyCall/src/PyCall.jl:255",
      " in pysequence_query at /Users/rodrigo/.julia/v0.3/PyCall/src/conversions.jl:778",
      " in pytype_query at /Users/rodrigo/.julia/v0.3/PyCall/src/conversions.jl:794",
      " in convert at /Users/rodrigo/.julia/v0.3/PyCall/src/conversions.jl:844",
      " in pycall at /Users/rodrigo/.julia/v0.3/PyCall/src/PyCall.jl:416",
      " in fn at /Users/rodrigo/.julia/v0.3/PyCall/src/conversions.jl:188",
      " in close_queued_figs at /Users/rodrigo/.julia/v0.3/PyPlot/src/PyPlot.jl:296"
     ]
    }
   ],
   "source": [
    "plot(rand(10), rand(10), 'r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando lo que ya aprendí, me fijo en la segunda línea y encuentro:\n",
    "\n",
    "`'third arg must be a format string'`\n",
    "\n",
    "Hay un problema con el tercer argumento, y si nos queda duda de cuál es el tercer argumento, hay un problema con una cadena.\n",
    "\n",
    "Ya habíamos visto en clase que `'r'` es un caracter (`Char`), y `\"r\"` una cadena (`ASCIIString`). Resulta que lo que yo tengo que pasar como argumento es una cadena, con comillas dobles. Esto es confuso porque la documentación `?plot` habla de cosas con comillas simples, pero esa es la documentación de **matplotlib** en **Python** donde no hay diferencia entre los dos tipos de comillas.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "True not defined\nwhile loading In[76], in expression starting on line 2",
     "output_type": "error",
     "traceback": [
      "True not defined\nwhile loading In[76], in expression starting on line 2",
      ""
     ]
    }
   ],
   "source": [
    "muestra = rand(10_000)\n",
    "plt.hist(muestra, normed = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Revisando la documentación de la función histograma `plt.hist`, si quiero normalizar la gráfica uso `normed = True`. De nuevo, esto es en **Python**, en **Julia** la variable booleana es `true`con minúscula.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.3.11-pre",
   "language": "julia",
   "name": "julia-0.3"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}