Fundamentos.ipynb

{
    "cells": [
    {
 	    "cell_type": "markdown", 
 	    "source": [ 
 		"# Fundamentos" 
 	    ], 
 	    "metadata": {} 
	},
        {
            "cell_type": "markdown",
            "source": [
                "## ¿Por qué Julia?\n",
                "### El problema\n",
                "El proceso de producir resultados en ciencia e ingeniería depende de múltiples etapas para las cuales, históricamente, se han requerido especialistas dedicados y apenas comunicándose sus resultados parciales para hacer funcionar un sistema.\n",
                "\n",
                "Esto, en un mundo de creciente multidisciplina e interdisciplina, se vuelve menos conveniente, pues comunicar conceptos y justificiaciones complejas entre diversos especialistas se ha hecho crucial para progresar con eficiencia una investigación y desarrollo de tecnología.\n",
                "\n",
                "### Una solución elegante\n",
                "Julia es un lenguaje de programación que es capaz de minimizar la brecha entre el concepto y el código, teniendo de ejemplo:\n",
                "```julia\n",
                "A = [∫ϕ₁² ∫ϕ₁₂;\n",
                "     ∫ϕ₁₂ ∫ϕ₂²]\n",
                "```\n",
                "para crear una matriz cuyas entradas son integrales de algunas funciones, muy común en métodos de elemento finito o métodos numéricos generales para mecánica cuántica. Este código corre perfectamente al definir los símbolos anteriores:\n",
                "```julia\n",
                "ϕ₁(x) = 1-x; ϕ₂(x) = x; \n",
                "ϕ₁²(x) = ϕ₁(x)^2; ϕ₂²(x) = ϕ₂(x)^2; ϕ₁₂(x) = ϕ₁(x)ϕ₂(x)\n",
                "∫(f) = quadgk(f,0,1)\n",
                "```\n",
                "Dejando muy en claro lo que hace el código para cualquiera que conozca los símbolos, incluso con poca experiencia con el lenguaje.\n",
                "\n",
                "Esta énfasis en legibilidad y eficiencia de escritura de código es algo que ya existe en lenguajes como Python, pero en menor grado de especialización para las ciencias y definitivamente con un costo de eficiencia de cómputo...\n",
                "\n",
                "Es por eso que rubros de la academia y tecnología persisten en utilizar lenguajes altamente eficientes como Fortran, C/C++, o incluso Octave. **Julia puede ser ambos: Legible y eficiente.** Emparejando muy de cerca velocidades de cómputo de C y Fortran (como visto [aquí](https://julialang.org/benchmarks/)), y a veces superando, sin comprometer la legibilidad o la interactividad \n",
                "\n",
                "### ¿Cómo lo logra Julia?\n",
                "Julia, a diferencia de Python, R y Octave, **no** es un lenguaje interpretado, si no compilado. No obstante, sigue siendo interactivo como estos anteriores, lo que nos permite recibir los resultados de nuestro código a tiempo real ¿Cómo lo hace?\n",
                "\n",
                "Julia utiliza un compilador [JIT](https://en.wikipedia.org/wiki/Just-in-time_compilation) (Just-In-Time) implementado en [LLVM](https://en.wikipedia.org/wiki/LLVM), que quiere decir que compila el código hasta el momento en que es necesario compilarlo y así proveer velocidades de lenguajes compilador como C/C++ pero interactividad y dinamismo de Python.\n",
                "\n",
                "Además, Julia es un lenguaje **opcionalmente tipado**, lo que quiere decir que, al igual que Python, es posible escribir código sin restringir el tipo de una variable o salida de función; incluso cambiándo su valor de tipo dinámicamente. Pero, tenemos también la opción de restringir los tipos como en C/C++ para ayudarle al compilador JIT a optimizar mejor nuestro código.\n",
                "\n",
                "Ésta y más técnicas son las utilizadas para escribir código máximalmente eficiente, pero aún tan fácil de leer y aprender como lo anteriormente mostrado.\n",
                "\n",
                "### Paradigmas y diseño del lenguaje Julia\n",
                "El diseño de Julia se puede intentar resumir en: ser de código abierto, multiparadigma y de propósito general con énfasis en cómputo científico y paralelo, conteniendo principalmente aspectos de programación funcional, imperativa y orientada a objetos; sin ser purista en ninguno. \n",
                "\n",
                "Pero no se puede hacer justicia diciendo solamente eso, pues contiene muchos aspectos únicos (si vienen de otros lenguajes de programación, ver [esta lista](https://docs.julialang.org/en/v1/manual/noteworthy-differences/)). Éstos los iremos visitando a lo largo del curso... comencemos con lo básico primero\n",
                "\n",
                "## Operaciones fundamentales y tipos primitivos\n",
                "### Aritmética básica\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "Tenemos aritmética usual (`+`, `*`, `-`, `/`, `^`). A continuación ilustramo la sintaxis básica:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "5+2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 268
        },
        {
            "cell_type": "markdown",
            "source": [
                "El resultado de sumar un float con un entero es un float. Veremos luego más sobre este proceso de **promoción de tipos**.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "5.0+2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 269
        },
        {
            "cell_type": "markdown",
            "source": [
                "La multiplicación se realiza con el operador `*`, como es usual con otros lenguajes de programación\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "5*3\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 270
        },
        {
            "cell_type": "markdown",
            "source": [
                "Pero notemos que, a diferencia de en otros lenguajes como Python, la exponenciación se utiliza con `^`.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "2^3\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 271
        },
        {
            "cell_type": "markdown",
            "source": [
                "Tenemos división con el operador `/`, que retorna un flotante si el resultado de la división lo amerita.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "3/2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 272
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos realizar también la división «al revés». Muy común en Octave/Matlab y es una sintaxis que se trasladará para el caso de matrices.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "2\\3\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 273
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Infinitos, complejos y racionales\n",
                "\n",
                "Además de la aritmética usual, tenemos por defecto infinitos, números complejos y números racionales. Estos pueden ser resultado de las operaciones anteriores en una forma esperada por nuestros conceptos matemáticos usuales.\n",
                "\n",
                "Por ejemplo, tenemos infinitos de ambos signos:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "1/0\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 274
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "-5/0\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 275
        },
        {
            "cell_type": "markdown",
            "source": [
                "Números complejos utilizando la palabra clave `im` (que puede escribirse con concatenación simple al número o con el operador explícito de multiplicación `*`).\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(5+2im)*(2-4im)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 276
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notemos que el infinito complejo se expresa como un infinito en su parte real y otro infinito en la parte imaginaria. \n",
                "\n",
                "Esta decisión de diseño provee un buen ejemplo de la complejidad de crear un lenguaje de programación consistente con nuestros conceptos matemáticos, como se puede ver a mayor profundidad en [esta](https://github.com/JuliaLang/julia/issues/9790) y [esta](https://github.com/JuliaLang/julia/issues/5234) discusión.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(5+2im)/0\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 277
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los números racionales son un tipo en sí mismo construidos con su numerador y denominador separados por `//`\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "3//4\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 278
        },
        {
            "cell_type": "markdown",
            "source": [
                "Las fracciones siempre se reducen a su forma más simple\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "6//8\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 279
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "3//4 == 6//8\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 280
        },
        {
            "cell_type": "markdown",
            "source": [
                "Los siguientes son equivalentes respectivamente al «infinito racional» y el «cero racional»\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "1//0, 0//2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 281
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esto se ilustra mejor a continuación:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "0//2 == 0//3 == 0, 3//0 == Inf\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 282
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Aritmética en tipos especiales\n",
                "\n",
                "Estos tienen aritméticas propias que reflejan lo que entendemos conceptualmente de ellos. Por ejemplo, la suma y productos escalares de infinitos retornan infinitos, mientras que la división de infinitos y resta de ellos, como sabemos del cálculo básico, no son operaciones bien definidas. Para entender un poco más sobre los infinits y su aritmética puedn visitar [aquí](https://en.wikipedia.org/wiki/Hilbert%27s_paradox_of_the_Grand_Hotel)\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "3*Inf+2, Inf/Inf, Inf - Inf\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 283
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los racionales pueden sumarse y restarse, obteniendo un resultado ya en forma simplificada, aunque en caso de que el resultado sea un número entero `a`, se expresa en la forma `a//1` para preservar su tipo racional hasta que se necesite cambiar a entero de nuevo (si aun caso).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "1//2 + 3//2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 284
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "3*1//3\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 285
        },
        {
            "cell_type": "markdown",
            "source": [
                "Los números complejos tienen también su aritmética usual como mostrado arriba. Aquí tenemos un ejemplo con la exponenciación con base y potencia compleja:\n",
                "\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(im)^(im)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 286
        },
        {
            "cell_type": "markdown",
            "source": [
                "### Tipos primitivos de datos\n",
                "Como se vio anteriormente, los resultados de las operaciones están ligados al **tipo de dato** que utilizamos. \n",
                "\n",
                "Con tipo de dato nos referimos a los distintos objetos que Julia nos permite guardar en memoria y manipular (mediante funciones, las cuales estudiaremos luego). Algunos tipos de datos primitivos son los siguientes:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(5), typeof(100_000_000_000_000_000_000_000), typeof(5.0), typeof('c'), typeof(\"Hola\"), typeof(true)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 287
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "donde se a utilizado la **función** `typeof` para imprimir en pantalla el *tipo de dato* de cada objeto. Las funciones serán discutidas luego.\n",
                "\n",
                "Una explicación breve de éstos tipos es:\n",
                "* `Int64`: Número entero representado en la computadora utilizando $64$ bits, es decir, una cadena de $0$s y $1$s de tamaño $64$. \n",
                "  \n",
                "   De ésta, el primero de ellos se utiliza para guardar el signo del entero, por lo que quedan $63$ libres e implicando que el rango de valores de un `Int64` es entre -$2^{63}$ y $2^{63}-1$ (donde el $-1$ aparece por que los positivos incluyen al cero). Se puede leer más [aquí](https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/).\n",
                "\n",
                "\n",
                "* `Int128`: Similar al `Int64`, ahora teniendo un rango posible entre -$2^{127}$ y $2^{127}-1$\n",
                "\n",
                "\n",
                "* `Float64`: Una representación decimal finita que intenta aproximar un número real utilizando 64 bits de información. \n",
                "\n",
                "  Esto es logrado por lo que se conoce como **sistema numérico de punto flotante**. La forma en que ésta es representada en memoria es más complicada que los `Int`, pero se puede leer más [aquí](https://en.wikipedia.org/wiki/Floating-point_arithmetic)\n",
                "\n",
                "\n",
                "* `Char`: Un caracter de texto, representado mediante codificación [Unicode](https://en.wikipedia.org/wiki/Unicode). Ésto quiere decir que Julia permite desde caractéres de nuestro alfabeto usual, caractéres con tildes y diéresis, así como japoneses, coreanos y chinos, subíndices, simbología matemática, alfabeto griego, emoticones y más.\n",
                "\n",
                "\n",
                "* `String`: Una cadena de más de un caracter.\n",
                "\n",
                "\n",
                "* `Bool`: Un Booleano. Solamente puede tener dos valores: Verdadero o falso. Se utiliza para representar condiciones y controlar flujos del código.\n",
                "\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Números enteros\n",
                "\n",
                "Como comentado anteriormentre, Julia tiene diferentes tipos de enteros dependiendo del espacio en memoria que se utiliza para guardarlos/representarlos. Estos pueden ser generados utilizando el nombre del tipo como una función:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(Int32(5)), typeof(Int16(5)), typeof(Int8(5)) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 288
        },
        {
            "cell_type": "markdown",
            "source": [
                "La **representación binaria** o de **bits** de cualquier tipo primitivo en Julia (booleano, flotante, entero, caracter) se puede obtener mediante la función `bitstring`). Esto nos permite hacernos una mejor idea de cómo se guardan en memoria estos objetos.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "bitstring(Int8(5)), bitstring(Int16(5))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 289
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos utilizar la función `methods` para enlistar todos los tipos para los cuales la función `bitstring` está definida:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "methods(bitstring)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 290
        },
        {
            "cell_type": "markdown",
            "source": [
                "El hecho que cada tipo de dato sea representado por una cadena **finita** de $0$s y $1$s implica que tendremos límites en los valores de nuestros datos. En particular, podemos ver los máximos de cada tipo de entero:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "## Estos valores son 2^(n-1) - 1, donde n es el número de bits.\n",
                "typemax(Int8), typemax(Int16), typemax(Int32), typemax(Int64)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 291
        },
        {
            "cell_type": "markdown",
            "source": [
                "y los mínimos...\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "## Estos valores son -2^(n-1), donde n es el número de bits.\n",
                "typemin(Int8), typemin(Int16), typemin(Int32), typemin(Int64)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 292
        },
        {
            "cell_type": "markdown",
            "source": [
                "Estos valores extremos son importantes puesto a que pueden causar lo que conocemos como **integer overflow** o **integer underflow** ('desbordamiento' de enteros, aunque el término en español no es comúnmente utilizado).\n",
                "\n",
                "Ésto es: Que el valor resultante de operaciones de enteros excede el máximo o mínimo de un tipo de entero y retornamos valores en el extremo opuesto:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typemax(Int32) + Int32(1) ## <- Integer overflow\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 293
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typemin(Int32) - Int32(1) ## <- Integer underflow\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 294
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notemos que esto no pasará en el siguiente ejemplo. ¿Por qué?:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "## el número 1 aquí, escrito sin especificar su tipo, tendrá tantos bits \n",
                "## como el \"tamaño de palabra\" utilizado en el procesador. Más de esto luego.\n",
                "typemax(Int32) + 1  \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 295
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(typemax(Int32) + 1 )\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 296
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esto sucede debido al **sistema de promoción de tipos** en julia. Para los enteros, siempre consideramos a los de mayor número de bits como 'superiores' en el sentido siguiente:\n",
                "\n",
                "Sean \n",
                "- `x` un entero de n bits\n",
                "- `y` un entero de m bits\n",
                "- n > m\n",
                "\n",
                "entonces: `x + y` será un entero de n bits tras *promover* `y` hacia su versión de n bits (lo cual siempre es posible).\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "La razón por la que `typemax(Int32) + 1` es de tipo `Int64` en computadoras de 64 bits es porque los enteros sin especificar su tipo (`1` en este caso) tienen por defecto tamaño 64. En general, la longitud de bits de enteros y de floats será del tamaño de lo que se conoce como [tamaño de palabra](https://en.wikipedia.org/wiki/Word_(computer_architecture)) en el procesador.\n",
                "\n",
                "De no estar seguro del tamaño de palabra que utiliza su procesador, Julia tiene una variable interna a la cual consultar para verificarlo rápidamente. En el caso donde se ejecutó por primera vez este notebook, tenemos un word size de 64 bits:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Sys.WORD_SIZE\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 297
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Números de punto flotante\n",
                "\n",
                "Los números de punto flotante son un sistema numérico que pretende aproximar lo mejor posible a los números reales utilizando una representación decimal, particularmente densa para números pequeños, los cuales suelen ser más útiles en garantizar la precisión de cálculos numéricos. De nuevo, más información [aquí](https://en.wikipedia.org/wiki/Floating-point_arithmetic).\n",
                "\n",
                "A diferencia de los enteros, los tipo flotantes no tienen límite superior ni inferior... si no que son representados infinitos especiales para cada cantidad de bits, que abarcan esa cantidad de memoria pero todos respetan propiedades esperadas como 'ser mayor que cualquier otro flotante' o la aritmética de infinitos vista anteriormente.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typemax(Float32)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 298
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typemin(Float32)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 299
        },
        {
            "cell_type": "markdown",
            "source": [
                "Además como visto anteriormennte, tenemos un número flotante especial (una versión para cada  número de bits), `NaN` (['Not a Number'](https://en.wikipedia.org/wiki/NaN)), que sirve para representar datos que no podríann ser representados de otra manera o que señalizan un error sin necesitar levantar un error que paralice el flujo de un programa.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(NaN), typeof(Float32(NaN))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 300
        },
        {
            "cell_type": "markdown",
            "source": [
                "Con aritmética que 'absorbe' cualquier otro número a ser `NaN` y además representar expresiones matemáticas no definidas.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "NaN + NaN, NaN*NaN, NaN/NaN, 5 + NaN, 0/0, Inf/Inf,  Inf - Inf\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 301
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos ver la representación de bits de dos flotantes:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "bitstring(Float16(5.0)), bitstring(Float32(5.0)), bitstring(Int16(5))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 302
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notemos que la cadena binaria del número 5 en su representación flotante cambia de la representación de entero en la adición de una cadena larga de $0$s a la derecha, la cual se utiliza para presentar su parte decimal. Ejemplo:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "bitstring(Float16(5.1))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 303
        },
        {
            "cell_type": "markdown",
            "source": [
                "No obstante, como la cadena binaria sigue siendo finita, esperamos que exista *algún* tipo de límite. Si este límite **no es** un máximo ni un mínimo ¿dónde está?\n",
                "\n",
                "Resulta que la precisión de los números flotantes está determinada por el número de **cifras significativas** que el número de bits nos permite guardar. Por ejemplo, el decimal $5.1$ puede guardarse sin mucha memoria, pero una representación de 100 cifras de $\\pi$ no es posible con un `Float16`, pero su precisión incrementa entre más bits tengamos.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Float16(pi)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 304
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Float64(pi)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 305
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esto, para números especiales como $\\pi$ no es un problema en Julia, ya que son representados mediante otro tipo de datos llamado `Irrational`, especial para representar de manera arbitrariamente precisa los números irracionales:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "pi\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 306
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(pi)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 307
        },
        {
            "cell_type": "markdown",
            "source": [
                "Si queremos extraer una precisión particular de un número como $\\pi$ o garantizar que cierto número de bits serán utilizados en nuestros cálculos, basta con utilizarlo en una operación o extraer el valor directamente utilizando el tipo flotante más general `BigFloat`\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "3pi\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 308
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "pi^2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 309
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "BigFloat(pi, precision = 256)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 310
        },
        {
            "cell_type": "markdown",
            "source": [
                "Aquí el argumento `precision` es el número de bits que utilizaremos en la representación de dicho número. Entre más sean, más cifras significativas podremos representar; esto puede ser crucial en caso de necesitar realizar cálculos sumamente precisos, aunque viene con el costo de mayor memoria por número.\n",
                "\n",
                "Para tener una mejor medida de cuántos bits necesitamos para obtener 'x' precisión, presentamos brevemente el concepto de ['épsilon de máquina'](https://en.wikipedia.org/wiki/Machine_epsilon): El máximo error relativo que puede ocurrir por medio del procedimiendo de redondeo. En cierto sentido, ésto es una cota de la precisión para una cantidad selecta de bits.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "eps(Float64), eps(Float32)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 311
        },
        {
            "cell_type": "markdown",
            "source": [
                "El epsilon de máquina depende de en que rango esté el número utilizado, no solo su tipo:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "eps(1.0), eps(10000.0) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 312
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esto es porque los números cercanos a cero yacen más densos mientras que los más grandes están más esparcidos. Por ello, normalizar cantidades a números pequeños y adimensionales en cálculos numéricos es importante para minimizar el error de precisión de máquina.\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "#### Caracteres\n",
                "\n",
                "Los `Char` son un tipo de dato primitivo que representa cualquier caracter definido en cualquier codificación bajo el [estándar Unicode](https://en.wikipedia.org/wiki/Unicode) (ej. UTF-8, UTF-16, GB18030). Esto incluyen caracteres alfanuméricos a los que estamos acostumbrados:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof('r'), typeof('5')\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 313
        },
        {
            "cell_type": "markdown",
            "source": [
                "O también characteres especiales de otros alfabetos o incluso emojis:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof('尊') ## <- Respeto/honor\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 314
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                " typeof('🦈')\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 315
        },
        {
            "cell_type": "markdown",
            "source": [
                "Muy cercanamente asociados a los `Char` tenemos a los `Strings` (cadenas de caracteres), un **tipo compuesto** que se genera a partir de `Chars`. La diferencia de sintaxis crucial es el uso de doble comillas \\\" en lugar de comillas simples, ' .\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(\"¡Hola!\"), typeof(\"안녕하세요\"), typeof(\"Z\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 316
        },
        {
            "cell_type": "markdown",
            "source": [
                "#### Booleanos\n",
                "\n",
                "Los booleanos (`Bool`) son el último tipo de dato primitivo del que platicaremos. Éstos se estudiarán más a fondo cuando se estudien las estructuras de control y los condicionales. Presentamos aquí algunas propiedades:\n",
                "\n",
                "* Tenemos dos valores de tipo booleano: `true` y `false`\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(true), typeof(false)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 317
        },
        {
            "cell_type": "markdown",
            "source": [
                " * Numericamente, son equivalentes `1` y a `0` respectivamente.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "true == 1, false == 0, true + true, true * false\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 318
        },
        {
            "cell_type": "markdown",
            "source": [
                "* `false` puede ser utilizado como un `0` 'más fuerte' que, por ejemplo, puede volver `0` incluso a `NaN`.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "false * NaN\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 319
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esto es para tener consistencia en operaciones booleanas a las cuales les interesa más que los resultados de ellas sean valores 'convertibles' a booleanos de nuevo, por lo que `NaN` no tendría mucha utilidad aquí.\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Tipos compuestos\n",
                "\n",
                "Observemos los siguientes tipos de datos:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(5+2im), typeof(5.0+2im), typeof(Inf), typeof(Inf + Inf*im), typeof(5//2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 320
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(Int32(5)//Int32(2))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 321
        },
        {
            "cell_type": "markdown",
            "source": [
                "Los números complejos y los números racionales son **tipos compuestos**: Su estructura es construida a partir de otros más simples.\n",
                "\n",
                "Esta es una idea poderosa en Julia que nos permite construir estructuras de datos arreglos de números (vectores, matrices, etc.)\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof([2, 3, 5])  ## Esto es un \"vector\"/arreglo unidimensional\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 322
        },
        {
            "cell_type": "markdown",
            "source": [
                "El anterior es un tipo compuesto llamado **arreglo**, en general, o en particular por su forma: **vector**. Su tipo se identifica con `Int64`, ya que todos sus sub-unidades (sus entradas) son de tipo `Int64`. \n",
                "\n",
                "Este tipo global que se identifica para los tipos compuestos ayuda al compilador a asignar memoria eficientemente al objeto completo. Por ejemplo, en este caso, cada entrada (con un total de $3$), al ser `Int64`, solamente ocupa 64 bits para almacenarse, y no tenemos el riesgo de necesitar más que eso. Por ello, el compilador puede buscar una sección de memoria con $3*64$ bits contiguos que posteriormente facilite y acelere el acceso entre elementos para operarlos, por ejemplo, al querer sumarlos, sacar su promedio, hacer una búsqueda, etc.\n",
                "\n",
                "Esta es una desventaja general de los objetos por defecto de lenguajes como la lista de Python, la cual equivale a un arreglo pero de cualquier tipo, por lo que su almacenamento en memoria no puede ser optimizado.\n",
                "\n",
                "No obstante, de necesitarlo, Julia igualmente puede tener un arreglo que pueda contener cualquier tipo, al tener como tipo global `Any`.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof([3, \"Hola\", 5.0])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 323
        },
        {
            "cell_type": "markdown",
            "source": [
                "Los anteriores son un análogo de lista para Python, pero igualmente tenemos objetos diseñados para comportarse como matrices, al estilo de lenguajes como Octave/Matlab:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof([2 3 5])  ## Esto es una \"matriz\"/arreglo bidimensional\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 324
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof([2.0 3.0 5.0])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 325
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof([2 3 5;\n",
                "        6 8 2])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 326
        },
        {
            "cell_type": "markdown",
            "source": [
                "El siguiente es un arreglo de tipo `Float64`, pues los `Int64` presentes fueron promovidos a `Float64.`\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof([2.0 3 5]) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 327
        },
        {
            "cell_type": "markdown",
            "source": [
                "¿Qué decide cuál tipo de número se promueve a cuál otro? Este es una pregunta importante al considerar tipos compuestos, especialmente cuando luego construyamos nuestros propios tipos compuestos.\n",
                "\n",
                "La respuesta corta e intuitiva en nuestro caso particular es: Un entero siempre puede convertirse a un flotante (agregando un `.0`, ej. `5` -> `5.0`) pero un flotante puede fallar fácilmente en poder convertirse en un entero si tiene parte decimal (`5.5` no podría convertirse en `5` ni en `6` sin perder información).\n",
                "\n",
                "Una respuesta más elaborada toma en cuenta dos cosas. Primero, la siguiente imagen:\n",
                "\n",
                "![Jerarquía](https://upload.wikimedia.org/wikipedia/commons/thumb/d/d9/Julia-number-type-hierarchy.svg/1920px-Julia-number-type-hierarchy.svg.png)\n",
                "\n",
                "Esta es una **jerarquía de tipos** en donde podemos observar que tipos que yacen en los extremos de sus 'ramas' (como Int32, Float64, Bool, etc.) son los que hemos llamado **tipos primitivos**, pero estos son particularizaciones de tipos conocidos como **tipos abstracto**. \n",
                "\n",
                "En resumen, tenemos una jerarquía de **supertipos** abstractos (ej. `Integer` es un supertipo de todos los `Int64`, `Int16`, ...) y **subtipos** (ej. `Int8` es subtipo de `Integer` pero a su vez `Integer` es a su vez subtipo de `Real`) donde solo los subtipos que no tienen más subtipos son llamados **primitivos**. \n",
                "\n",
                "Para que un tipo, `x`, pueda ser convertido en otro tipo `y`, necesitamos que `x` pueda ser llevado hacia un **supertipo** en común, digamos `z`, y luego re-presentarlo en un elemento de tipo `y` de manera única y sin perder información que le distinga su valor. \n",
                "\n",
                "Esto lleva al segundo punto: La función `promote`, la cual está encargada de realizar este procedimiento para cada tipo compuesto que lo requiera por uniformidad.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "promote(5, 1.4, 6)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 328
        },
        {
            "cell_type": "markdown",
            "source": [
                "Es posible en cualquier momento obtener la jerarquía de supertipos de un tipo en particular:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "supertypes(Int64) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 329
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "supertypes(Float64)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 330
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "supertypes(Char)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 331
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos observar que, para todos los tipos, el tipo `Any` será un supertipo maximal. La motivación y beneficio de definir esta jerarquía de tipos será evidente una vez que estudiemos funciones y construyamos nuestros propios tipos.\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "#### Vectores, matrices y arreglos\n",
                "\n",
                "Regresando a la plática de arreglos, exploremos su aritmética, la cual se comporta como esperaríamos del álgebra lineal.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[1 2 4] + [3 2 1]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 332
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos pensar informalmente en los arreglos 'sin comas' como 'vectores fila' mientras que los vectores 'con comas' como 'vectores columna'. Esto es útil recordar cuando queremos hacer productos de matriz con vector:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[2 3; 6 8] * [1, 1] \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 333
        },
        {
            "cell_type": "markdown",
            "source": [
                "También podemos exponenciar matrices:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[3 4; 6 8]^2 ## ¿Pueden encontrar más matrices con esta propiedad? :) \n",
                "\t\t\t ## pista: Cayley-Hamilton  \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 334
        },
        {
            "cell_type": "markdown",
            "source": [
                "Pero ¿Cómo es que el mismo operador (``+``, ``*``, ``/``,etc.) sabe qué hacer dependiendo del tipo de dato?\n",
                "\n",
                "### Operaciones por tipo\n",
                "\n",
                "En julia todos los operadores son realmente funciones. Podemos encontrar sus definiciones en diversos archivos de lo que llamamos la **librería estándar** o **base** de Julia anteponiendo `@which` (conocido como un **Macros**, más de ellos luego) a la operación realizada.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@which 3.0*4.0\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 335
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@which (3+0im)*(4+0im)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 336
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@which Float32(4.0)*Float32(2.0)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 337
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@which 3*4\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 338
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@which [2 3; 6 8] * [1, 1]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 339
        },
        {
            "cell_type": "markdown",
            "source": [
                "Incluso, tenemos operaciones con cadenas de caracteres:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@which \"Hola\" * \" \" * \"mundo\"\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 340
        },
        {
            "cell_type": "markdown",
            "source": [
                "La operación de multiplicación de cadenas de texto funciona igual a la suma `+` en python. Julia eligió utilizar multiplicación debido a que no es una operación conmutativa, y tiene más sentido tener una notación consistente con la de un [monoide](https://en.wikipedia.org/wiki/Monoid):\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "\"Hola\" * \" \" * \"mundo\", \"Hola\"^3\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 341
        },
        {
            "cell_type": "markdown",
            "source": [
                "cuyo elemento identidad es la cadena vacía: `\\\"\\\"` \n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "\"hola\" * \"\"\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 342
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para dejar más en claro que los operadores son funciones, podemos notar que podemos operar de la siguiente manera, muy similar a los lenguajes basado en Lisp\n",
                "\n",
                "Tengan muy en mente esta noción, pues resultará claro luego que es uno de los pilares de diseño más importantes de Julia.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "*(5,3,2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 343
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "+(3,5,2,1,5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 344
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "^(3, 2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 345
        },
        {
            "cell_type": "markdown",
            "source": [
                "Para poder indagar mejor en cómo están definidos estos operadores, y cualquier parte de código de Julia, se pueden utilizar **macros** como `@edit` o `@doc`:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@doc 4*5\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 346
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Variables y funciones\n",
                "\n",
                "### Sintaxis básica\n",
                "Como mencionado anteriormente, Julia prioritiza y enfoca mucho la legibilidad del código. Esto es en gran parte posible gracias a lo expresivos que pueden ser los nombres y definiciones de variables y funciones.\n",
                "\n",
                "Por ejemplo, nuestras variables podrían ser muy explícitas de contar el número de conejitos y lobos en una zona en particular.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "🐰 = 4; 🐺 = 2;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 347
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esta además es una buena oportunidad para ver cómo Pluto puede utilizarse como un editor reactivo...\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "🐰 + 1 \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 348
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "2*🐺\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 349
        },
        {
            "cell_type": "markdown",
            "source": [
                "Por supuesto, también podemos tener variables con nombres más usuales\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "x = 5\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 350
        },
        {
            "cell_type": "markdown",
            "source": [
                "Aquí en pluto, debido a la reactividad del cuaderno, no podemos definir más de una sola variable por celda a menos que, como anteriormente, utilicemos punto y coma (`;`) o esto que llamamos un bloque `begin`$-$`end`, que compone varias **expresiones** en una sola **expresión compuesta**. Hablaremos más de ello luego.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tx₀ = 5 \n",
                "\tx₁ = 2 \n",
                "\tx₂ = 1\n",
                "\tx₀ + x₁ \n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 351
        },
        {
            "cell_type": "markdown",
            "source": [
                "La notación para crear funciones es bastante flexible. La siguiente es una forma estándar en muchos lenguajes de programación.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function sumaUno(x)\n",
                "\treturn(x+1)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 352
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "sumaUno(10)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 353
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esta misma función puede, de manera más sucinta, expresarse como lo haríamos en papel\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "f(x) = x+1\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 354
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "f(10)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 355
        },
        {
            "cell_type": "markdown",
            "source": [
                "También podemos colocar múltiples argumentos:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "w(x,y,z) = x+y+z\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 356
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "w(1,3,-2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 357
        },
        {
            "cell_type": "markdown",
            "source": [
                "Una tercera forma de hacerlo es:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "OtraForma(x) = begin\n",
                "\tx+1\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 358
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esta es una combinación entre la claridad en el nombre de la variable del segundo método y la capacidad de tener un bloque grande de instrucciones entre el `begin` y `end`.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "x->x+1\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 359
        },
        {
            "cell_type": "markdown",
            "source": [
                "Ésta última forma de definir funciones se engloba como un tipo de función llamado **funciones anónimas**. Éste nombre debido a que estas funciones no **necesitan** un nombre para ser evaluadas:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(x->x+1)(5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 360
        },
        {
            "cell_type": "markdown",
            "source": [
                "Aunque pueden igual guardarse dentro de una variable para darles nombre si uno lo desea...\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "función_desanonimizada = x->x+1\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 361
        },
        {
            "cell_type": "markdown",
            "source": [
                "En el caso de funciones anónimas de múltiples argumentos, se escribe así:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(x,y,z) -> x+y+z\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 362
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Mejorando la legibilidad de las funciones\n",
                "\n",
                "A diferencia de en otros lenguajes, para definir funciones dependientes de una variable `x`, Julia permite anteponer objetos numéricos y implicar multiplicación, similar a cómo escribiríamos en un papel:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "g(x) = 2x^2 + 3x + 1\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 363
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "g(4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 364
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Esto es solo un ejemplo de las interconexión natural que obtenemos entre las notaciones estándar y sintaxis de Julia, veamos más a continuación: \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "f₁(x) = x + 2; f₂(x) = x + 1;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 365
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(f₁∘f₂)(2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 366
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Lo anterior evalúa primero $f₂(2) = 2 + 1 = 3$, y ese resultado lo evalúa en la función $f₁$. Es decir, el resultado será $f₁(3) = 3 + 2 = 5$. Un ejemplo de **composición de funciones**.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "3 ÷ 2, 123551 ÷ 19723\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 367
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El símbolo de división literal, ÷ (ingresado mediante la escritura de `\\div`, como en $\\LaTeX$, seguida por `<TAB>`), realiza una división entera. Es decir, devuelve la parte entera del resultado de dividir dos números.\n",
                "\n",
                "Todos los símbolos permitidos por Julia se pueden encontrar en [esta lista](https://docs.julialang.org/en/v1/manual/unicode-input/)\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "5 ≈ 10, 5 ≈ 5.1, 5 ≈ 5 - eps(Float64)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 368
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Tenemos un símbolo de aproximación (`\\approx + <TAB>`) para comparar cantidades flotantes y considerarlas equivalentes si difieren en alguna *pequeña* cantidad respecto a lo que la precisión de punto flotante considera pequeño (dependiendo de qué tipo de flotante se utiliza, qué tan cercano estamos de 0, etc.)\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "√16, √(5^2 - 3^2), 4 ≠ 5\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 369
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Y por supuesto podemos utilizar el símbolo de raíz cuadrada (`\\sqrt + <TAB>`) para ejecutar dicha operación y el símbolo de no igualdad (`\\ne + <TAB>`) para verificar objetos diferentes.\n",
                "\n",
                "Las posibilidades son ilimitadas, pues podemos siempre definir cualquier operación como algún símbolo de la lista unicode mostrada anteriormente.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "⨳(a,b) = (3a+b^2) ## ¡Los paréntesis son importantes para que sea `infix`! \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 370
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "4 ⨳ 5 ## 3(4) + 5^2 = 12 + 25 = 37 \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 371
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "10 ⨳ -1\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 372
        },
        {
            "cell_type": "markdown",
            "source": [
                "Noten que por defecto los operadores definidos de esta manera serán (la mayor parte del tiempo) asociativos hacia la izquierda. El cómo generar asociatividad derecha y entender mejor ésta decisión de diseño se puede lograr visitando [esta discusión](https://discourse.julialang.org/t/is-there-any-way-to-make-custom-binary-infix-operators-right-associative/3202/4).\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "4 ⨳ (5 ⨳ 1) == 4 ⨳ 5 ⨳ 1, (4 ⨳ 5) ⨳ 1 == 4 ⨳ 5 ⨳ 1\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 373
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Retorno de las funciones\n",
                "\n",
                "Una función, como visto anteriormente, tiene un valor de retorno tras evaluación mediante la palabra clave `return`. No obstante, esta no es necesaria, pues las funciones por defecto van a retornar la ultima expresión antes de `end`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function test_retorno(x)\n",
                "\tx-1\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 374
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "test_retorno(4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 375
        },
        {
            "cell_type": "markdown",
            "source": [
                "Si deseamos que la función retorne nada, necesitamos explíticamente solicitarlo mediante `return(nothing)`\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function test_retorno₂(x)\n",
                "\tx-1\n",
                "\treturn(nothing)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 376
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "test_retorno₂(4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 377
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esta vez la función fue evaluada, se operó `x-1` pero su resultado no se guardó en ninguna localidad apuntada por alguna variable (y eventualmente se perderá en el recolector de [basura de julia](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science))). Luego, la función no retorna nada, tal cual como especificado.\n",
                "\n",
                "Por otro lado, podemos retornar múltiples valores por una función\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function test(a,b)\n",
                "\t2b, 3a\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 378
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "test(4,7), typeof(test(4,7))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 379
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notemos que el tipo de retorno de una función con múltiples retornos es lo que conocemos como una **tupla**. Más información de ellas en la sección de estructuras de datos.\n",
                "\n",
                "### Tuplas como argumentos de funciones\n",
                "\n",
                "En general, cualquier agrupación ordenada de números es representada en Julia por una tupla, eso incluye los argumentos de una función. Considere el siguiente ejemplo:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\ttest₂(x,y,z) = x*y - z\n",
                "\ttupla_test = (4,3,1)\n",
                "\ttest₂(tupla_test...)  \n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 380
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notemos que la función `test₂` requiere tres argumentos para ser evaluada, no obstante, le hemos pasado solamente uno: `tupla_test`. Esto funciona debido a dos razones:\n",
                "* La variable `tupla_test` es una agrupación de tres elementos que *podrían* ser pasados como argumentos a `test₂`, aunque pasarlo como `test₂(tupla_test)` generaría un error.\n",
                "* Para evitar el error, debemos realizar el procedimiento llamado como *desempacamiento* (unpacking). Esto es, extrae los elementos de una tupla como si fueran elementos individuales; de esa forma evaluándolos. Esto se hace con los [**ellipsis**](https://en.wikipedia.org/wiki/Ellipsis##:~:text=The%20ellipsis%20...%2C%20.,without%20altering%20its%20original%20meaning.) `...` contiguo a la tupla.\n",
                "\n",
                "Esto puede ser utilizado en la definición de las funciones también, para lograr tener un número variable de parámetros.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function argumentosVariables(a, b, x...)\n",
                "\tsum(x)/length(x) + a*b \n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 381
        },
        {
            "cell_type": "markdown",
            "source": [
                "La función anterior toma dos números, `a` y `b`, que son parámetros obligatorios y los multiplica, pero a ello, le sumará la media de todos los números que le siguen.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "argumentosVariables(4, 3, 6) ## 4*3 + 6 = 12 + 6 = 18\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 382
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "argumentosVariables(4, 3, 6, 1, 5, 2, 9, 2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 383
        },
        {
            "cell_type": "markdown",
            "source": [
                "Observemos que `x` no es realmente opcional, pues necesita tener al menos un número para que tenga sentido efectuar `length(x)` y `sum(x)`.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "## Genera error debido a que la función no está bien definida para cuando x es vacío\n",
                "## argumentosVariables(4,3) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 384
        },
        {
            "cell_type": "markdown",
            "source": [
                "Los argumentos realmente opcionales se mirarán luego de discutir los tipos dentro d las funciones:\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Determinación de tipos en las funciones\n",
                "\n",
                "Observemos las siguientes dos funciones:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function duplicadorDeTexto(texto) \n",
                "\treturn(texto*texto)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 385
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function alPoderDeDos(n)\n",
                "\treturn(n*n)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 386
        },
        {
            "cell_type": "markdown",
            "source": [
                "Su nombre, así como el de sus argumentos, documenta bien qué es lo que las funciones pretenden hacer. No obstante, ¿Realmente necesitamos dos funciones?\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "duplicadorDeTexto(\"Hola\"), duplicadorDeTexto(3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 387
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Por supuesto, aunque `3` no es texto, fue procesado por la función ya que la operación `*` está bien definida para enteros. De hecho, la función `alPoderDeDos` es idéntica a `duplicadorDeTexto` en cuanto a lógica.\n",
                "\n",
                "No obstante, ambas funciones son guardadas en memoria y necesitan ser compiladas por el compilador JIT por cada tipo de dato con el vayamos a utilizarlo. Para ahorrarle el paso al compilador de esperar a saber el tipo de dato a utilizar, podemos especificar el tipo de dato a utilizar de la siguiente forma:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function duplicador(texto::String)\n",
                "\treturn(texto*texto)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 388
        },
        {
            "cell_type": "markdown",
            "source": [
                "Uno puede explorar los pasos que sigue la evaluación de una función al ser evaluada por instrucciones en lenguaje máguina utilizando el macros `@code_native`\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "## @code_native duplicador(\"Hola\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 389
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Si nosotros quisieramos proveer la funcionalidad también para los números, hacemos uso de lo llamado **Multiple dispatch**, o bien puesto en concepto: la producción de múltiples definiciones para una sola función, dependientes del contexto de sus argumentos. \n",
                "\n",
                "Cada una de estas múltiples definiciones son llamadas **métodos**, aunque no deben confundirse con lo que se conoce como método en **programación orientada a objetos**.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function duplicador(num::Integer)\n",
                "\treturn(2*num)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 390
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "duplicador(3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 391
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "## @code_native duplicador(3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 392
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Notemos que ahora la definición de nuestra función indica `generic function with 2 methods`, haciendo referencia a que es una sola función pero que ahora posee dos **métodos**. \n",
                "\n",
                "Podemos también especificar el tipo de la salida de la función, lo cual es además útil para aumentar la legibilidad de nuestro flujo de código, evitar errores no deseados tras ser suficientemente específicos y forzar el tipo de ciertos resultados.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function media(x::AbstractFloat, y::AbstractFloat) :: Float32\n",
                "\tresultado = (x+y)/2\n",
                "\treturn(resultado)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 393
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notemos que como el tipo de salida se ha especificado a ser `Float32`, los números  `x` y `y`, que pueden ser `Floats` de cualquier número de bits (al pertenecer  a su clase abstracta) van a ser siempre convertidos a su representación de 32 bits tras operarse con la función.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "media(5.0, 3.5), typeof(media(5.0, 3.5))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 394
        },
        {
            "cell_type": "markdown",
            "source": [
                "Para los más inclinados a una notación matemática más rigurosa, es posible hacer  definiciones de funciones anónimas, especificando sus tipos, de forma que imite la notación usual de definición de funciones en matemática.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ℤ = Integer; ℚ = Rational;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 395
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "h = x::ℤ -> (1//x)::ℚ\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 396
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "h(5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 397
        },
        {
            "cell_type": "markdown",
            "source": [
                "### Argumentos opcionales en funciones\n",
                "\n",
                "Para agregar un valor por defecto en un argumento de una función basta con seleccionarlo en su definición. Posterior a ello, éste será totalmente opcional a colocar, y en caso de no colocarlo, se utilizará el valor por defecto que se eligió.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function múltiples_opcionales(x, y = 1, z = 3)\n",
                "\treturn(x,y,z)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 398
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "múltiples_opcionales(5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 399
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "múltiples_opcionales(5, 5, 9)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 400
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "múltiples_opcionales(5, 6) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 401
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Broadcasting\n",
                "\n",
                "Una función definida aparentemente para un número individual puede ser evaluada en objetos como vectores y matrices utilizando el operador de **broadcasting** (o difusión), '`.`', de la siguiente manera:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "m(x::Integer) = x^2 + 1\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 402
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "m.([1,2,4]) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 403
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "g.([1 2 4; 3 5 6])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 404
        },
        {
            "cell_type": "markdown",
            "source": [
                "El broadcast también puede ser aplicado operación por operación desde la definición de la función:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "g₂(x) = 2x.^2 .+ 3x .+ 1\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 405
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "g₂([1 2 4; 3 5 6])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 406
        },
        {
            "cell_type": "markdown",
            "source": [
                "Veamos un ejemplo un poco más complejo:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function extracción_dominio(correo::String)\n",
                "\t## La siguiente función extrae una subcadena acorde a alguna expresión regular\n",
                "\t## encontrada.\n",
                "\tresult = match(r\"@(.*)\", correo).captures[1] \n",
                "\treturn(result)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 407
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "extracción_dominio(\"correo_ejemplo@julia.com\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 408
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tlista_correos = [\"lffm.fismat@tutanota.com\",\n",
                "\t\t\t\t\t \"correo_ejemplo@julia.com\",\n",
                "\t   \t\t\t\t \"otro_correo@yahoo.com\",\n",
                "\t\t\t\t\t \"luke@lukesmith.xyz\"]\n",
                "\t\n",
                "\textracción_dominio.(lista_correos)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 409
        },
        {
            "cell_type": "markdown",
            "source": [
                "### Structs\n",
                "Los `structs` en julia son la forma de producir tipos propios que funcionen tal cual como los tipos primitivos y compuestos de los que hemos hablado hasta ahora.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "struct Empleado\n",
                "\tnombre\n",
                "\tedad\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 410
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(Empleado), typeof(Float64)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 411
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "empleado₁ = Empleado(\"Felipe\", 24)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 412
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(empleado₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 413
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "supertypes(Empleado)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 414
        },
        {
            "cell_type": "markdown",
            "source": [
                "Más información [aquí](https://docs.julialang.org/en/v1/manual/constructors/)\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dump(Float64)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 415
        },
        {
            "cell_type": "markdown",
            "source": [
                "### Funciones como tipos\n",
                "\n",
                "Las funciones en julia son lo que se conoce como [first-class citizen](https://en.wikipedia.org/wiki/First-class_citizen). Esto quiere decir que, al igual a todos los demás tipos que hemos visto, las funciones pueden operarse dentro de otras funciones, muy similar a como se puede hacer con las funciones en R.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@doc Function\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 416
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "function evalua_funciones(f::Function, argumento)\n",
                "\tf(argumento)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 417
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "evalua_funciones(x -> x+1, 4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 418
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "evalua_funciones(extracción_dominio, \"correo_falso@wikipedia.org\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 419
        }
    ],
    "nbformat_minor": 2,
    "metadata": {
        "language_info": {
            "file_extension": ".jl",
            "mimetype": "application/julia",
            "name": "julia",
            "version": "1.5.1"
        },
        "kernelspec": {
            "name": "julia-1.5",
            "display_name": "Julia 1.5.1",
            "language": "julia"
        }
    },
    "nbformat": 4
}