{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funciones, Ejemplo: Estimar el número π\n",
    "A continuación escribiremos la primera función. \n",
    "\n",
    "Existen diversos métodos de estimar el número π, entre estos, series de Taylor, la fórmula de Madhava, Euler, Wallis y el algoritmo de John Machin. [Más detalles.](https://julialang.org/blog/2017/03/piday) \n",
    "\n",
    "Los ejemplos presentados se basan en [Julia for Pythonistas](https://colab.research.google.com/github/ageron/julia_notebooks/blob/master/Julia_for_Pythonistas.ipynb)\n",
    "\n",
    "Uno de los sencillos de implementar es usando la sucesión:\n",
    "$π = 4 \\times \\left(1 - \\dfrac{1}{3} + \\dfrac{1}{5} - \\dfrac{1}{7} + \\dfrac{1}{9}-\\dfrac{1}{11}+\\dots\\right)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000000\n",
      "El valor estimado de π ≈ 3.141592663589326\n",
      "El error es 9.999532757376528e-9\n",
      "π\n",
      "Irrational{:π}\n",
      "Irrational{:π}\n"
     ]
    }
   ],
   "source": [
    "function estimate_pi(n)\n",
    "    s = 1.0\n",
    "    println(n)\n",
    "    for i in 1:n\n",
    "        s += (isodd(i) ? -1 : 1) / (2i + 1)\n",
    "    end\n",
    "    4s\n",
    "end\n",
    "\n",
    "# Nótese que _ se usa como separador de miles\n",
    "p = estimate_pi(100_000_000)\n",
    "println(\"El valor estimado de π ≈ $p\")\n",
    "\n",
    "# El valor de pi es una constante bajo el símbolo o carácter unicode π\n",
    "# Es equivalente a pi o \\pi\n",
    "println(\"El error es $(p - π)\")\n",
    "\n",
    "# PI es un número Irracional\n",
    "println(pi)\n",
    "println(typeof(pi))\n",
    "println(typeof(π))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Código Similar en Python\n",
    "\n",
    "```python\n",
    "import math\n",
    " \n",
    "def estimate_pi(n):\n",
    "    s = 1.0\n",
    "    for i in range(1, n + 1):\n",
    "        s += (-1 if i % 2 else 1) / (2 * i + 1)\n",
    "    return 4 * s\n",
    " \n",
    "p = estimate_pi(100_000_000)\n",
    "\n",
    "# f-strings está disponible a partir de la versión 3.6 de Python\n",
    "print(f\"El valor estimado de π ≈ {p}\") \n",
    "print(f\"El error es {p - math.pi}\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diferencias Sutiles\n",
    "\n",
    "|Julia|Python\n",
    "|-----|------\n",
    "|`function` | `def`\n",
    "|`for i in X`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end` | `for i in X:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`\n",
    "|`1:n` | `range(1, n+1)`\n",
    "|`cond ? a : b` | `a if cond else b`\n",
    "|`2i + 1` | `2 * i + 1`\n",
    "|`4s` | `return 4 * s`\n",
    "|`println(a, b)` | `print(a, b, sep=\"\")`\n",
    "|`print(a, b)` | `print(a, b, sep=\"\", end=\"\")`\n",
    "|`\"$p\"` | `f\"{p}\"`\n",
    "|`\"$(p - π)\"` | `f\"{p - math.pi}\"`\n",
    "\n",
    "### Otras consideraciones\n",
    "\n",
    "* La identación en Julia no tiene relevancia sintáctica, esta se recomienda para que el código sea legible. \n",
    "* Los bloques en julia terminan con `end`.\n",
    "* Julia puede ser más conciso en su sintaxis, por ejemplo: 4 * s se puede definir también como 4s.\n",
    "* No es necesario importar muchas de las características matemáticas, por ejemplo, pi o π.\n",
    "* La palabra clave `return` es opcional. Se retorna el último valor de la última expresión (`4s` en el ejemplo).\n",
    "* Julia permite trabajar directamente con simbolos Unicode como `π`. También se puede definir a mediante un nombre de variable (ejemplo, `π == pi`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtener Símbolos Unicode\n",
    "\n",
    "Es posible obtenerlos a partir de su representación en latex. [Tabla de símbolos latex](https://oeis.org/wiki/List_of_LaTeX_mathematical_symbols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "π\n",
      "θ\n",
      "∈\n"
     ]
    }
   ],
   "source": [
    "#Obtener Simbolos Unicode\n",
    "using REPL.REPLCompletions: latex_symbols, emoji_symbols\n",
    "\n",
    "println(latex_symbols[\"\\\\pi\"])\n",
    "println(latex_symbols[\"\\\\theta\"])\n",
    "println(latex_symbols[\"\\\\in\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"😃\""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emoji_symbols[\"\\\\:smiley:\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* También se pueden consultar en el notebook escribiendo el código latex entre dobe signo de $.\n",
    "\n",
    "$$\\hat{y}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor estimado de y es: 73\n"
     ]
    }
   ],
   "source": [
    "# En Julia\n",
    "r = 10\n",
    "𝑦̂ = 23 + 5r\n",
    "println(\"El valor estimado de y es: \", 𝑦̂)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* En Python es similar, las dos diferencias son: \n",
    "1. No podemos usar `5r`, este se define como `5*r`. \n",
    "2. `println` no existe en python, se usa `print`.\n",
    "\n",
    "```python\n",
    "r = 10\n",
    "𝑦̂ = 23 + 5*r\n",
    "print(\"El valor estimado de y es: \", 𝑦̂)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones Genéricas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(x,y)= x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(10, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "miFuncion (generic function with 1 method)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miFuncion(x, z) = 20 + 2x - 3z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miFuncion(5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "g (generic function with 1 method)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Análogo a g(x,y) = x * y\n",
    "\n",
    "function g(x,y) \n",
    "    return x * y\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(10,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejecutar Código Python en Julia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m   Updating\u001b[22m\u001b[39m registry at `C:\\Users\\Fernan\\.julia\\registries\\General`\n",
      "\u001b[32m\u001b[1m  Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1m  Installed\u001b[22m\u001b[39m PyCall ─ v1.92.1\n",
      "\u001b[32m\u001b[1mUpdating\u001b[22m\u001b[39m `C:\\Users\\Fernan\\.julia\\environments\\v1.5\\Project.toml`\n",
      " \u001b[90m [438e738f] \u001b[39m\u001b[92m+ PyCall v1.92.1\u001b[39m\n",
      "\u001b[32m\u001b[1mUpdating\u001b[22m\u001b[39m `C:\\Users\\Fernan\\.julia\\environments\\v1.5\\Manifest.toml`\n",
      " \u001b[90m [438e738f] \u001b[39m\u001b[92m+ PyCall v1.92.1\u001b[39m\n",
      "\u001b[32m\u001b[1m   Building\u001b[22m\u001b[39m PyCall → `C:\\Users\\Fernan\\.julia\\packages\\PyCall\\BcTLp\\deps\\build.log`\n"
     ]
    }
   ],
   "source": [
    "# Importamos el paquete para installar paquetes\n",
    "using Pkg \n",
    "# Instalamos el paquete para llamar codigo Python \n",
    "Pkg.add(\"PyCall\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importamos el módulo \n",
    "using PyCall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"3.8.5 (default, Sep  3 2020, 21:29:08) [MSC v.1916 64 bit (AMD64)]\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Versión de python instalada\n",
    "sys = pyimport(\"sys\")\n",
    "sys.version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El Valor estimado de π es ≈ 3.141592663589326\n",
      "El error is 9.999532757376528e-09\n"
     ]
    }
   ],
   "source": [
    "#Usar codigo Python\n",
    "py\"\"\"\n",
    "import math\n",
    " \n",
    "def estimate_pi(n):\n",
    "    s = 1.0\n",
    "    for i in range(1, n + 1):\n",
    "        s += (-1 if i % 2 else 1) / (2 * i + 1)\n",
    "    return 4 * s\n",
    " \n",
    "p = estimate_pi(100_000_000)\n",
    "print(f\"El Valor estimado de π es ≈ {p}\")\n",
    "print(f\"El error is {p - math.pi}\")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3π es 9.424777990767979\n"
     ]
    }
   ],
   "source": [
    "# Usar un valor calculado de Python\n",
    "valorde = py\"p\"\n",
    "trespi = 3valorde\n",
    "println(\"3π es \", trespi)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Float64,2}:\n",
       " 0.348598  0.0904924  0.484818\n",
       " 0.8055    0.615658   0.605433"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Usar numpy\n",
    "np = pyimport(\"numpy\")\n",
    "a = np.random.rand(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.3485976896130741 0.09049244210949274 0.4848177585126648; 0.8055003764177291 0.6156579814071617 0.605433270653951]\n"
     ]
    }
   ],
   "source": [
    "#Usar valores de Julia en Python\n",
    "exp_a = np.exp(a)\n",
    "\n",
    "py\"\"\"\n",
    "import numpy as np\n",
    "\n",
    "result = np.log($exp_a)\n",
    "\"\"\"\n",
    "\n",
    "println(py\"result\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m   Updating\u001b[22m\u001b[39m registry at `C:\\Users\\Fernan\\.julia\\registries\\General`\n",
      "\u001b[32m\u001b[1m  Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1mNo Changes\u001b[22m\u001b[39m to `C:\\Users\\Fernan\\.julia\\environments\\v1.5\\Project.toml`\n",
      "\u001b[32m\u001b[1mNo Changes\u001b[22m\u001b[39m to `C:\\Users\\Fernan\\.julia\\environments\\v1.5\\Manifest.toml`\n"
     ]
    }
   ],
   "source": [
    "# Instalación de PyPlot\n",
    "using Pkg \n",
    "Pkg.add(\"PyPlot\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "sys:1: UserWarning: Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n"
     ]
    }
   ],
   "source": [
    "# En Julia se puede usar Matplotlib `pyimport(\"matplotlib\")` \n",
    "# pero se recomienda usar PyPlot por razones de rendimiento\n",
    "# PyPlot se basa en matplotlib\n",
    "using PyPlot\n",
    "\n",
    "x = range(-5π, 5π, length=100)\n",
    "plt.plot(x, sin.(x) ./ x) \n",
    "plt.title(\"sin(x) / x\")\n",
    "plt.grid(\"True\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.5.3",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}