Estructuras_de_Datos.ipynb

{
    "cells": [
    {
 	    "cell_type": "markdown", 
 	    "source": [ 
 		"# Estructuras de Datos" 
 	    ], 
 	    "metadata": {} 
	},
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "## Estructuras de Datos\n",
                "Las estructurtas de datos son formatos especiales de datos que permiten guardar, organizar y manipular información. En particular, cada estructura especifica la forma en la cual se pueden realizar operaciones sobre los datos que contiene y a la vez sobre qué tipo de datos trabajan. \n",
                "\n",
                "Las estructuras de datos ocultan al programador la manera en que se maneja la memoria y la gestionan de forma eficiente, por ende genera eficiencia en los algoritmos que los implementan. \n",
                "\n",
                "Existen numerosas estructuras de datos cada una diseñada para una aplicación en específico, Julia incorpora algunos tipos de datos básicos y sus procedimientos correspondientes, sin embargo no incorpora por defecto todos los tipos conocidos. Por ello, la comunidad de Julia ha trabajado en un paquete que incorpora diferentes estructuras de datos procurando rendimiento (revisar el paquete [DataStructures.jl](https://juliacollections.github.io/DataStructures.jl/latest/circ_buffer/)).\n",
                "\n",
                "A continuación, se disertará sobre algunos de los tipos de datos básicos incorporados por defecto en Julia.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "###  Rangos\n",
                "\n",
                "`(:)(start,[step],stop)`\n",
                "\n",
                "Esta estructura permite crear secuencias de números, desde un número dado (`start` ) hasta otro (`stop`) con un tamaño de paso (`[step]`) que puede ser inidicado de forma opcional. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\trange₁ = -5:10\n",
                "\trange₂ = 0:2:10\n",
                "\trange₃ = 0:10.0\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 137
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Por defecto el tamaño del paso es `1`. Si es requerido Julia realiza una conversión automática de tipos de datos. En general el rango puede ser tipo `UnitRange` o `StepRange`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(range₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 138
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(range₂)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 139
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(range₃)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 140
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Puede notar que el tipo de dato de cada elemento del range está determinado infiriendo este (de forma automática) por cualquiera de los tipos de datos de: `start`, `step` o `stop`.\n",
                "\n",
                "Para crear un rango también puede utilizarse el constructor `OneTo` (perteneciente al módulo Base), que garantiza el valor inicial de la secuencia es `1` al igual que el paso.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "range₄ = Base.OneTo(10)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 141
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "range₄[5]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 142
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Array\n",
                "\n",
                "Los arrays son un tipo de estructura que contiene datos relacionados, con ellos pueden ser representados vectores y matrices. \n",
                "\n",
                "En Julia los Arrays son listas, que pueden contener más de un tipo de dato, según este sea creado o inicializado, además implementa métodos para incrementar y eliminar elementos. También, a diferencia de otras estructuras los array pueden tener datos duplicados.\n",
                "\n",
                "#### Inicialización de arrays\n",
                "El array puede ser inicializado de diversas maneras, como se contempla a continuación:\n",
                "\n",
                "**Usando el constructor explícito**\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁ = Array{Float64}(undef,5,2,2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 143
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁[5][1]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 144
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el constructor explícito debe especificarse: \n",
                "* El tipo de dato (en el ejemplo `Float64`).\n",
                "* Las dimensiones del array (en el ejemplo al array se especifica 3 dimensiones).\n",
                "* El tamaño del array, el keyword `undef` debe ser declarado, posteriormente se indica la cantidad cantidad de elementos por dimensión.\n",
                "\n",
                "**NOTA:**  Aunque se desea tener un array vacío, al especificar el tamaño de array, Julia rellena los elementos con datos contenidos en el garbage.\n",
                "\n",
                "El array vacío (sin especificar el tamaño) se puede inicializar de las siguientes maneras:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₂ = Array{Any,1}()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 145
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₃ = []\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 146
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En las inicializaciones anteriores el array acepta cualquier tipo de valor, pues su definición contempla elementos con el supertipo `Any` (en el caso de `array₂` se define de forma explícita y en el de `array₃` de forma implícita).\n",
                "\n",
                "Pueden existir casos en que el array solo deba contener elementos de un número limitado de tipos, en tales casos la declaración del tipo del array puede ser decalarado mediante `Union`, por ejemplo: `Array{Union{Int64,Float64,String},2}`. En el ejemplo el array solo podrá contener elementos del tipo: `Int64`, `Float64` o `String`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₄ = Array{Float64,1}()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 147
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₅ = Float64[]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 148
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los arrays anteriores están vacios, pero solo aceptan elementos que son del tipo `Float64` o que pueden ser promovidos a ese tipo (por ejemplo Int64 puede ser convertido a Float64).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "push!(array₄,2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 149
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "##push!(array₅,\"Hola\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 150
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "**NOTAS:** Con el método `push!` se pueden agregar elementos al array. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Si ya se conoce el contenido del array, este puede ser inicializado como 'array literal', es decir puede ser creado de forma manual. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₆ = [1,2,3]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 151
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El array anterior, que es de 1 dimensión, es conocido como array columna, en lugar de utilizar `,` puede utilizar `;`. Un array fila puede ser creado si cada elemento del array es separado mediante un espacio.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₇ = [1 2 3]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 152
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Como puede notar el tipo de dato entre `array₆` y `array₇` difieren, el primero es de una dimensión mientras que el segundo es de dos dimensiones. Lo anterior significa que en `array₇`  cada elemento se encuentra en columnas diferentes de la matriz.\n",
                "\n",
                "Lo anterior puede suponer varias ventajas, ya que se pueden realizar operaciones conocidas entre matrices.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₇*array₆\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 153
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₆*array₇\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 154
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el caso de un array de dos dimensiones, existen diferentes formas en que este puede ser inicializado de formas manual. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₈ = [[1,2,3] [4,5,6] [7,8,9]]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 155
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el caso anterior el array fue creado por columnas, mediante el ingreso de arrays columnas separados por un espacio. Similares resultados se obtienen al utilizar el método [hcat](https://docs.julialang.org/en/v1/base/arrays/##Base.hcat).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "hcat([1,2,3],[4,5,6])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 156
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₉ = [[1 2 3]; [4 5 6]]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 157
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el caso anterior el array fue creado mediante filas, mediante el ingreso de arrays filas separados por una `;`. Similares resultados se obtienen al utilizar el método [vcat](https://docs.julialang.org/en/v1/base/arrays/##Base.vcat). \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "vcat([1 2 3], [4 5 6] )\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 158
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Inicialización de arrays especiales\n",
                "\n",
                "Julia implementa métodos que pueden ser útiles para crear array de forma rápida\n",
                "\n",
                "##### Array de ceros\n",
                "Un array de ceros puede ser creado con el método `zeros`, que admite como argumentos el tipo de datos y luego las dimensiones del array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "zeros(Int64,4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 159
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "zeros(Float64,4,4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 160
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "##### Array de unos\n",
                "Un array de unos puede ser creado con el método `ones`, que admite como argumentos el tipo de datos y luego las dimensiones del array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ones(Float64,3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 161
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ones(Float64,3,3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 162
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "**NOTA:** Puede leer más sobre inicialización de arrays y métodos para el manejo de arrays en:\n",
                "+ La sección [Construction and Initialization](https://docs.julialang.org/en/v1/manual/arrays/##Construction-and-Initialization) del capítulo Multi-dimensional Arrays del manual de Julia.\n",
                "+ La sección [Constructors and Types](https://docs.julialang.org/en/v1/base/arrays/##Constructors-and-Types) del capítulo Arrays en el manual de Julia.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Accediendo a los elementos de un Array\n",
                "Se accede a los elementos de un array con `[]` e indicando la posición de elemento.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₆\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 163
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₆[1]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 164
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Como puede ser observado, a diferencia de otros lenguajes de programación, Julia tiene indexación base-1, lo que significa que para el primer elemento del array tiene índice `1` no `0`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array3dim = cat([1 2; 3 4],[\"Hola 1\" \"Hola 2\"; \"Hola 3\" \"Hola 4\"],[5 6; 7 8],dims=3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 165
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array3dim[1,1,2]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 166
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el ejemplo anterior se accede a un elemento de un array de 3 dimensiones, indicando la posición con una terna de números. Sin embargo, se puede acceder a más de un elemento extrayendo un subarray del primero.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₆[2:3]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 167
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los índices de los elementos que se desean extraer pueden ser indicados mediante un objeto tipo range como se muestra en el ejemplo.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array3dim[:,:,2]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 168
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Con el símbolo `:` se indica que todos los elementos de una dimensión del array deben ser extraidos; en el caso del array de una dimensión, todos los elementos del mismo.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array3dim[1,1:2,3]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 169
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array3dim[1:2,2,1]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 170
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En los ejemplos anteriores, se recorre el arreglo por columna y por fila respectivamente. \n",
                "\n",
                "Para un mejor rendimiento, se recomienda recorrer un array por columna, debido a la forma en que Julia almacena los elementos del array en memoria, como se muestra a continuación.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₀ = [1:3 4:6 7:9 ] \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 171
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Note que `array₁₀` es un array de dos dimensiones y aunque se accede a los elementos indicando dos índices, también puede accederse mediante un solo índice.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[array₁₀[1],array₁₀[3],array₁₀[4],array₁₀[6],array₁₀[7],array₁₀[end]]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 172
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Ello indica que Julia almacena los elementos del array de forma concecutiva por columnas. Por ende, si el array se recorre por filas se tendrán que hacer cálculos adicionales llevando un costo de tiempo; por esa razón el costo por acceder a un array por columnas es menor que si se hiciera por filas.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Métodos útiles\n",
                "Julia implementa numerosos métodos para trabajar con los arrays. A continuación, se mencionan algunas de las más básicas que permiten realizar varias tareas.\n",
                "\n",
                "En Julia los argumentos de las funciones se pasan por referencia, es decir, se pasa a la función no solo el valor contenido en la variable sino que, también se pasa la referencia a la variable original. Lo anterior significa que, cualquier cambio realizado al argumento dentro de la función, dicho cambio se verá reflejado en la variable original.\n",
                "\n",
                "\n",
                "Por ello, en Julia se sigue una convención cuando se diseña funciones y esta es: si la función modifica el argumento se denota añadiendo al nombre el símbolo `!`. La convención mencionada es algo que se mira en varias funciones, existiendo dos versiones de las mismas (las que modifican la variable original y las que no).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁ = [1,2,3]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 173
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `push!` modifica el array, agregando un elementos al final del mismo y devuelve el array modificado. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "push!(array₁₁,4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 174
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "push!(array₁₁,5,6,7)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 175
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 176
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `pushfirst!` añade un elementos al inicio del array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "pushfirst!(array₁₁,-1,0)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 177
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `pop!` elimina y retorna el último elemento del array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "pop!(array₁₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 178
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 179
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `popfirst!` elimina y retorna el primer elemento del array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "popfirst!(array₁₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 180
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 181
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `deleteat!` elimina un elemento indicado la posición de este dentro del array y devuelve el array modificado.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "deleteat!(array₁₁,6)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 182
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "deleteat!(array₁₁,3:5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 183
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `splice!` tiene diferentes formas de uso; entre ellas reemplazar elementos del array, indicando la posición del elemento por reemplazar y devuelve el valor del elemento reemplazado.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "splice!(array₁₁,3,3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 184
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 185
        },
        {
            "cell_type": "markdown",
            "source": [
                "Otra forma de uso es la de eliminar elementos, para ello solo se pasa como argumento el array a modificar y la posición del elemento, el método devuelve el valor del elemento eliminado.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "splice!(array₁₁,2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 186
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 187
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Otro caso de uso para `splice!` es la eliminar un elemento y agregar elementos indicándolos por medio de una lista.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "splice!(array₁₁,2,[3,4,5,6])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 188
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 189
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "splice!(array₁₁,2,[1,2,3])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 190
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 191
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "También pueden insertarse elementos elementos entre otros, como se ilustra.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "splice!(array₁₁,4:3,0)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 192
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 193
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para que `splice!` funcione de la manera mostrada anteriormente, es necesario que el índice de los elementos donde se desea insertaer se indiquen de la forma `n:n-1`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Existe un método para vaciar un array, este método presenta los dos casos: el que modifca el array y el que no, el método `empty` y `empty!`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "empty(array₁₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 194
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 195
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "empty!(array₁₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 196
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₁\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 197
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `maximum` devuelve el máximo valor entre los valores del elemento de un array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "maximum([1 2; 3 4])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 198
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `minimum` devuelve el mínimo valor entre los valores del elemento de un array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "minimum([1 2; 3 4])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 199
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Merece la atención los métodos anteriores, pues devuelven el menor o mayor valor (según sea el caso) al llamado de una función, para más información puede leer del manual de Julia las [secciones](https://docs.julialang.org/en/v1/base/collections/##Base.maximum) relacionadas con dichas funciones.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El método `isempty` comprueba si el array está vacío o no.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "isempty(array₁₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 200
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "isempty(array₁₀)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 201
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "La función `length` devuelve la cantidad de elementos que contiene el array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "length(array₁₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 202
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "length(array₁₀)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 203
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "La funión `size` devuelve las una tupla con las dimensiones del array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "size(array₄)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 204
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "size(array₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 205
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "**NOTA:** Más funciones e información acerca de los arrays en Julia puede encontrarlo en el manual en la seción [Multi-dimensional Arrays](https://docs.julialang.org/en/v1/base/collections/##Base.maximum)\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Precauciones\n",
                "\n",
                "Al trabajar con arrays en alguna ocasión se querrá hacer una copia de esta. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₂ = [1,2,3]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 206
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "arraycopy₁ = array₁₂\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 207
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El problema de las líneas anteriores es: tanto `array₁₂` como `arraycopy₁` apuntan a la misma dirección de memoria, es decir, la línea de código `arraycopy₁ = array₁₂` no asigna el valor de `array₁₂` en `arraycopy₁`. \n",
                "\n",
                "Para comprobar lo anterior puede usarse el operador de igualdad estricto.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "arraycopy₁ === array₁₂\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 208
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Además cualquier modificación realizado con `arraycopy₁` se verá reflejado en `array₁₂`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "push!(arraycopy₁,5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 209
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₂\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 210
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para hacer una copia de una array puede utilizarse el método `copy`, el cual realiza una copia del array indicado en su argumento.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "arraycopy₂ =  copy(array₁₂)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 211
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "arraycopy₂ === array₁₂\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 212
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "push!(arraycopy₂,5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 213
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₂\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 214
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Tuplas\n",
                "\n",
                "Las tuplas (`Tuples`) son listas, pero a diferencia de los arrays son inmutables. Lo anterior quiere decir que una vez creada la tupla esta no puede ser: modificada, eliminada o sobreescrita, como sí sucede con los arrays. Al igual que los arrays, las tuplas pueden contener diferentes tipos de datos.\n",
                "\n",
                "Para crear una tupla, los elementos de esta se encierran entre `()`. Se accede a los elementos de las tuplas de la misma forma en que se acceden a los elementos de un array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "tuple₁ = (1,2,3,\"Hello, World!\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 215
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(tuple₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 216
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para comprobar la inmutabilidad de las tuplas, se puede intentar modificar el tercer elemento de `tuple₁` y de `array₁₂` (en el caso de `tuple₁` se obtendrá un error).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "##tuple₁[3] = 33\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 217
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "array₁₂[3] = 33; array₁₂\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 218
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Cuando se quiere crear una tupla de un solo elemento, al final del elemento debe colocarse `,`; ya que el uso de `( )` serían interpretados como elementos de agrupación. Para mantener coherencia, se permite lo mismo si se inicializa una tupla con más de un elemento.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "tuple₂ = (11,) ##Compare con la asignación (11), en el cual tuple₂ sería una variable con valor 11 del tipo Int64\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 219
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "tuple₃ = (11,12,13,) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 220
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "A menudo las tuplas son implementadas en el retorno de funciones, por ejemplo, la función `divrem` que retorna el cociente y el resto de la división euclidiana. Cuando sucede lo anterior los valores de la tupla se puede descomprimir en variables.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "cociente,resto = divrem(39,5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 221
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[cociente, resto]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 222
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Una discusión sobre el tipo de tuplas puede encontrarse en [Tipos de Tuplas](https://riptutorial.com/es/julia-lang/example/22725/tipos-de-tuplas).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "De forma opcional, los componentes de las tuplas pueden ser nombrados, en dicho caso se construye una tupla con nombre.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "tuple₄ = (a = 2, b = 4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 223
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para acceder a los elementos de una tupla nombrada se puede usar la sintaxis `tuple.nombre`, además de la indexación normal `tuple[i]`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[tuple₄.a, tuple₄[:b], tuple₄[1],tuple₄[2]]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 224
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Diccionarios\n",
                "Los diccionarios son estructuras de datos que guardan datos en forma de clave-valor, es decir es una colección asociativa de datos que no tienen un orden establecido. \n",
                "\n",
                "#### Creando diccionarios\n",
                "Los diccionarios son creados con el constructor `Dict`, este puede contener como argumentos las claves asociadas a los valores o puede usarse sin argumentos (en dicho caso es vacío).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dict₁ = Dict(\"Nombre\"=>\"Juan\", \"Edad\"=>25, 3.0=>50)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 225
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Como puede observarse, los diccionarios pueden aceptar como clave cualquier valor y tipo de dato. Para asociar los valores a las claves se utiliza el operador `=>`, que corresponde a la función `Pair()`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dict₂ = Dict()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 226
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "`dict₂` es un diccionario vacío, pero al igual que los array es una estructura de datos mutable, por lo que pueden añadirse elementos como se haría con array asociativos en otros lenguajes de programación.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tdict₂[1] = \"Hola\" ##La clave es un valor del tipo Int64\n",
                "\tdict₂[\"dos\"] = \"Mundo\" ##La clave es un valor del tipo String\n",
                "\tdict₂[:x] = \"Tercer elemento\" ##La clave es un valor del tipo Symbol\n",
                "\tdict₂\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 227
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En un diccionario las claves deben ser únicas, no pueden existir dos claves con el mismo nombre.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[dict₂[1], dict₂[\"dos\"], dict₂[:x]]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 228
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Accediendo a los elementos de un array\n",
                "El acceso a los elementos del diccionario se realiza de forma similar a los arrays, mediante `[ ]`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Dict(\"nombre\"=>\"Pedro\", \"nombre\"=>\"Rodríguez\") ##El diccionario solo tiene una única clave 'nombre'\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 229
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Métodos usados con diccionarios\n",
                "\n",
                "Para conocer si una determinada clave existe se puede utilizar el método `haskey`, este retorna `true` o `false` dependiendo si existe o no.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[haskey(dict₂,5), haskey(dict₂,\"dos\"), haskey(dict₂,1)]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 230
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "De igual manera se puede determinar si un par `clave => valor` existe con el método `in`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "[in(1=>\"Hola\",dict₂), in(1=>\"Mundo\",dict₂)]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 231
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Las claves de un diccionario pueden obtenerse uando el método `keys`, el cual retorna un iterador. Se puede utilizar el método collect para transformarlo en un array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "keys(dict₂)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 232
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "collect(keys(dict₂))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 233
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los valores de un diccionario pueden obtenerse uando el método `values`, el cual retorna una lista con ellas.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "values(dict₂)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 234
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "collect(values(dict₂))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 235
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Tipos de datos y los diccionarios\n",
                "\n",
                "En los diccionarios mostrados, el tipo de dato para la clave y los valores podian ser de diferentes tipos. La definición del diccionario es la siguiente: \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(dict₂)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 236
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Como se observa `Dict{Any,Any}` indica que el tipo de dato para la clave es `Any` y para el valor es `Any`.\n",
                "\n",
                "Puede crearse un dicconario que restrinja el tipo de datos para la clave y valor, de esta manera puede crearse una estructura más compleja.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(Dict{String,Int64}(\"1\"=>1, \"2\"=>2))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 237
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(Dict{Int64,String}(1=>\"1\", 2=>\"2\"))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 238
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(Dict{Symbol,Int64}(:x=>1, :y=>2))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 239
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los diccionarios y las tuplas nombradas pueden ser vistas como similares, sin embargo, existe una diferencia fundamental: que las tuplas son inmutables mientras que los diccionarios son mutables.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Conjuntos \n",
                "\n",
                "Los conjuntos son una colección desordenada de datos, pero tiene la peculiaridad de no contener elementos duplicados. Así como los arrays y los diccionarios son tipos de datos mutables. \n",
                "\n",
                "Al igual que los arrays y los diccionarios, los conjuntos pueden contener cualquier tipo de dato. Al momento de crear el conjunto el tipo de dato puede ser especificado, como en otras estructuras de datos; si el tipo de dato no es especificado, Julia analiza los elementos y define  el tipo de datos del conjunto.\n",
                "\n",
                "#### Creación de conjuntos\n",
                "Los conjuntos son creados con el constructor `set`, cuyos elementos son especificados mediante un array.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₁ = Set()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 240
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "`set₁ ` es un conjunto vacío que acepta cualquier valor.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₂ = Set{Float64}()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 241
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "`set₂` es un conjunto vacío que acepta valores del tipo `Float64`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₃ = Set([1,2,3,3])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 242
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Como puede notar, en el caso de `set₃` Julia analiza que los elementos del conjunto `set₃` deben ser del tipo `Int64`. Dado que los conjuntos no pueden tener elementos duplicados, finalmente `set₃` solo tiene un elemento con valor `3`. \n",
                "\n",
                "Con el método `push!` se puede agregar datos a los conjuntos, pero dado que es una colección de elementos desordenados no puede usarse el método `pushfirts!`. De la misma manera con el método `pop!` se puede eliminar un elemento del conjunto indicándolo.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "push!(set₃,5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 243
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "pop!(set₃,5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 244
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₃\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 245
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Métodos relacionados con los conjuntos\n",
                "Julia implementa diferentes métodos para trabajar con los conjuntos (muchos de ellos también puede usarse con los diccionarios).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₄ = Set([\"Domingo\",\"Lunes\",\"Martes\",\"Miércoles\",\"Jueves\",\"Viernes\",\"Sábado\"])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 246
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₅ = Set([1,2,3,\"Sábado\",\"Domingo\"])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 247
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Con el método `union` los conjuntos pueden fusionarse, retornando el conjunto resultante. Es decir, un conjunto cuyo elementos se ecuentra en cualquiera de los conjuntos.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "union(set₅,set₄)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 248
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "union!(set₅,set₄)\n",
                "",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 249
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₅\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 250
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Con el método `intersect` se obtiene la interseción de los conjuntos, es decir, devuelve un conjunto cuyos elementos se encuentra en ambos conjuntos.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "intersect(set₄,set₅)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 251
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "intersect!(set₄,set₅)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 252
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₄\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 253
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Con el método `setdiff` se obtiene la diferencia entre dos conjuntos, es decir, un conjunto cuyos elementos se encuentran en uno de ellos no en el otro.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "setdiff(set₅,set₄)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 254
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "setdiff!(set₅,set₄)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 255
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### List Comprehensions\n",
                "Es un forma poderosa de crear listas o array, que también ha sido implementado en otros lenguages de programación.  Tiene la peculiaridad de definir los elementos del array de manera similar a la notación constructiva en matemática. Tiene la siguiente sintaxis:\n",
                "\n",
                "`[ expresión for elemento ∈ colección]`\n",
                "\n",
                "\n",
                "Por ejemplo, un matemático podría decir: *'Sea $S$ el conjunto de todos los elementos $n$, donde $n$ es mayor o igual a $1$ y menor o igual a $10$'*. En tal caso se puede crear en Julia un conjunto que responda a la definición anterior.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "set₆ = Set([n for n ∈ 1:10])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 256
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Ahora bien, con list comprehensions se pueden utilizar condicionales que actúan como filtro, de esta manera se pueden definir conjuntos más complicados como: *'Sea $C$ el conjunto de todos los elementos $n$; donde $n$ es mayor o igual a $1$, menor o igual a $10$ y divisible entre dos'*\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "C = [n for n ∈ 1:10 if n%2 == 0]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 257
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Dobles iteraciones se pueden utilizar para generar arrays con list comprehensions.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "tablamultiplicar₁ = [ x*y for x ∈ 1:10, y ∈ 1:10]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 258
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el caso anterior, se crea un array de más de dos dimensiones. Si se utiliza dos bucles de forma explícita se generan los mismos elementos, sin embargo, de esta última manera se crea un array de una dimensión.  \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "tablamultiplicar₂ = [ x*y for x ∈ 1:10 for y ∈ 1:5]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 259
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Al igual que los arrays el tipo de datos de los elementos es analizado por Julia, pero este puede ser definido de forma explícita.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(Float64[n for n ∈ 1:10])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 260
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Tipos de estructuras como: diccionarios, tuplas y arrays, pueden ser usados para realizar iteraciones.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "for i ∈ [1,2,3]\n",
                "\tprint(i)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 261
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "tuple₄\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 262
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "for i ∈ tuple₄\n",
                "\tprint(i)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 263
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dict₂\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 264
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "for i ∈ keys(dict₂)\n",
                "\tprint(dict₂[i])\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 265
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "for i ∈ values(dict₂)\n",
                "\tprint(i)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 266
        }
    ],
    "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
}