python3_numpy_es.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Mis notas: NumPy<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Intro\" data-toc-modified-id=\"Intro-0\"><span class=\"toc-item-num\">0&nbsp;&nbsp;</span>Intro</a></span></li><li><span><a href=\"#Arrays\" data-toc-modified-id=\"Arrays-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Arrays</a></span><ul class=\"toc-item\"><li><span><a href=\"#Creación\" data-toc-modified-id=\"Creación-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Creación</a></span></li><li><span><a href=\"#Representación\" data-toc-modified-id=\"Representación-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Representación</a></span></li><li><span><a href=\"#Atributos\" data-toc-modified-id=\"Atributos-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Atributos</a></span></li><li><span><a href=\"#Indexado\" data-toc-modified-id=\"Indexado-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Indexado</a></span></li><li><span><a href=\"#Slicing\" data-toc-modified-id=\"Slicing-1.5\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>Slicing</a></span></li><li><span><a href=\"#Sub-arrays\" data-toc-modified-id=\"Sub-arrays-1.6\"><span class=\"toc-item-num\">1.6&nbsp;&nbsp;</span>Sub-arrays</a></span></li><li><span><a href=\"#Copia\" data-toc-modified-id=\"Copia-1.7\"><span class=\"toc-item-num\">1.7&nbsp;&nbsp;</span>Copia</a></span></li><li><span><a href=\"#Reformateo\" data-toc-modified-id=\"Reformateo-1.8\"><span class=\"toc-item-num\">1.8&nbsp;&nbsp;</span>Reformateo</a></span></li><li><span><a href=\"#Concatenación\" data-toc-modified-id=\"Concatenación-1.9\"><span class=\"toc-item-num\">1.9&nbsp;&nbsp;</span>Concatenación</a></span></li><li><span><a href=\"#División\" data-toc-modified-id=\"División-1.10\"><span class=\"toc-item-num\">1.10&nbsp;&nbsp;</span>División</a></span></li><li><span><a href=\"#Arrays-de-fechas\" data-toc-modified-id=\"Arrays-de-fechas-1.11\"><span class=\"toc-item-num\">1.11&nbsp;&nbsp;</span>Arrays de fechas</a></span></li></ul></li><li><span><a href=\"#Funciones-universales\" data-toc-modified-id=\"Funciones-universales-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Funciones universales</a></span><ul class=\"toc-item\"><li><span><a href=\"#Funciones-aritméticas\" data-toc-modified-id=\"Funciones-aritméticas-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Funciones aritméticas</a></span></li><li><span><a href=\"#Funciones-comparativas\" data-toc-modified-id=\"Funciones-comparativas-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Funciones comparativas</a></span></li><li><span><a href=\"#Funciones-lógicas\" data-toc-modified-id=\"Funciones-lógicas-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Funciones lógicas</a></span></li><li><span><a href=\"#Funciones-trigonométricas\" data-toc-modified-id=\"Funciones-trigonométricas-2.4\"><span class=\"toc-item-num\">2.4&nbsp;&nbsp;</span>Funciones trigonométricas</a></span></li><li><span><a href=\"#Funciones-exponenciales-y-logarítmicas\" data-toc-modified-id=\"Funciones-exponenciales-y-logarítmicas-2.5\"><span class=\"toc-item-num\">2.5&nbsp;&nbsp;</span>Funciones exponenciales y logarítmicas</a></span></li><li><span><a href=\"#Otras-funciones\" data-toc-modified-id=\"Otras-funciones-2.6\"><span class=\"toc-item-num\">2.6&nbsp;&nbsp;</span>Otras funciones</a></span></li><li><span><a href=\"#Métodos-de-las-funciones-universales\" data-toc-modified-id=\"Métodos-de-las-funciones-universales-2.7\"><span class=\"toc-item-num\">2.7&nbsp;&nbsp;</span>Métodos de las funciones universales</a></span></li></ul></li><li><span><a href=\"#Funciones-no-universales\" data-toc-modified-id=\"Funciones-no-universales-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Funciones no universales</a></span><ul class=\"toc-item\"><li><span><a href=\"#Funciones-estadísticas\" data-toc-modified-id=\"Funciones-estadísticas-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Funciones estadísticas</a></span></li><li><span><a href=\"#Funciones-para-arrays-booleanos\" data-toc-modified-id=\"Funciones-para-arrays-booleanos-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Funciones para arrays booleanos</a></span></li><li><span><a href=\"#Funciones-para-matrices\" data-toc-modified-id=\"Funciones-para-matrices-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Funciones para matrices</a></span></li><li><span><a href=\"#Producto-tensorial-y-Producto-vectorial\" data-toc-modified-id=\"Producto-tensorial-y-Producto-vectorial-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>Producto tensorial y Producto vectorial</a></span></li><li><span><a href=\"#Funciones-especializadas\" data-toc-modified-id=\"Funciones-especializadas-3.5\"><span class=\"toc-item-num\">3.5&nbsp;&nbsp;</span>Funciones especializadas</a></span></li><li><span><a href=\"#Rutinas\" data-toc-modified-id=\"Rutinas-3.6\"><span class=\"toc-item-num\">3.6&nbsp;&nbsp;</span>Rutinas</a></span></li></ul></li><li><span><a href=\"#Broadcasting\" data-toc-modified-id=\"Broadcasting-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Broadcasting</a></span></li><li><span><a href=\"#Indexado-múltiple\" data-toc-modified-id=\"Indexado-múltiple-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Indexado múltiple</a></span></li><li><span><a href=\"#Ordenación-de-arrays\" data-toc-modified-id=\"Ordenación-de-arrays-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Ordenación de arrays</a></span><ul class=\"toc-item\"><li><span><a href=\"#Ejemplo:-KNN-(K-Nearest-Neighbours)\" data-toc-modified-id=\"Ejemplo:-KNN-(K-Nearest-Neighbours)-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span>Ejemplo: KNN (K-Nearest Neighbours)</a></span></li></ul></li><li><span><a href=\"#Arrays-estructurados\" data-toc-modified-id=\"Arrays-estructurados-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Arrays estructurados</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Disclaimer**: Este notebook contiene mis notas sobre NumPy, recogiendo lo más útil del [capítulo 2](https://jakevdp.github.io/PythonDataScienceHandbook/02.00-introduction-to-numpy.html) de [Python Data Science Handbook](https://jakevdp.github.io/PythonDataScienceHandbook/index.html) escrito por [Jake VanderPlas](http://vanderplas.com/), y de la documentación de NumPy. Recomiendo leer la fuente original e ir ejecutando todos los ejemplos (___learn by doing!___)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[NumPy](http://www.numpy.org/) (Numerical Python) es una librería fundamental para cálculo científico en Python, preparada para tratar grandes cantidades de datos. Los arrays de NumPy proporcionan almacenamiento y operaciones mucho más eficientes que los arrays estándar de Python, lo que requerimos cuando los datos empiezan a crecer. Esto convierte a NumPy en parte indispensable dentro del ecosistema de Data Science con Python.\n",
    "\n",
    "Para poder usar NumPy, simplemente tendremos que importar la librería :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NumPy suele importarse con el alias np\n",
    "import numpy as np\n",
    "np?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Igual que un tipo básico en Python es más que un simple valor debido al tipado dinámico (en realidad se trata de una estructura de C), una lista es más que una simple colección de objetos uniformes, pudiendo albergar todo tipo de objetos simultáneamente. \n",
    "\n",
    "Esta flexibilidad tiene un precio, ya que cada objeto en una lista debe incluir información del tipo (entre otras cosas). En el caso de que todos los elementos fueran de un mismo tipo podríamos eliminar la redundancia para ganar en eficiencia de almacenado; y esto es precisamente lo que aporta el objeto `array` disponible en Python desde la versión 3.3.\n",
    "\n",
    "El objeto `ndarray` de NumPy (o array de NumPy a secas) aparte de las ventajas del array de Python aporta también una serie de operaciones eficientes sobre sus datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todos los elementos de un objeto ndarray son del mismo tipo.\n",
    "\n",
    "> Lista de tipos básicos para arrays de NumPy: [Doc:  Data types](https://docs.scipy.org/doc/numpy/user/basics.types.html)\n",
    "\n",
    "### Creación\n",
    "\n",
    "Podemos crear arrays en NumPy **a partir de listas o tuplas** de Python, usando el método `array()`\n",
    "\n",
    "Si se construyen con elementos de distintos tipos, NumPy intentará el ***upcasting*** automático. Si eso no es posible, obtendremos un error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación a partir de una lista\n",
    "np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación a partir de una tupla, especificando el tipo deseado\n",
    "np.array((1, 2, 3), dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 2.5, 3. ])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación con elementos de tipo int y float => upcasting automático a float\n",
    "np.array([1, 2.5, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1', '2.5', '3.1'], dtype='<U11')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación con elementos de tipo numérico y texto => upcasting automático a cadenas de texto\n",
    "np.array([1, '2.5', 3.1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos crear arrays sin partir de una lista, **usando funciones específicas** como `arange()`, que nos permite generar una secuencia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear un array de números secuenciales con arange(), que es como range() de Python pero devolviendo un array\n",
    "np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear un array de números dentro de un intervalo, indicando el salto\n",
    "np.arange(1, 10, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos controlar el número de elementos generados usaremos `linspace()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 1.5, 3. , 4.5, 6. , 7.5, 9. ])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear un array con linspace(), indicando el intervalo y el número de elementos equiespaciados\n",
    "np.linspace(0, 9, 7) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para inicialización de arrays tenemos `empty()`, `zeros()` o `ones()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.69028917e+180, 5.03961303e-266, 2.56929947e+151, 8.37028247e-313])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear un array \"vacío\" (muestra lo que sea que haya en memoria). Útil para inicializarlo sin más.\n",
    "np.empty(4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear un array de ceros (float por defecto)\n",
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Especificando el tipo...\n",
    "np.zeros(5, dtype='int')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos crear también arrays **multidimensionales**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear un array multidimensional a partir de otros\n",
    "np.array([np.zeros(3), np.ones(3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1],\n",
       "       [1, 1, 1],\n",
       "       [1, 1, 1]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear una matriz (array bidimensional) de 1s. Ojo cómo definimos el tipo (opción b)\n",
    "np.ones((3, 3), dtype=np.int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen otras funciones útiles para inicialización, como `full()`, `zeros_like()` o `eye()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[3.14, 3.14],\n",
       "        [3.14, 3.14]],\n",
       "\n",
       "       [[3.14, 3.14],\n",
       "        [3.14, 3.14]]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear una matriz con un valor concreto. Esta vez probamos con un array de 3 dimensiones!\n",
    "full = np.full((2, 2, 2), 3.14)\n",
    "full"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 0],\n",
       "        [0, 0]],\n",
       "\n",
       "       [[0, 0],\n",
       "        [0, 0]]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crea un array de ceros con la misma forma que otro array\n",
    "np.zeros_like(full, dtype='int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear una matriz identidad (diagonal de 1s)\n",
    "np.eye(3, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introducimos el módulo `random` para generación de **números aleatorios**, y el concepto de semilla para lograr reproducibilidad:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5488135 , 0.71518937, 0.60276338],\n",
       "       [0.54488318, 0.4236548 , 0.64589411],\n",
       "       [0.43758721, 0.891773  , 0.96366276]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear una matriz de números aleatorios entre 0 y 1\n",
    "np.random.seed(0) # semilla\n",
    "np.random.random((3, 3)) # = rand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 6, 7],\n",
       "       [7, 8, 1],\n",
       "       [5, 9, 8]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear una matriz de números enteros aleatorios dentro de un intervalo\n",
    "np.random.randint(0, 10, (3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.48431215,  0.57914048, -0.18158257],\n",
       "       [ 1.41020463, -0.37447169,  0.27519832],\n",
       "       [-0.96075461,  0.37692697,  0.03343893]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Crear una matriz de números aleatorios siguiendo una distribución normal (gaussiana) con media 0 y varianza 1\n",
    "np.random.randn(3, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Representación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.41466194, 0.26455561],\n",
       "        [0.77423369, 0.45615033]],\n",
       "\n",
       "       [[0.56843395, 0.0187898 ],\n",
       "        [0.6176355 , 0.61209572]]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array de ejemplo\n",
    "m = np.random.random((2, 2, 2))\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así veremos un array por defecto con la función `print()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0.41466194 0.26455561]\n",
      "  [0.77423369 0.45615033]]\n",
      "\n",
      " [[0.56843395 0.0187898 ]\n",
      "  [0.6176355  0.61209572]]]\n"
     ]
    }
   ],
   "source": [
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTA: NumPy representa la última dimensión de izquierda a derecha, la penúltima de arriba a abajo, y las siguientes de arriba a abajo separadas por un espacio. Los arrays de 1D se imprimen como filas, los 2D como matrices, y los 3D como una lista de matrices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy no representa los arrays completos por defecto si estos son grandes. Para cambiar este comportamiento usaremos lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "np.set_printoptions(threshold=sys.maxsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Atributos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estos son los atributos más básicos de un array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m.ndim = 3\n",
      "m.shape = (2, 2, 2)\n",
      "m.size = 8\n",
      "m.dtype = float64\n",
      "m.itemsize = 8\n",
      "m.nbytes = 64\n"
     ]
    }
   ],
   "source": [
    "print('m.ndim =', m.ndim)          # dimensiones\n",
    "print('m.shape =', m.shape)        # tamaño\n",
    "print('m.size =', m.size)          # nº de elementos\n",
    "print('m.dtype =', m.dtype)        # tipo\n",
    "print('m.itemsize =', m.itemsize)  # tamaño de cada elemento en bytes\n",
    "print('m.nbytes =', m.nbytes)      # tamaño total en bytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array de ejemplo\n",
    "a = np.arange(0,10); a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos indexar un elemento concreto del array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Acceso a un elemento de un array unidimensional indicando su posición\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Acceso a un elemento indicando su posición desde el final\n",
    "a[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4146619399905236"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Acceso a un elemento de un array multidimensional\n",
    "m[0, 0, 0] # equivalente a m[0][0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Igualmente podemos modificar su contenido:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8, 10])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modificación de un elemento\n",
    "a[9] = 10; a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 2, 0, 4, 0, 6, 0, 8, 0])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modificación de varios elementos\n",
    "a[[1, 3, 5, 7, 9]] = 0; a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder a parte del array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(0,10)\n",
    "# [start:stop:step]\n",
    "a[0:6:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 2, 1])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# [start:stop:-step], desde el final\n",
    "a[3:0:-1] # 9 8 7 6 5 4 [3 2 1] 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Uno de cada 2 elementos empezando por a[1]\n",
    "a[1::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En arrays con más dimensiones tenemos disponible slicing múltiple. La última dimensión siempre son las columnas; y la penúltima las filas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.41466194],\n",
       "        [0.77423369]]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[:1, :2, :1] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.41466194, 0.26455561],\n",
       "       [0.77423369, 0.45615033]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[0,...] # Equivalente a m[0,:,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array Ejemplo\n",
    "a_2x10 = np.array([a, a])\n",
    "a_2x10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Elementos de la primera columna\n",
    "a_2x10[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Elementos de la primera fila\n",
    "a_2x10[0,:] # Equivalente a a_2x10[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si iteramos sobre un array multidimensional, lo estaremos haciendo sobre sus filas (lo que se conoce como axis 0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "for row in a_2x10:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sub-arrays\n",
    "Si creamos un sub-array y modificamos algo del mismo, **se modificará el array original**, ya que no es una copia real. Este comportamiento por defecto nos permitirá cargar parte de un dataset para operar solamente sobre esos datos, evitando cargar el array completo cuando éste es demasiado grande."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x2 = a_2x10[:2,:2]\n",
    "a_2x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1],\n",
       "       [10,  1]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x2[:,0] = [10, 10]\n",
    "a_2x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1,  2,  3,  4,  5,  6,  7,  8,  9],\n",
       "       [10,  1,  2,  3,  4,  5,  6,  7,  8,  9]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copia\n",
    "Si queremos crear una copia real (*deep copy*) de un array o parte del mismo tendremos que usar la función `copy()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1],\n",
       "       [10,  1]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x10_copy = a_2x10[:2,:2].copy()\n",
    "a_2x10_copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reformateo\n",
    "Útil para cambiar la forma de un array, siempre que el número de elementos encaje. Contamos con la función `reshape()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Paso de un array unidimensional (9) a uno bidimensional (3,3)\n",
    "np.arange(1, 10).reshape((3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reformateo automático\n",
    "np.arange(1, 10).reshape((3, -1)) # -1: lo que sea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Paso de un array unidimensional (9) a uno bidimensional (1,9)\n",
    "np.arange(1, 10).reshape((1, 9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos conseguir lo mismo usando corchetes y `newaxis`, que crea un nuevo eje. La nueva dimensión tendrá tamaño 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Paso de 1D (10) a 2D (1, 10). El lugar del 1 será donde tengamos que poner np.newaxis\n",
    "a[np.newaxis, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5],\n",
       "       [6],\n",
       "       [7],\n",
       "       [8],\n",
       "       [9]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Paso de 1D (10) a 2D (10, 1)\n",
    "a[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos **transponer** un array de forma inmediata usando `.T`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 10],\n",
       "       [ 1,  1],\n",
       "       [ 2,  2],\n",
       "       [ 3,  3],\n",
       "       [ 4,  4],\n",
       "       [ 5,  5],\n",
       "       [ 6,  6],\n",
       "       [ 7,  7],\n",
       "       [ 8,  8],\n",
       "       [ 9,  9]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x10.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `ravel()` nos permite **aplanar** cualquier array a 1 dimensión:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10,  1,  2,  3,  4,  5,  6,\n",
       "        7,  8,  9])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x10.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para la concatenación de arrays con mismas dimensiones se usa `concatenate()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1,\n",
       "       2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concatenación de arrays unidimensionales\n",
    "np.concatenate([a, a, a])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1],\n",
       "       [10,  1],\n",
       "       [10,  1],\n",
       "       [10,  1]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concatenación de arrays bidimensionales con mismo tamaño; por defecto se hace por filas (eje 0)\n",
    "np.concatenate([a_2x2, a_2x2]) # axis=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1, 10,  1,  2],\n",
       "       [10,  1, 10,  1,  2]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concatenación de arrays bidimensionales por columnas\n",
    "np.concatenate([a_2x2, a_2x10[:2,:3]], axis=1) # (2,2) + (2,3) válido en el eje 1, no en el 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para concatenación de arrays con distintas dimensiones tendremos que usar `vstack()` o `hstack()` (también válidos para mismas dimensiones). La primera es equivalente a usar `row_stack()`. La segunda se puede sustituir por `column_stack()` si no tenemos más de 2D."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1],\n",
       "       [10,  1],\n",
       "       [10,  1]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concatenación para arrays con distintas dimensiones, en vertical (añadimos filas)\n",
    "np.vstack([a_2x2, a_2x2[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10,  1],\n",
       "       [10,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10,  1]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concatenación para arrays con mismas dimensiones, en horizontal (añadimos columnas)\n",
    "np.hstack([a_2x10, a_2x2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos usar `stack()` para realizar la concatenación de una forma más generalizada (con más parámetros). Así mismo utilizaremos `dstack()` para concatenar en la tercera dimensión."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### División\n",
    "La operación contraria a la concatenación es la división, que llevaremos a cabo con `split()`, `hsplit()`, `vsplit()` y `dsplit()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0] [1 2] [3 4 5] [6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "a1, a2, a3, a4 = np.split(a, [1, 3, 6])\n",
    "print(a1, a2, a3, a4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[10,  1,  2,  3,  4,  5,  6,  7,  8,  9]]),\n",
       " array([[10,  1,  2,  3,  4,  5,  6,  7,  8,  9]])]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vsplit(a_2x10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2, 3, 4]), array([5, 6, 7, 8, 9])]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(a, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays de fechas\n",
    "\n",
    "NumPy añadió el *dtype* `datetime64` para contar con series temporales de forma nativa. Es una representación de las fechas como enteros de 64 bits, permitiendo que los arrays sean muy compactos, y las operaciones sobre ellos muy eficientes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array('2019-02-20', dtype='datetime64[D]')"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Inicialización de un array con una fecha\n",
    "dates = np.array('2019-02-20', dtype=np.datetime64)\n",
    "dates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La **[D]** que podemos ver entre corchetes es la unidad fundamental asignada por defecto para la entrada del ejemplo; en este caso ***Días***. Existen otros códigos que podemos indicar de forma explícita, y que nos condicionarán el intervalo de fechas representable (Y, M, W, D, h, m, s, ms, us, ns, ...)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2019-02-20T00:00:00.000000000')"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Resolución mayor\n",
    "np.datetime64('2019-02-20', 'ns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos crear una **serie temporal** fácilmente a partir del array previamente inicializado con una fecha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2019-02-20', '2019-02-21', '2019-02-22', '2019-02-23',\n",
       "       '2019-02-24', '2019-02-25', '2019-02-26', '2019-02-27',\n",
       "       '2019-02-28', '2019-03-01', '2019-03-02', '2019-03-03',\n",
       "       '2019-03-04', '2019-03-05', '2019-03-06'], dtype='datetime64[D]')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates + np.arange(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones universales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La clave para que las operaciones sobre arrays de NumPy sean eficientes es usar **operaciones vectorizadas**; aquellas que ejecutadas sobre un vector son aplicadas sobre cada elemento. Este tipo de operaciones están implementadas en NumPy a través de sus funciones universales (**ufuncs**).\n",
    "\n",
    "Distinguimos 2 tipos de ufuncs: ***unarias*** (una entrada) y ***binarias*** (dos).\n",
    "\n",
    "Cada vez que veamos un bucle que actúa sobre los elementos de una colección deberíamos considerar la opción de sustituirlo por una operación vectorizada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con array y escalar, usando el operador universal de división\n",
    "b = a / 10\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con 2 arrays, usando la suma\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos mejorar el rendimiento de una operación especificando el array de salida de la misma en el parámetro `out`, en lugar de hacer una asignación; de esa manera nos ahorraremos la creación de un array temporal y la copia de sus elementos al array final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  0.,  2.,  0.,  4.,  0.,  8.,  0., 16.,  0.])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "y = np.zeros(10)\n",
    "np.power(2, a[0:5], out=y[::2]) # más eficiente que y[::2] = np.power(2, a[0:5])\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> La documentación de todas las funciones universales disponibles se puede consultar [aquí](https://numpy.org/doc/1.17/reference/ufuncs.html?highlight=ufuncs#available-ufuncs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones aritméticas\n",
    "Todas las operaciones aritméticas nativas de Python están soportadas por NumPy, y se pueden escribir de dos formas (si usamos la primera, internamente se aplicará la de NumPy al haber arrays de por medio):\n",
    "\n",
    " * `+` = `np.add()`\n",
    " * `-` = `np.subtract()`\n",
    " * `-` = `np.negative()`\n",
    " * `*` = `np.multiply()`\n",
    " * `/` = `np.divide()`\n",
    " * `//` = `np.floor_divide()`\n",
    " * `**` = `np.power()`\n",
    " * `%` = `np.mod()`\n",
    " \n",
    "Si queremos actualizar un array en lugar de crear uno nuevo, podemos imitar la sintaxis de Python para actualización de variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  1.,  4.,  3.,  8.,  5., 14.,  7., 24.,  9.])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ejemplo\n",
    "y += a\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones comparativas\n",
    "\n",
    "Con NumPy disponemos también de los operadores de comparación optimizados:\n",
    "\n",
    " * `<` = `np.less()`\n",
    " * `>` = `np.greater()`\n",
    " * `<=` = `np.less_equal()`\n",
    " * `>=` = `np.greater_equal()`\n",
    " * `==` = `np.equal`\n",
    " * `!=` = `np.not_equal()`\n",
    "\n",
    "Podremos comparar todos los elementos de un array con un escalar, o los elementos de 2 arrays uno a uno. El resultado en ambos casos será un **array booleano**, para los cuáles NumPy también tiene funciones útiles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False, False, False, False, False,  True,  True,  True,\n",
       "         True],\n",
       "       [ True, False, False, False, False, False,  True,  True,  True,\n",
       "         True]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x10 > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos aplicar **enmascarado** para seleccionar los elementos que cumplen cierta condición. Para ello usaremos los corchetes igual que en cualquier selección con índices, y pasaremos como parámetro un array booleano resultado de comprobar una condición:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  6,  7,  8,  9, 10,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x10[a_2x10 > 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones lógicas\n",
    "\n",
    "NumPy define los siguientes operadores lógicos para una comparación elemento a elemento de arrays booleanos. Si los elementos son enteros recordamos que 0 es False, y todos los demás números son True:\n",
    "\n",
    " * `np.logical_and()`\n",
    " * `np.logical_or()`\n",
    " * `np.logical_xor()`\n",
    " * `np.logical_not()`\n",
    "\n",
    "Define también los siguientes operadores lógicos a nivel de bit para una comparación elemento a elemento de arrays de enteros:\n",
    "\n",
    " * `&` = `np.bitwise_and()`\n",
    " * `|` = `np.bitwise_or()`\n",
    " * `^` = `np.bitwise_xor()`\n",
    " * `~` = `np.bitwise_not()` = `np.invert()`\n",
    " \n",
    "Si escribimos **and** y **or** estaremos usando los operadores de Python, a nivel de objeto (con arrays obtendríamos un error)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),\n",
       " array([-9, -8, -7, -6, -5, -4, -3, -2, -1,  0]),\n",
       " array([False,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        False]))"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# AND element-wise\n",
    "a, -a[::-1], np.logical_and(a, a[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# AND bit-wise\n",
    "np.bitwise_and(a, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones trigonométricas\n",
    "\n",
    " * `np.sin(x)` : seno\n",
    " * `np.cos(x)` : coseno\n",
    " * `np.tan(x)` : tangente\n",
    " \n",
    " \n",
    " * `np.arcsin(x)` : arco seno\n",
    " * `np.arccos(x)` : arco coseno\n",
    " * `np.arctan(x)` : arco tangente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones exponenciales y logarítmicas\n",
    "\n",
    " * `np.exp(x)` : e\\*\\*x\n",
    " * `np.expm1(x)` : e\\*\\*x - 1 # para x ~ 0\n",
    " * `np.exp2(x)` : 2\\*\\*x \n",
    " * `np.power(base, x)` : base\\*\\*x\n",
    " \n",
    " \n",
    " * `np.log(x)` : ln(x)\n",
    " * `np.log1p(x)` : ln(1 + x) # para x ~ 0\n",
    " * `np.log10(x)` : log10(x)\n",
    " * `np.log2(x)` : log2(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Otras funciones\n",
    " \n",
    " * `np.absolute(x)` = `np.abs(x)`\n",
    "  \n",
    " \n",
    " * `np.square()`\n",
    " * `np.sqrt()`\n",
    " \n",
    " \n",
    " * `np.diagonal()`\n",
    " * `np.floor()`\n",
    " * `np.ceil()`\n",
    " * `np.isfinite()`\n",
    " * `np.isinf()`\n",
    " * `np.isnan()`\n",
    " * `np.unique()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 0, 1, 2])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo valores absolutos de array de enteros\n",
    "np.abs(np.arange(-2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.41421356, 2.23606798, 1.        , 1.        ])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo valores absolutos de array complejo\n",
    "np.abs(np.array([1 - 1j, -1 - 2j, 1 + 0j, 0 + 1j]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos de las funciones universales\n",
    "\n",
    "Aparte de poder realizar operaciones de un array con un escalar, o de un array con otro array, podemos usar **operaciones entre los elementos de un mismo array**. \n",
    "\n",
    "Todas las funciones universales cuentan para ello con ciertos métodos predefinidos, que tendrán sentido o no dependiendo de la funcionalidad:\n",
    "\n",
    " * `<ufunc>.reduce(x)`: aplica la operación sobre 2 elementos, luego al resultado y al siguiente elemento, y así sucesivamente hasta reducir a un único valor.\n",
    " * `<ufunc>.accumulate(x)`: lo mismo que reduce() pero la salida es un array con todos los resultados parciales.\n",
    " * `<ufunc>.outer(x, y)`: aplica la operación específica a todas las combinaciones entre los elementos de un vector y los elementos de otro.\n",
    " * `<ufunc>.at(x, indexes)`: aplica la operación en los índices especificados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podremos aplicar cualquier ufunc binaria recursivamente elemento a elemento usando el método `reduce()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-45"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con la operación resta\n",
    "np.subtract.reduce(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si en vez de obtener un resultado final lo que buscamos es obtener un array con todos los resultados parciales, usaremos `accumulate()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,  -1,  -3,  -6, -10, -15, -21, -28, -36, -45], dtype=int32)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.subtract.accumulate(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo con `outer()` se suman los elementos 2 a 2, obteniendo una matriz con todas las combinaciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],\n",
       "       [ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10],\n",
       "       [ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11],\n",
       "       [ 3,  4,  5,  6,  7,  8,  9, 10, 11, 12],\n",
       "       [ 4,  5,  6,  7,  8,  9, 10, 11, 12, 13],\n",
       "       [ 5,  6,  7,  8,  9, 10, 11, 12, 13, 14],\n",
       "       [ 6,  7,  8,  9, 10, 11, 12, 13, 14, 15],\n",
       "       [ 7,  8,  9, 10, 11, 12, 13, 14, 15, 16],\n",
       "       [ 8,  9, 10, 11, 12, 13, 14, 15, 16, 17],\n",
       "       [ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.outer(a, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones no universales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones estadísticas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy cuenta con funciones agregadoras optimizadas para el estudio estadístico de los datasets. Son funciones del propio tipo array pero también se pueden invocar pasando el array como parámetro:\n",
    "\n",
    " * Suma: `x.sum()` = np.sum(x)\n",
    " * Máximo: `x.max()` = np.max(x)\n",
    " * Mínimo: `x.min()` = np.min(x)\n",
    " * Producto: `x.prod()` = np.prod(x)\n",
    " * Media: `x.mean()` = np.mean(x)\n",
    " * Desviación: `x.std()` = np.std(x)\n",
    " * Varianza: `x.var()` = np.var(x)\n",
    " * Índice máximo: `x.argmax()` = np.argmax(x)\n",
    " * Índice mínimo: `x.argmin()` = np.argmin(x)\n",
    " * Mediana: `x.median()` = np.median(x)\n",
    " * Percentil: `x.percentile(percentage)` = np.percentile(x, percentage) _# x.percentile(50) = x.median()_\n",
    " * OR: `x.any()` = np.any(x)\n",
    " * AND: `x.all()` = np.all(x)\n",
    " \n",
    "Existe una versión segura de cada función (menos de las dos últimas), usando el prefijo `nan` (ejemplo: `nanmin`). Dichas funciones ignorarán los valores no válidos, representados por el valor **NaN**.\n",
    " \n",
    "NOTA: hay que tener cuidado de escribir `np.` delante si no estamos usando la función propia del array, o se ejecutará la función nativa de Python.\n",
    " \n",
    "Estas funciones son aplicables a arrays de cualquier dimensión, usando parámetros añadidos. El parámetro `axis` nos servirá para aplicar la función verticalmente a lo largo del eje de las filas (axis=0) u horizontalmente a lo largo del eje de las columnas (axis=1). Siendo el elegido el eje 0, lo que le estamos indicando es que la operación se aplique avanzando a lo largo del eje que forma la sucesión de filas, haciendo que la dimensión del resultado sea la de 1 fila."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  1],\n",
       "       [10,  1]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "a_2x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10.,  1.])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operación aplicada verticalmente en el eje de las filas\n",
    "a_2x2.mean(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 5.5])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operación aplicada horizontalmente en el eje de las columnas\n",
    "a_2x2.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0], dtype=int64)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2x2.argmax(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones para arrays booleanos\n",
    "\n",
    " * `np.count_nonzero(x)` : cuenta los *True* del array. Equivale a `np.sum(x)` porque True = 1 y False = 0.\n",
    " * `np.count_nonzero(x, axis=n)` : cuenta los True del array resultante de agregar x en el eje n (0: filas)\n",
    " * `np.any(x [,axis=n])` = OR\n",
    " * `np.all(x [,axis=n])` = AND"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones para matrices\n",
    " * `np.dot()`: producto de matrices con unas reglas de broadcasting específicas\n",
    " * `np.matmul()`: producto de matrices, con la misma implementación de Python (operador `@`, disponible desde Python 3.5)\n",
    " * `np.transpose()`: matriz transpuesta (equivale a `.T`)\n",
    " * `np.linalg.det()`: determinante de la matriz\n",
    " * `np.linalg.inv()`: matriz inversa (existente si su determinante no es nulo)\n",
    " * `np.linalg.norm()`: norma de la matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "285"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo producto\n",
    "np.dot(a, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Producto tensorial y Producto vectorial\n",
    "En el caso de usar el método `outer()` de la ufunc `multiply` obtenemos el **producto tensorial**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0],\n",
       "       [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],\n",
       "       [ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18],\n",
       "       [ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27],\n",
       "       [ 0,  4,  8, 12, 16, 20, 24, 28, 32, 36],\n",
       "       [ 0,  5, 10, 15, 20, 25, 30, 35, 40, 45],\n",
       "       [ 0,  6, 12, 18, 24, 30, 36, 42, 48, 54],\n",
       "       [ 0,  7, 14, 21, 28, 35, 42, 49, 56, 63],\n",
       "       [ 0,  8, 16, 24, 32, 40, 48, 56, 64, 72],\n",
       "       [ 0,  9, 18, 27, 36, 45, 54, 63, 72, 81]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Por defecto, equivalente a np.multiply.outer()\n",
    "np.outer(a, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con la función `cross()` obtendremos el **producto vectorial**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cross([0,1,0], [0,0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones especializadas\n",
    "NumPy tiene muchas más funciones para todo tipo de operaciones matemáticas, como por ejemplo `elliptic`, `bessel`, `gamma` o `beta` (ver [documentación](https://docs.scipy.org/doc/numpy/reference/)). Y si queremos alguna función más específica, es muy posible que la podamos encontrar disponible en el módulo `scipy.special` (ver [documentación](http://scipy.github.io/devdocs/tutorial/special.html))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "special.gamma(b) = [       inf 9.5135077  4.59084371 2.99156899 2.21815954 1.77245385\n",
      " 1.48919225 1.29805533 1.16422971 1.0686287 ]\n",
      "special.erf(b) = [0.         0.11246292 0.22270259 0.32862676 0.42839236 0.52049988\n",
      " 0.60385609 0.67780119 0.74210096 0.79690821]\n"
     ]
    }
   ],
   "source": [
    "from scipy import special\n",
    "\n",
    "#Ejemplos\n",
    "print('special.gamma(b) =', special.gamma(b))\n",
    "print('special.erf(b) =', special.erf(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rutinas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> La documentación de las rutinas o procedimientos más habituales se puede consultar  [aquí](https://docs.scipy.org/doc/numpy/reference/routines.html#routines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El primer motivo que vimos para vectorizar operaciones era evitar el uso de bucles. El segundo motivo es usar la funcionalidad de broadcasting de NumPy.\n",
    "\n",
    "El broadcasting es simplemente un conjunto de reglas para aplicar ufuncs binarias sobre arrays de distintos tamaños, donde las operaciones no pueden aplicarse elemento a elemento de forma directa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12,  2],\n",
       "       [12,  2]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo: suma de un array (2,2) y otro (2)\n",
    "a_2x2 + np.array([2, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el anterior ejemplo, podemos pensar que el array (2) ha sido \"difundido\" (broadcasted) para conformar una matriz (2,2). \n",
    "\n",
    "Las **reglas** del broadcasting en NumPy:\n",
    "\n",
    "1. Si los 2 arrays difieren en el nº de **dimensiones**, se amplían las del pequeño, añadiendo un 1 a la izquierda\n",
    "```\n",
    "a : (3, 1)\n",
    "b : (3) -> (1, 3)\n",
    "```\n",
    "2. Si en alguna dimensión los 2 arrays difieren en el nº de elementos, y el array con menos elementos tiene **exactamente 1**, se difunde hasta igualar el tamaño del otro. Si éste fuera mayor de 1 obtendríamos un error.\n",
    "```\n",
    "a : (3, 1) -> (3, 3)\n",
    "b : (1, 3) -> (3, 3)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2]\n",
      "\n",
      "[[0]\n",
      " [1]\n",
      " [2]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [1, 2, 3],\n",
       "       [2, 3, 4]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "a_3 = np.array([0, 1, 2])                   # (3)\n",
    "a_3x1 = np.array([0, 1, 2])[:, np.newaxis]  # (3, 1)\n",
    "\n",
    "print(a_3)\n",
    "print(\"\")\n",
    "print(a_3x1)\n",
    "\n",
    "a_3 + a_3x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "operands could not be broadcast together with shapes (2,2) (3,) \n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de error\n",
    "try:\n",
    "    a_2x2 + a_3\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexado múltiple\n",
    "\n",
    "El indexado múltiple (o *fancy indexing*) no es otra cosa que indexar múltiples elementos de un array usando un array de índices en lugar de un sólo índice escalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo: array unidimensional. En este caso podemos pasar una lista en lugar de un array\n",
    "indices = [0, 2, 4]\n",
    "a[indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo: array unidimensional. La salida tendrá el mismo formato que el array de índices\n",
    "indices = np.array([[0, 1], [8, 9]])\n",
    "a[indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para arrays bidimensionales, tendremos que especificar 2 parámetros separados por coma (filas, columnas). Podremos usar 2 arrays de índices (siendo aplicable el broadcasting), 1 array y un escalar (para seleccionar sólo una fila o una columna), 1 array y slicing (para seleccionar un rango), o 1 array y 1 array booleano (enmascarado). La salida tiene la misma forma que dicten las reglas de broadcasting sobre los arrays de índices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de datos de partida\n",
    "a_4x4 = np.arange(16).reshape(4, 4); a_4x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  5, 10, 15])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de indexado con 2 arrays de entrada\n",
    "filas = [0, 1, 2, 3]\n",
    "columnas = [0, 1, 2, 3]\n",
    "a_4x4[filas, columnas]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4,  8, 12],\n",
       "       [ 1,  5,  9, 13]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de indexado con broadcasting. La salida tiene la misma forma que el broadcasting de los índices.\n",
    "filas = [0, 1, 2, 3]\n",
    "columnas = np.array([0, 1])[:, np.newaxis]\n",
    "a_4x4[filas, columnas]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1],\n",
       "       [ 4,  5],\n",
       "       [ 8,  9],\n",
       "       [12, 13]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de indexado con masking\n",
    "filas = np.array([0, 1, 2, 3])[:, np.newaxis]\n",
    "columnas = np.array([1, 1, 0, 0], dtype=np.bool)\n",
    "a_4x4[filas, columnas]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El indexado múltiple se puede usar tanto para obtener parte de un array, como para modificarlo por asignación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11,  2,  3,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con índices repetidos\n",
    "a_copy = np.copy(a)\n",
    "indices = [0, 1, 0, 1] # no importan los duplicados\n",
    "a_copy[indices] += 10\n",
    "a_copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si lo que quisiéramos en realidad es que se aplicara la suma al elemento tantas veces como aparezca en los índices podemos lograrlo usando el método `at()` de las ufuncs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.add.at?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 31,  2,  3,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.at(a_copy, [0, 1, 0, 1], 10)\n",
    "a_copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ordenación de arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy ofrece funciones para ordenar los elementos de un array de forma mucho más eficiente que las funciones `sort` y `sorted` de Python para listas. Las funciones de NumPy son:\n",
    "\n",
    " * `np.sort(x [, index=i])` : devuelve una versión ordenada del array de entrada, usando un algoritmo quicksort O[N logN] por defecto. También tenemos disponibles `mergesort()` y `heapsort()`.\n",
    " * `np.argsort(x [, index=i])` : devuelve un array con los índices de los elementos ordenados\n",
    " * `np.partition(x, k [, index=i])` : devuelve los k primeros valores agrupados a la izquierda (sin orden), y el resto a la derecha (sin orden)\n",
    " * `np.argpartition(x, k [, index=i])` : devuelve un array con los índices de los elementos agrupados\n",
    " * `np.shuffle(x)`: devuelve una versión desordenada del array de entrada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 9])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de ordenación de elementos\n",
    "np.sort(np.array([3,7,6,9,5,1,2,4,0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 0], dtype=int64)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de obtención de índices de ordenación\n",
    "np.argsort(np.array([3,2,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 1 4 9]\n",
      " [8 1 1 7]\n",
      " [9 9 3 6]\n",
      " [7 2 0 3]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[4, 1, 0, 3],\n",
       "       [7, 1, 1, 6],\n",
       "       [8, 2, 3, 7],\n",
       "       [9, 9, 4, 9]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de ordenación con 2 dimensiones\n",
    "r = np.random.randint(0, 10, (4, 4))\n",
    "print(r)\n",
    "np.sort(r, axis=0) # 0: por columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 2, 3, 7, 9, 6, 4, 5])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de agrupación\n",
    "np.partition(np.array([3,7,6,9,5,1,2,4,0]), 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo: KNN (K-Nearest Neighbours)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set() # styling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Necesitamos unas muestras para el ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generamos 15 muestras aleatorias de puntos en 2D\n",
    "np.random.seed(42)\n",
    "data = np.random.rand(15, 2)\n",
    "\n",
    "# Los pintamos\n",
    "plt.scatter(data[:, 0], data[:, 1], s=100);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calcularemos la distancia cuadrática de cada par de puntos como la suma de los cuadrados de las distancias.\n",
    "Primero calculamos para cada par de puntos la diferencia entre sus coordenadas. Usamos broadcasting!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15, 15, 2)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "differences = (data[:, np.newaxis, :] - data[np.newaxis, :, :]) # (15, 1, 2) - (1, 15, 2)\n",
    "\n",
    "# Comprobamos la pinta del array\n",
    "differences.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_dist = np.sum(differences ** 2, axis=-1) # sobre el último eje\n",
    "\n",
    "# Comprobamos la diagonal!\n",
    "square_dist.diagonal()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obtenemos los 2 vecinos más cercanos usando `argpartition`, y representamos todas estas relaciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD7CAYAAAB+B7/XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3deXhMZ/vA8e/MJJOFICILiiKWIkERa23VBCXW2oqqVqm1+vb9aVFaqmiLakurumhr3xq0xFq0EmJrNrtYQmSRxJLNJDPn90deIcJMMMlMkvtzXb2amTlz5p7bmXueec5znkelKIqCEEKIYkNt6QCEEEKYlxR2IYQoZqSwCyFEMSOFXQghihkp7EIIUcxIYRdCiGJGCrsQQhQzNpYOACA5ORWDIf/D6V1cSpOYmFKAERV9kiPjJD/GSX5Ms2SO1GoVzs6lHvm4VRR2g0F5rMJ+9znCOMmRcZIf4yQ/pllrjqQrRgghihkp7EIIUczkq7CnpKTQrVs3rly5kuexkydP0rt3b/z8/JgyZQpZWVlmD1IIIUT+mSzsoaGhDBw4kIsXLz708f/+979MmzaN7du3oygKa9euNXeMQgghHoPJwr527VqmT5+Om5tbnseuXr1KRkYGjRo1AqB3794EBgaaP0ohhBD5ZnJUzKxZsx75WHx8PK6urjm3XV1diYuLe+wgXFxKP/ZzXF2dHvs5JY3kyDjJj3GSH9OsNUdPNdzRYDCgUqlybiuKkut2fiUmpjzWsCFXVycSEm7nui8+OY3tIdEER8aSodNjr9XQsr4Hfj5VcHN2fOyYirqH5UjcI/kxTvJjmiVzpFarjDaIn6qwe3h4kJCQkHP7+vXrD+2yKWhh5xNZHBCOXq+g/98XRIZOz/7QGA5EXGN0Ty+8a7oUelxCCGEJTzXcsXLlytjZ2XH06FEANm3aRNu2bc0SWH7FJ6exOCAcXaYhp6jfpTco6DINLA4IJz45rVDjEkIIS3miwj5ixAjCw8MB+OKLL5g9ezadO3cmLS2NoUOHmjVAU7aHRKPXG+/G0esVdhyOLqSIhBDCsvLdFbNnz56cv5cuXZrzd926dVm/fr15o3oMwZGxuVrqF47/iV0pZ2ztSqGxsUWt0aK2sWXn37F0bFAardYOe3s77OzssbGxeaJzAsL6yDkWIe6xirlinkaGTp/rduRfSx+xJWxbkvu2Wq3G3t4eOzs7tNrsYn+36NvZ2WFvb49Wq33gfnvs7LS5trGzu/ecu3/fv5/7H39we41GUxBpKVHkHIsQuRX5wm6v1eQq7mU9anEz9ixVvHypVLsVhiwden0WNmQxoGN17tzJICPjDnfuZKDT3cn5+86dO2RkZP8/+/7sv1NTU8jIyL7v/m2yn6976vhtbGyMfhHc/5hWq831xfDwL57sLw9X13JkZBjytX1R/tVy/zmWB+kN2YV+cUA4M4b7SMtdlBhFvrC3rO/B/tCYnJZa897T2fndMK5E7KZO60HYO5ZDo1bRrlElBvvWMetrGwwGdDpdri+Lu8X/YV8E2ffnf/u7/79162bO8+998WQ/Zo4pHO79YrF74IvgwftN/ZKxy/nP9C+Ze798bG1tn/jL5XHOsZj7318Ia1XkC7ufTxUORFzLKexa+9LUa/c6kX8t5fDvM3nh1XloNCp8m1Ux+2vf7cqxt7enbFmz7z5fsrKycv2CuFv8HR01XLuWZOSXSe7tjf2SSUlJITEx8YH77+1LUZ5u6lKVSvXIL4L7vyTuPz9y90tiX1g8ekWDPjONtFvXSbl+Ga9Oo6lQtUHO/vUGheCIWCnsosQo8oXdzdmR0T29cvWxVm/8MpdCA7kZd55rp/Yy98MJxfZnuI2NDTY2NpQqlXvS/cK6eEJRlP99uWQ8UPQf/GVy9wvkYb9M7m3/8F8td7hxI5nU1FRu3LhBamoKd+7cISsr66FfKoc2TOelUcvQOty7KvDBczFCFGcq5WmbW2ZgritPdxyOJjgie1SEIT2Jrd+9ia3WljOnL+HoWDwL+6MU1SsHdTodR46EcOhQMGFhoURFnePatWvcvn0LvT53cVarNWi0Dmgdy1GqXEWcXKqSkhxD3Llg7Eo58+IbS1DbaAFw0GpY9G67nOcW1fwUFsmPacX2ylNr4ubsyGDfOrl+bs/SRrJw4TyGDRvE2rUBFoxOPOj8+XMcOPA3x48f5fTpU1y5Ek1SUhI63Z082zo6OlKpUmWqVXuWevUa0KRJM9q0aYurqyu/bT+d6xwLwOFNs4k7f4h/Vk+i7eAFaNQqWjbwKMy3J4RFFZsW+6M0bFiXa9diWLNmIx06dHrSEIsca2hx3bhxg+DgA4SEHOTEiQguXrxAfHw8aWmpebpQbG1tcXZ2plKlZ6hduw6NGjWmVau21K1bF7X60dfRxSenMe2nkDyjYvb/NpFbCRdw92xO6z5T8oyKsYb8WDPJj2nSYreglSvX06FDa0aMGMapUxexsSn2b7lQZWVlERp6nKCgfwgLC+XcuTNcuxbDzZu30Otzj9hRq9WULu2Ep2ctatTwpEGDBjRv3gofnxZP3FX2sHMsAG0GzmX3jyOJO3cI26t/4ubc/mnfqhBFRrFvsQOMGzeKNWtW8sorA1i06PsnCbHIMXdr4urVaPbv38vRo0c4ffoU0dGXSUpKJCMjI8+2Dg4OuLi4UKVKNerWrUfTps144YV2eHhUNFs8D3rwHIu9VoNXVXvmvNeDtLQ05s//isGDh+VsLy1S4yQ/pllzi71EFHaDwUCdOtW4efMmu3btx9u70ZOEWaQ8yUGXkpLCwYNBHDoUTGRkBBcunCc+Pp6UlNt5uk5sbGwoW7YclSpVplat2jRs2JjWrdvQoIG30a6TwnbmzGnat2+JXq9n/frNvPBC9glUKVzGSX5Mk8JuQkEXdoC9e/fQr19PPDwqEhZ2+nFDLHIelSODwUBERBgHDvxDaOhxzp7N7jq5cSM5z8VOKpWK0qWdcHNzo3r1mtSv34DmzVvSokUrSpd+/MVRLOWvv3YxYEAfbGxs2LfvIJ6etaRwmSD5MU0KuwmFUdgBBgzozZ49uxgzZgLTp8987OcXJZmZtwkI+JNjx45w4kQk0dGXSUy8Tnp6ep5t7e3tKV/ehSpVqlKnTl2aNGlKmzZtqVKlmgUiLxg///wjkyZNpHTp0hw9GkHt2tWkcBkhhd00KewmFFZhz8jIoHbtauh0dzh8OLTIF66MjAwOHgwiJOQg4eFhXLhwntjYWFJSbmMw5B4lotHYULZsGSpWrETNmrVo2LARrVq1oWHDxiXmhPL06ZP59ttvqFixEpcvXyI5Oe+XnMgmhd00KewmFFZhB9iwYQ1vvz2CWrVqc+DAkSfaR2EyGAycOnWK4OB/OH78KGfOnCYm5grJyclkZmbm2lalUuHoWAo3Nzdq1fKkVq3n8PFpQcuWrSlXrpyF3oF1GTy4Pzt2bKNJkyZs2/aXpcOxWlLYTZPCbkJhFnYAP78OHD9+lE8+mctbb739xPsxp8TE6/zzz34OHw7h5MlILl26yPXrCaSl5V35Sau1o3z58jzzTBXq1KlL48ZNaN36BWrW9MzZRj6YD2cwGOjYsTUnTkTSvXtPfvzxV0uHZJXk+DFNCrsJhV3YExOv4+VVG5VKRUTEWZydyz/xvh7H3cvlDx4MIizsX6KizhMbe43bt2/nuVxeo9Hg5FSGihUrUqOGJ97eDWnevCVNm/qg1WpNvpZ8MB9Np9PRtGkDYmNjeeed95g8eZqlQ7I6cvyYZs2FvWR0rj7AxaUCkydPZ8aMD/F9uTvN+n5q1lV3zp8/xz//7OfYsaOcOZN9uXxycvIjL5d/5pkqVK1ajfr1G9C0aXNat26Di0uFp3mLwgitVktoaCjVq1fnyy+/oEaNmgwY8KqlwxLCbEpkix2yV93p0bUVqcnXeP7l96hUpw0AGrUKjUZlctWdGzducODA34SEHOLkyezL5RMSEh5xubwWZ2dnKlfOvly+ceMmtGrVhtq16xTYmG9pcRnn6urEvn2HePHFNhgMejZu/IPWrV+wdFhWQ44f06y5xV4iC/vd+UWS46/y18+j0dhoeWn0b9jY3Ovi0NqqmTb0ea5ePElw8IH/XS5/ltjYGG7evPmQmQbVODk54e5ekRo1auDl1RAfnxY0b94Se3v7J471SckH07i7+dm9eyeDBvXFxsaGf/45TPXqNSwdmlWQ48c0ay7sJbIr5u6qO6WcK1K98ctcOP4HQasmUc6jFrcTo0m/FY8u/RYb52bmea6DgwOVKlWmSpWq1KtX/39jvtvj7u5ugXcintaLL77Ep59+zgcfvEenTi9w9GikjCASRV6JLOzBkbE5k0U91244l8J3cCvhArcSLgCgUmuwtS9NKacKvPhCUxo2bETr1i9Qr14Dq7pcXpjHG2+8RVTUOZYu/Y4OHVpx+HBYiRnbL4qnEnn03r+ajlqtpu3gLzl7aB2V675A+cr1sNFmd52ogMXvd7RQlKIwzZr1GVFR59m9eyfduvkSGLjH0iEJ8cRKZPPTXqvJdbt0+Uo07jIBt+rP5xT1h20nircVK9ZRu3Zdjh07wsiRwy0djhBPrEQW9pb1PdCoVUa3kVV3Sh61Ws2uXfupUMGV339fz9y5n1g6JCGeSIks7H4+VdBoTBR2jQrfZlUKKSJhLezt7fnrryAcHByYN+8z1q5daemQhHhsJbKw3111R2urztNy16hVaG3VjO7p9VQXKYmiy93dna1bd6PRaBg3bjQHDwZZOiQhHkuJLOwA3jVdmDHch3aNKuGg1aAieyX7do0qMWO4j9GLk0TxV79+A37+eQWKotC3rz+XLl20dEhC5FuJvECpJJAcGZff/Hz//bdMnTqJMmXKcOzYCcqUKVMI0VmeHD+mWfMFSiW2xS5Efrz11tu8/voIbt26RYcOrfLMcy+ENZLCLoQJc+fOo337jkRHX6Z7dz9LhyOESfkq7Fu2bKFr1674+vqyYsWKPI9HRkbSp08f/P39GTlyJLdu3TJ7oEJY0urVG/H0rM3hw4cYPXqEpcMRwiiThT0uLo4FCxawcuVKAgICWLNmDefOncu1zaxZsxg/fjybN2+mevXq/PjjjwUWsBCWoFar2bPnH8qXd2H9+jXMmzfH0iEJ8UgmpxQICgqiRYsWORMj+fn5ERgYyNixY3O2MRgMpKamApCenk7ZsmULKFwhLMfe3p69e4Pw8WnE3Lmf4uJWBY1bU4IjY806n78QT8tkiz0+Ph5XV9ec225ubsTFxeXa5v3332fq1Km0adOGoKAgBgwYYP5IhbACHh4V+eOP7ajVGv7vvdH8vm1PztxDGTo9+0NjmPZTCGHnEy0cqSjJTLbYDQYDKtW9i3gURcl1OyMjgylTprBs2TK8vb35+eefmTRpEt9//32+gzA2bOdRXF2dHvs5JY3kyLgnzU+9hs/TvMf7BP8+i6A1U2k/7Bscy2ZP26w3KOgNCt8GRPD1ex2oWKGUOUMuVHL8mGatOTJZ2D08PDhy5EjO7YSEBNzc3HJunzlzBjs7O7y9vQHo378/CxcufKwgZBy7+UmOjHua/Kzafhq3mj4813YYJ/cvY//yd+k0Yik22nvdL1l6A6u3n2Swbx1zhVyo5PgxrUiPY2/VqhXBwcEkJSWRnp7Ojh07aNu2bc7j1apVIzY2lqioKAB2796Nl5eXGUIXwjrdnc+/ZtOeVPXyJetOKoGLBhO281vupGd/0PUGheCIWAtHKkoqky12d3d3Jk6cyNChQ8nMzKRv3754e3szYsQIxo8fj5eXF7Nnz+add95BURRcXFz49NNPCyN2ISzi/vn8vV8aTWzUYXSpyVwO387l8O3YaB1wrd6EWj59gXaWC1SUWDKlQDElOTLuafIzev6+XMUdIOVGHCf++p7rl8Mw6O8tqWhnZ0ezZs0ZMuR1evToVWRW4JLjxzRr7oqRwl5MSY6Me5r8/Lb9NPtDY3KWV3zQjbgozgSt4PrlUAz6rJz71Wo1tWrVpmfP3rzxxiirXltVjh/TrLmwF43mgxBWxNR8/uXca9Cm33SO/hvFzz+voGXLVkD2CLPTp08xd+6n1K5dlQYNajFu3CgiIyMKK3RRQkhhF+Ix5Xc+/8ru5Xj55e5s2hRIePgZPvxwBs8+Wx0AlUpFQkI8a9aspEOHVjz7rAe9e3fj9983yERj4qlJV0wxJTkyzhz5iU9OY8fhaIIj7rvytIEHvs0efeWpoigcORLCqlXL2bBhHenpadjb26PX68nMzO6bV6s1eHrWokePXowY8bZFumzk+DHNmrtipLAXU5Ij46whP6mpqfzxxyZWrVpOUNA/QPaVrenp6dy8eSNnOzc3N9q3f5FRo8bQoIF3ocRmDfmxdlLYTZDCbn6SI+OsLT8XLkSxZs0K1qxZxdWrVyhbtiw1a9YiKSmR6OjL6PXZo3AcHBx5/vkmDBkyjJ49+xTYKBtry481ksJughR285McGWet+dHr9ezfv5dVq35j27Y/uXPnDvXqNaBhw4ZcunSR0NB/cybcU6vVeHrWwt+/FyNGjMLZubzZ4rDW/FgTKewmSGE3P8mRcUUhP8nJSWzcuJ7Vq1cQGnocrVaLn19X2rR5gePHj7F37x5iY6/lbO/m5ka7dh15++2xT91lUxTyY2lS2E2Qwm5+kiPjilp+IiMjWL16OevWrSYpKYmKFSvRr99Aunfvwe7dOwkI2MCZM6fzdNkMHjyUXr1eeewum6KWH0uQwm6CFHbzkxwZV1Tzo9Pp2L59G6tXL2f37p0YDAaaN2/JoEFDePllf/bv/4tffvmJI0dC8nTZdO/eg7feGm20yyY+OY3tIdEcPBFH+p0smWPeCCnsJkhhNz/JkXHFIT+xsddYu3Y1q1b9xvnz53B0LEWPHr0YOHAIzZu34PTpUyxZsojdu3fm6rJxdXWjffuOjBw5Gm/vRjn3h51PZHFAOHq9kuuqWo1ahUajYnRPL7xruhTqe7RmUthNkMJufpIj44pTfhRF4fDhEFat+o2AgI2kpqZQo0ZNBg4cTL9+A6lYsRK3bt3ip5+WEhCwntOnT93XZeNA48ZN6N5zAIcSniFL/+jX0dqqmTHcR1ru/yOF3QQp7OYnOTKuuOYnJSUlZ2x8cPAB1Go1HTq8yMCBg/Hz64qdnR0Gg4Ft2/7kl19+5PDhEFJTU7KfrFJR2rkyFWu3onqjbmgdy+Tat0atol2jSkV2jnlzk8JughR285McGVcS8hMVdZ41a1awevVKrl2LwdnZmb59+zNgwGC8vO6Nmjlz5jSDx0zh2vkj3ElJyrnfvnQFGnWeQIWq99ZXcNBqWPSuTEUMUthNksJufpIj40pSfvR6Pfv2/cWqVcvZtu0PdDodXl4NGTjwVXr3foXy5V0YPmcPALqMNC6G/sn5kA3oMzMAcCjjynNtX6dS7VaogB/f72jBd2M9pLCbIIXd/CRHxpXU/GSPjV/HqlUrCAv7F61WS5cu3Ui086ZsJS9Uak3OtjfjzhO261tuxp0DQOtQlvovDGL78rmWCt+qSGE3QQq7+UmOjJP8QHh4GKtXL2fDhrUkJSVh7+TCM891oEr9FynlXDFnu9QbcYTvXMT16HBAwcnJiVGjxvKf/0wqMguHFAQp7CZIYTc/yZFxkp977ty5w7qNAcxduIS4C8dAMVC+cn2qNOhIxVqtsNE6AGDQ3UJ3Zg1/7Q5Er9djZ2fP4MFDmT79E+zt7S38LgqfFHYTpLCbn+TIOMlPXmHnE5n3214uhu/hcvhuUm/EoLG1p3KdNlRv2ImpY/rR0LMCaWlpTJnyf6xbtxqdToeNjQ3+/r2YM2eeVa8KZW5S2E2Qwm5+kiPjJD8PlzPHfGQsV6PCiTn5FzGn/0F3J52aNT1zxsZ7eFQkKyuL2bNn8uOPS0hLS8sZWjlv3ldUqlTZ0m+lwElhN0EKu/lJjoyT/Bh3f35SUlLYsiWAVauWc/BgEGq1mo4dOzFw4BD8/LpgY2PDd999w5dfzuPGjWRAhY9Pc774YiF16z5n2TdSgKy5sJfcMx9CiHwpXbo0AwcOZvPmQA4ePMb48e8SERHOG28MoWHDOkyb9gFt23bgzJlLfPPNd3h4eBAScpC2bZvTvn1LDh4MsvRbKHGksAsh8q1GDU8mT57G8eMnWLVqPa1bt2XZsh/p2LE1nTq15fbtFPbtC2bVqg3UqFGTEyci8ffvTLNm3mzb9qelwy8xpCummJIcGSf5Me5x8pOUlMjGjetYuXI5ERFhaLVaunbtxsCBQ3BycmLSpP8QHh4KZM8Z//77Uxk8eFgBRl84rLkrRgp7MSU5Mk7yY9yT5ic8PPR/C3WvJTk5mUqVKjNgwCBatWrDvHmfcfBgEIqiUKZMWcaMGc+ECf8psmPhpbCbIIXd/CRHxkl+jHva/Ny5c4ft27eycuVv7N27B4PBQKtWbejatTv79u3JmUvewcGB114bztSpH6PVas34DgqeFHYTpLCbn+TIOMmPcebMT0zMVdauXcWqVcu5cCGK0qWd6Nq1G0lJiezb9xeZmZnY2trSq1dfPv30c8qUKWN6p1ZACrsJUtjNT3JknOTHuILIj6IoHDoUzMqVv7F5cwBpaanUqOGJq6sroaHHycjIQK1W89JLnfnii4W4u7ub9fXNzZoLe9Hs3BJCFDkqlYoWLVrx1VffEhFxhi+/XISrqyuHDgWj0+nw9KyFvb0927dvxdu7Nv7+nTl37qylwy6SpLALIQpd6dJODBo0hC1bthMcfJSxY98hJSWFtLQ0HB1L4eDgwMGDQbRq1YSOHVtz9OhhS4dcpEhhF0JYVM2atZg69SOOHYtk5cp1vPjiS2RmZgKg1WqJiAinS5cXad68Mbt27bBwtEWD9LEXU5Ij4yQ/xlk6P4mJiWzcuJYVK37jxIkIVCoVd0uVu7sHH374Ef36Dcr1nPjkNLaHZM9zk6HTY6/V0LK+B34+VQpknVZr7mPPV2HfsmUL3377LVlZWbz22mu8+uqruR6Piopi+vTp3Lx5E1dXV+bPn0/ZsmXzHaQUdvOTHBkn+THOWvKjKErO2Pg1a1aRknIvJienMkyc+F9Gjx5HxIVkFgeEo9cr6O+rJRq1Co1GxeieXnjXdDFrbNZc2E12xcTFxbFgwQJWrlxJQEAAa9as4dy5czmPK4rC22+/zYgRI9i8eTPPPfcc33//vXmiF0KUaCqVCm/vRsye/QUnTpxn6dJltGzZGoDbt28xY8aHVKnixshx75BxR5erqAPoDQq6TAOLA8KJT06zxFuwCJOFPSgoiBYtWlCuXDkcHR3x8/MjMDAw5/HIyEgcHR1p27YtAKNGjcrTohdCiKdlb29Pjx692bRpG8ePn2DixP9SqlRpMjN1nD+yia0LXyEk4BMy7+Qt4Hq9wo7D0RaI2jJMFvb4+HhcXV1zbru5uREXF5dz+/Lly1SoUIHJkyfTq1cvpk+fjqOj+fuzhBDirsqVn+GDDz4kKuoqL/SfQSnnZ0BRiI86wvZFgwjbuTjX9nqDQnBErIWiLXw2pjYwGAyoVKqc24qi5LqdlZVFSEgIy5cvx8vLiy+//JI5c+YwZ86cfAdhrK/oUVxdnR77OSWN5Mg4yY9xRSU/5Sp70+H1b9BlpBIauJD4i0e5GR+VZ7uMTL3Z35O15shkYffw8ODIkSM5txMSEnBzc8u57erqSrVq1fDy8gKgW7dujB8//rGCkJOn5ic5Mk7yY1xRyo+dVkOGTo/WvhTNek5+5Hb2thqzvqciffK0VatWBAcHk5SURHp6Ojt27MjpTwdo3LgxSUlJnDp1CoA9e/ZQv359M4QuhBCmtazvgUatMrqNRq2iZQOPQorI8ky22N3d3Zk4cSJDhw4lMzOTvn374u3tzYgRIxg/fjxeXl4sWrSIqVOnkp6ejoeHB5999llhxC6EEPj5VOFAxLU8I2Lup9Go8G1WpRCjsiy5QKmYkhwZJ/kxrqjlJ+x8ooxjv4/JFrsQQlg775ouzBjuw47D0QRH3HflaQMPfJsVzJWn1kwKuxCiWHBzdmSwbx0G+9axdCgWJ5OACSFEMSOFXQghihkp7EIIUcxIH7soUIU9laoQQgq7KEAPG4KWodOzPzSGAxHXCmQImhBCCnux8WDL2MHOhhb13C3WMo5PTmNxQDi6TEOex/SG7EK/OCCcGcN9pOUuhJlJH3sxEHY+kWk/hbA/NIYMnR6A9DtZ7A+NYdpPIYSdTyz0mLaHRKPXG7/orKRNpSpEYZEWexFnDS3jrKws4uPjuHYthvj4eOLj41i2+TCpKTfJzEghMyOF9NvXMRiy6DDsm1zxBUfEyrhjIcxMCnsR9zgt4wcLqMFg4ObNG1y7FktcXAwJCfHExyeQlJRIcnISN27c4ObNG9y+fZvU1FTS0lLJyMjgzp07ZGZmkpWVhcGgf6x4DQYDavW9H4p3f2EIIcxHCnsRFxwZm2tujMzMDI798TmKXo8+M51MXTr6zAwCs3R8ZGNAp9ORlZWFXq/ncaYJUqvVaDQabG1t0WrtcHJywsHBkVKlHCld2okyZcpSrlw5ypVzxsXFhe3Hk1HblcGuVHkcSpdn//L/kJlxO1dRB7DXasyWCyFENinsRdyDLd4rkX+RcOHoffeoUKnUqDQatBp7nJzK4ODggKNjdkF2cnKibNlylCtXDhcXF1xcKuDq6oarqxsVK1bC3d3jiVbEqrD9NPtDY3K+dLJ0qdja5d5PSZtKVYjCIoW9iLP/3yIDd1Vv1AW9Lo1TB5ZTzr0WPr2monUog4NWw6J32xVaXPdPpWowGDBk6bArVynXNiVtKlUhCouMiiniHrbIgKdPH5p0m8SthAscWP0Bd24nFHrL2M3ZkdE9vdDaqsm4GQOAYzl3ILulrrVVM7qnlwx1FKIASGEv4vx8qqDR5F09pmKtFjTv8xG6tBv8vWoSz5ZJKfTY7k6l6qrJXkS4jEtVHLQa2jWqxIzhPnJxkhAFRAp7EXd/y/jBlrtb1Qa0fXUOpR20DBvck+DgAxaJz1EfB8CHY/qw6N12DPatIy11IQqQFPZi4G7LuF2jSjhoNagAR3sb2jWqxMJJr7Bj+27c3d3p168nf/yxudDjO3v2NJJBu0kAACAASURBVADNm7co9NcWoiSSpfGKqQdzlJSUyODB/Tl69DBz5szj9dffLLRYmjdvxKVLF4mNvVFor2mKHEPGSX5Ms+al8aTFXkKUL+/C+vWbeeklPyZNepc5cz55rHHsT+P69euUKvXog1AIYV5S2EsQR0dHli1byaBBQ5g//zPee28CWVlZBf66qakpVKhQocBfRwiRTcaxlzA2NjYsWPAN7u7uLFjwBQkJCSxZ8hMODg4F8nrJyUkYDAYqV36mQPYvhMhLWuwlkEql4oMPpjF79uds376VV17pQXJyUoG81qFDBwGoVUsm+hKisEhhL8HeeGMkS5cu499/j+Hv35mrV6+Y/TWOHz8GgJeXl9n3LYR4OCnsJZy/fy9Wr95ITEwML7/8EqdPnzLr/k+fPgGAj09Ls+5XCPFoUtgFbdq0ZdOmbWRlZdG9u29O94k5XLx4EQBPz1pm26cQwjgp7AKABg282Lp1Fy4uFXjlFX8CA7eaZb9xcbHY29vnma5XCFFw5NMmclStWo0tW3ZQr159hg0bxPLlvzz1Pm/dukW5cs5miE4IkV9S2EUuFSpUYMOGP2jfviPvvjuOefPmPvGFTFlZWWRm6qhYsZLpjYUQZiOFXeRRqlQpfvttDf36DWTu3FlMmvQuev3jL2EXGnocgGefrW7uEIUQRsgFSuKhbG1t+frr73Bzc+ebb77k+vXrLF68FHt7+3zv4+jRIwDUr9+goMIUQjyEFHbxSCqVimnTZuDu7s6HH35AUlIiv/yykrJly+Xr+RERYQA0adKsIMMUQjwgX10xW7ZsoWvXrvj6+rJixYpHbrd37146duxotuCEdRg5cgxLlvzE4cOH8PfvQmzstXw97/z5cwA0btykIMMTQjzAZGGPi4tjwYIFrFy5koCAANasWcO5c+fybHf9+nXmzp1bIEEKy+vVqy8rV67n8uVLdO3aibNnz5h8zrVrV7GxsXmixbCFEE/OZGEPCgqiRYsWlCtXDkdHR/z8/AgMDMyz3dSpUxk7dmyBBCmsQ7t2Hdi0aSsZGRl07+7LkSMhRrdPSkrCycmpkKITQtxlsrDHx8fj6uqac9vNzY24uLhc2/z666/Uq1ePhg0bmj9CYVW8vRvx5587KVOmLH36dGfnzrxf8nelp6fj6upWiNEJISAfJ08NBgMq1b21NBVFyXX7zJkz7Nixg2XLlhEbG/tEQRhbCeRRXF2lJWhKQeXI1bUhhw4dpGvXrgwdOpClS5fy+uuv59rm0qVLKIqCp2dNq/23sta4rIXkxzRrzZHJwu7h4cGRI0dybickJODmdq8VFhgYSEJCAn369CEzM5P4+HgGDRrEypUr8x2ELI1nfgWdI5XKgXXrNvP664MZPnw4589fYvz4d0m4kc72kGhWr10FwLnr9sxffgQ/nypWtYC1HEPGSX5Ms+al8UwW9latWvH111+TlJSEg4MDO3bsYObMmTmPjx8/nvHjxwNw5coVhg4d+lhFXRRdpUs7sWLFOsaPf5tZsz7mxNlL8GxPDAYV169mn2AvVaE6+0NjOBBxjdE9vfCu6WLhqIUo/kz2sbu7uzNx4kSGDh1Kz5496datG97e3owYMYLw8PDCiFFYMa1Wy+LFSxk6bCS/r13GwYDP0el0pCRlz+1evvJz6A0KukwDiwPCiU9Os3DEQhR/+bpAqXv37nTv3j3XfUuXLs2z3TPPPMOePXvME5koMtRqNQ1ffJP6F+4QuW8ZuvRbpN++DqhwcLq31qler7DjcDSDfWU1JSEKkswVI8wiODKW6k160qjzBJKuniDtRiwqtSbXNnqDQnDEk51gF0LknxR2YRYZuuxJwp6p14FKtdsACoohi61f9SNozRSuntyHwWDI2U4IUXBkrhhhFvZaDRk6PaE7vuHqqX2AijKu1Um9cY2kq5EkXY3keOBCnFwqM892CG+8MYpy5fI354wQ4vFIYRdm0fw5Nz6bNoqES8extStN26Ff5vSv3068TNTRzSRcOMbt69HMnfspc+d+iru7Bx07vsTbb4+lbt3nLPwOhCg+VMqTrqJgRjKO3fwKM0fp6en4+nXg9KkT2DtVoN3QhdjalcqzndZWzXt9a7Np/a8EBGzk7NkzGAwGAEqVKo2PT3Nef30Evr6dC3wpPTmGjJP8mGbN49ilsBdThZWjhIQEXnqpLTExV6lesy5ePT5BpbZFf9+/p0atQqNR5RnHbjAYCAjYwK+//szx40dJT08HwMbGhueeq0efPv0YNuzNAplETI4h4yQ/pklhN0EKu/kVRo7OnTuDn19Hbt++RevWL7Bu3SaSbuvYcTia4IhYMnR67LUaWjbwwLeZ6StPjx8/ynffLWL//r0kJl7Puf+ZZ6rg59eF0aPHUaVKNbPELseQcZIf06SwmyCF3fwKOkdBQQfo168HOp2OHj16s2TJT2btPomLi+P77xfzxx+buXgxKmfd1bJly9KqVRvefHMUL7zQ7on3L8eQcZIf06SwmyCF3fwKMkcbNqxlzJi3MBgMjBgxik8+mZtrYjhz0+l0rF69glWrlhMeHoZOdwfIvurVy6shAwa8ysCBg9FqtfnepxxDxkl+TJPCboIUdvMriBwpisKXX37B7NnZcwVNnjyNd955z6yvkR9//72PH374jqCgA9y8eQPIXsbv2Wer8/LL/owcOQZ3d3ej+5BjyDjJj2lS2E2Qwm5+5s5RVlYW7703gZUrfwNg3ryvGDJkmNn2/6Sioy/x7bffEBi4lStXonPud3FxoW3bDowaNeahS/PJMWSc5Mc0KewmSGE3P3PmKDU1lWHDBrFv31+o1Rp++GEZ3br1MMu+zSktLY1ffvmJ9etXc/LkCbKysgBwcHCgceMmDBnyGr16vYJarZZjyATJj2lS2E2Qwm5+5spRXFwc/fr14OTJE2i1WlasWEe7dh3MEGHBMhgM7NgRyLJlPxAScpCUlBQA1GoNnp61ePXVgQwc+Pojr36NT05je0g0wZH3je6p72F188oXFPmMmSaF3QQp7OZnjhydOXOavn39iYuLxcHBkfXrN9G0qY+ZIixcp06dZMmSRezatYO4uHsTkbm7e9Cpky9vvz2O2rWzZ50MO5/I4oBw9HolX+PxiyP5jJkmhd0EKezm97Q5OnDgbwYP7k9aWirOzs5s3Pgn9erVN2OElnPjxg1WrfqZFStWce7cvatfS5cuTcNGzdC7taJ81SaPHL6ptVUzY7hPsW65y2fMNCnsJkhhN7+nydG6dasZP/5tFEXBw6MiGzf+QY0aNc0coWXdzY/BYOD339fx22+/5Lr6VaXW4FShKpXrtqeatx82Wvuc52rUKto1qlSs55WXz5hp1lzYZdpekUNRFBYs+JwxY95CURSqV6/Btm27i11Rv59araZPn/4EBGzl0qU4OgydR6U6L2BrV4pb8Rc4uf9nAr8ZQMSepejSbwEyr7ywfjK7owAgMzOTSZPeZfnyX1CpVNSv78XatQG4uBTvvuQHlapQk+df/g8AGSnJnD/8OzGn93Px3z+JjthFVW9fajTpgeq+laGEsDZS2AW3b9/izTdf46+/dgPQsmVrfvttNU5OZSwcWeG7O688gH1pZ+p3GE79DsO5nRjN+cMbuXj8Ty7+u41nG3Qgql9VatTwtHDEQuQlXTElXEzMVbp378zevdlr1fr6dmbVqg0lsqgDtKzvgUadd3oEJ5cqNOo8gQ7Dv+VZb1+iT+6nVaumvPXWMCIiZFF3YV2ksJdgkZERdO7ckbNnT6MoCr17v8LPP6/AwcHB0qFZjJ9PFTSaR89741jWncZ+o9i19whjx77Drl076dixNa+++gqHDh0sxEiFeDQp7CXUX3/tpls3X27duklmZibDhr3B4sVLsbW1tXRoFuXm7Mjonl5obdV5Wu4atQqtrZrRPb2oV6saU6d+xPHjkUyePI1jx47QvbsvPXp0Yc+eXVjBYDNRgklhL4FWrvyNQYP6otFoSEtLY8KE/zB37vwCX7WoqPCu6cKM4T60a1QJB60GFeCg1dCuUSVmDPfJdXFS2bLleOed9zh6NJJZs+Zy6dJFBgzoTadObdmyJQC9XhbvFoVPxrEXUw/LkaIozJ37CfPnf0758uVJSkpi2rSZjB07wUJRWk5BHUM6nY7169fw9dcLOH/+HJ6etRg//l369OlXpH4NyWfMNBnHLixOp9MxZsxbzJ//Oa6ubiQnJzNv3lclsqgXJK1Wy6BBQ/jnn8P88MMv2Ns7MH782/j4NOSHH74jLS3N0iGKEkAKewlw8+YNBgzozfr1a3B39yA5OYklS36yiml3iyuNRoO/fy927/6b1as3UKVKVSZP/j+aNm3AwoXzuHXrpqVDFMWYFPZiLjr6Mt26+XLwYBDu7h7cunWT335bTc+efSwdWomgUqno2PElNm8OZPPmQBo2bMysWR/TuHF9Zs36mISEBEuHKIohKezFWGjocbp0eZErV65QrpwzaWlprFnzOy++6Gvp0EqkFi1asWrVBnbv/puOHTvx1VfzadKkPh988B7R0ZctHZ4oRuTkaTF16NA++vfvT+nSTmRm6lCr1axZ8zve3o0sHZpVsIZj6Ny5s3zzzZesXbsKgL59+zNu3ERq1apt0bjAOvJj7UzlqCDn9JeTpyXQzz//QI8ePahYsTLp6ek4ODiyefN2KepWxtOzFl9+uYjDh8MYPnwEmzZtpE2bZrzxxlDCwv61dHjiKYSdT2TaTyHsD43JmaIiQ6dnf2gM034KIex8YoG+vhT2YsRgMPDxxx8yadK7NG3alJiYK7i6urJly3araAWKh6tc+Rk++WQuR49G8s47/2Hfvr/o1Kkt/fv3Ijj4gFzsVMTEJ6exOCAcXaYh10ItkD0zqC7TwOKAcOKTC26ElBT2YiIjI4ORI4ezaNFC2rfvyPHjx6lRw5PNm7dTpUpVS4cn8qFChQp88ME0jh2LYOrUjwgPD6NHjy507+7Hzp2BUuCLiO0h0ej1xv+t9HqFHYejjW7zNPJV2Lds2ULXrl3x9fVlxYoVeR7ftWsXPXr0wN/fn9GjR3PzpgzlKkxJSYn07evPpk0b6d69J/v376VZs2YEBPyJm5ubpcMTj6lMmbKMH/8uR49GMHv2F8TEXOXVV/vRsWMbAgI2yNWsVu7v0MtcPXuIsF3fsXvpW/yxoBd/Luida5uCntPf5MnTuLg4Bg4cyMaNG9FqtQwYMID58+fj6Zk9XWlKSgqdO3dmw4YNuLu7s3DhQm7fvs3UqVPzHYScPH1yFy5EMXBgH65evUKPHr1Zu3YV7dt35I8/NpOWZrB0eFarKB1DmZmZbNiwlq+/XsDZs2eoXr0G48ZN5JVXBmBnZ1cgr1mU8mMprq5OhIaeIjBwK0FB/3DiRARXr14lPT1vF4uN1pHOY1fmuk8F/Ph+xyd6bVMnT03Oxx4UFESLFi1yVnP38/MjMDCQsWPHAtkH3fTp03F3dwegTp06bNmy5YmCFabdf6b92sUTHNn8KWqVQueuPVi7dhXduvXg229/oFSpUqSlyQezOLC1tWXAgFfp128gW7f+wcKF83j33XF8/vlsRo8ex+DBwyhVqpSlwyzWDAYDR48eZteunRw+fJBz585y/XoCWVlZubZTqe5NHKfW2OLh2YJ67V7HvnT5PPu012oKLF6TLfYlS5aQlpbGxIkTAVi3bh1hYWHMnDkzz7YZGRkMGjSIIUOG0KtXr4KJuAQ7cjKOOb8cJktv4MrpYI5vnY9dqXK4PFOPKyf24t97IBvW/IqNjayfUpwpisLOnTuZPXs2e/fuxcXFhQkTJjB27FicnZ0tHV6Rl5KSwtatW9m5cydHjx7lwoUL3Lx5M9c5DltbW9zc3KhUqRIJCQlcvnwZg8GASqWi8rN1qOjVE3fPFo98DY1aReeW1RjVu2GBvAeTFeBusHcpipLr9l23b99mzJgx1K1b97GLunTFmBafnMbsX0LQZRqIOraZE3t/pqy7J45lXblyYi81mvij8RzA6ahE3JwdS2SOHkdRz0/jxi1Zu3YzISGH+OqreUybNo25cz/j9dffZOTIMTm/oJ9UUc9Pfl24EEVg4FaCg//h1KmTxMZeIyMjI9c2jo6OeHrWol69BrRp05Y2bdry66/LWLduJYcPHwbA2dmZvn37M2nSVDL0Nkz7Kfuz+igajYoXGng8cY6fuivGw8ODI0eO5NxOSEjIc0IuPj6eN954gxYtWjB58uQnClQYtz0kmqzMLCL++omLx//AvYYPoHDtTBB1Wg3Cs/krGAyw43A0g33rWDpcUUh8fJqzfPlaIiMj+Prr+Sxe/BVLl37LwIGDGTNmAtWqPWvpEK1CVlYWwcEH2LNnF0eOhBAVdZ6kpMRcJ6LVajXlyjlTr14Dnn++CR07vkTbtu3RarUA7Nq1g88++5T/+7+JKIqCWq2mefOWfPDBh7Rq1SZnP2WA0T29WBwQjl6v5BryqFGr0GhUjO7p9dQXKRmT75On69evx8HBgQEDBjBz5ky8vb0B0Ov1vPLKK3Tq1InRo0c/URDSYjftrbnbCQ74nLjzIbg++zyJ0eEY9JnU7zCC6o1fztnOQath0bvtSmSOHkdxzU9U1HkWLVrI6tUrMBgM9O79CuPHv0udOnUfaz9FOT/JyUns3BnI/v37CA8P5cqVaG7fzv1etFotbm7u1KlTl+bNW+Hr24V69erl2VdCQgKffvoxmzb9TkpK9j48PCry2muvM2PGdG7evPPIOOKT09hxOJrgiPuuPG3ggW+zgr/yNF9TCmzZsoUlS5aQmZlJ3759GTFiBCNGjGD8+PHExsYybtw46tS510ps0KABs2bNyneQUtizPeoS5KY17enRuzc3Ys9i5+jMnbRkAKrUf5GGfuNy7ePumfbimiNzKe75uXYthm+//YZff/2JtLQ0unTpxjvv/IfGjZvk6/lFJT8nTpxgx45tHDoUxJkzp4mLi0Wn0+XapnRpJ6pUqYKXV0PatGmLn18XnJ3znsy8y2AwsHbtqpxRSJDdp96uXUemTv045wvAmudjl7lirETY+cSH/nRLu3GVoHUfkZFyHf73T+VU4Vma9fgAx7J5+1GlxZ4/JSU/iYmJ/PDDd/zwwxJu3rxB27YdmDDhXdq0afvQc2V3WVt+dDod+/fvZc+enRw/fowLF6K4cSMZg+FeP7ZGo6F8eRdq1KjJ8883o1Onl2jZsnW+BxNcuBDFzJnT2blzO3fuZPezP/tsdUaNGsuwYW/kWWFMCrsJJb2wxyenPfRkS+KVSEI2zkCflf1zz0brgFen0VSu+8JD96NRq2jXqBKDfesUuxyZW0nLT0rKbZYt+4nvvvuG+Pg4mjRpyoQJ7+Hr2/mhSyJaMj9xcXEEBv7JgQN/ExkZztWrV/IsUGJvb4+HR0Wee64eLVq0pnPnrlSvXuOxXysrK4vvv1/MDz8s4cqV7CtBHRwc6dLlZT788CMqV67yyOdac2GXcXFW4GGXIJ8/upmT+3763y0VVb1ewvult8nubHk4jUaFb7NHH4ii5Cpd2omxYyfw5psjWb16Bd988yVDhw7guefqMW7cRHr27FPow2QNBgNhYaHs2LGNkJCDnD17huvXE8jMzMzZRqVSUaZMGby8GuLt3ZD27Tvy4ou+lC796KKWH//+e5xPPplOUNA//xuLrqJevfpMmPAevXoV/bUKpMVuBUbP35czAxzAPysncSP2NAClXari03MKjmXd0dqoQYXRM+13F1oubjkyt5Ken6ysLAICNvDVV/M5deok1ao9y9ix79C//yDs7e1xdXUi8kyc2aadTUtLY8+enezdu4fQ0H+5dCnv2HAbGxsqVHDF07MWzZq1wNfXj8aNm5htkfW0tDQWLPicFSt+5fr17AVOypYtS+/e/Xj//SlG+90fxppb7FLYrcDwOXty/s7UpbP9m4Go1Boa+o7jmXrtcx5TAbNHtsjXmfbiliNzk/xkMxgMbN++jYULv+DYsaO4ubnz9tvj6NBtAF+tP5GvRsSDoqMvsW3bVoKDD3DiRCTXrsWQkZGeaxtHR0cqVapMvXoNaN26LX5+nalUqXKBvMe9e/cwZ84nHD9+DEUxoFaref75pkyaNIV27To88X6lsJtQ0gv7gy329JQk7BzL5Wmp3D0xmh/FLUfmJvnJTVEU/v57HwsXzufvv/dia1+aZxu9TPXGL6N1KJNne62tmo+GNSXq9L/s3r2TI0dCOH/+HImJ13ONDVepVJQr50z16tVp3LgJ7dp1pH37jtjb2xfo+0lMvM7s2TMJCNjArVu3AHBzc+PVV4cxceJ7Znl9ay7s0sduBVrW92B/aExOy8jhIfNKaNQqWjbwKOzQRAmhUqlo27Y9bdu255NFG1i74jvOHlxD1NFNVPP245n6nbidEEXC5VBuxkWRfiuejXNzn9C0tdVSsWJFateui49PC/z8ulK/foNCfR8bN67jyy+/4NSpk0B2906HDi/y4Ycf06CBd6HGYklS2K2An08VDkRcyzMp//3kxKgoLDF3KtDU/wNuXb/E+cMbiTq6iaijm3Jto7F1oEyFqvi2b8kLL7TF17cLLi4VLBJvdPQlZsyYzo4d20hPz+7yqVKlKm+99TZvvDGyRM6dVPLesRVyc3a0+CXIQtx1t1uwTIVqNO4ykeSY06TdjOWZBp2oXOcFXKrUR622QQUsfsJpZ5+WwWDgp5++Z8mSxVy6dBHIHgLp79+LDz/8uMRPpSCF3Up413RhxnCfArsEWYj8stdqcoq7LiONtJuxOJRxpZHv2DzbFbbIyAhmzpzG33/vyxkWWadOXcaPf5c+ffqZbQRNUSeF3Yq4OTsy2LeOTOIlLOr+cz5nD64BoKqXX65tCvOcT0ZGBl99NZ/ffvuZuLg4AJycytC//6tMmTLNYl1A1kwKuxAiFz+fKgRFxKI36Ll6ai+oVNRs4p9rm8I453PgwN/Mnj2TI0dCcqYPb9y4Cf/3f5N58cWXCvS1izop7EKIXNycHXn/tWa8/8V6dGk3KedRC7VN9tS1BX3O58aNG8yd+wkbNqzlxo0bALi4VGDgwMG89977ODpKl2R+SGEXQuTR9Dl3lEt/AFC/dX9UUKDnfDZvDmDBgs84cSISRVHQaDS88EI7pk79KN8zUop7pLALIR4q6MBeHBwc+f3b/yuQ/cfEXOWTTz5i69YtOZN8Va78DMOHj+Dtt8eVyGGK5iKZE0LksX79ejIyMujevadZ92swGPjll5/57rtvuHDhPAB2dnZ07dqNDz+cQc2anmZ9vZJKCrsQIo85c+YA8MEHH5plf2fOnGbGjGn89dduMjOzF8Lw9KzNmDHjGThwsAxTNDMp7EKIXDIyMjh+/Dju7u54etZ64v3odDq++eZLfvnlJ65diwGgVKnS9OnzClOmfPTUC26LR5PCLoTI5euvF2AwGOjXb9ATPT8k5CCzZn1MSMhB9Ho9KpUKb+9GvPfe+3Tu3NXM0YqHkcIuhMhlxYpfUalUTJz433w/59atW3zxxWzWrFlFcnISAOXLl6dfv4G8994HlCmTd4ZIUXCksAshcly6dJGYmKt4e3vna5WiwMCtfPHFHMLDQ3OGKbZs2ZopU6bj49OiECIWDyOFXQiRY/bsmQD897+Pbq3HxcUxa9ZHbNmyidTUFAAqVqzEa68NZ+zYd9BqtYUSq3g0KexClGDxyWm5lr8L/OMPbGxs6eDbI9d2BoOBVauWs2jRQs6dOwtkz7/u69uFqVM/om7d5ywRvngEKexClFBh5xNzTRUdf/FfsnTpuFVvwoT5+3i7ZwNKkczMmdPYvXsnd+7cAaB69ZqMHj2OIUOGyTBFKyWFXYgSKD45jcUB4egyDTn3nfvfTI61WvQn8sA6ui9+nfTb14HsNUr79u3P1KkfFdjapMJ8pLALUQJtD4lGr7+3oIvBkEVSzClUag1Bq99HUbILfqWqtZgx7UP8/c17BaooWFLYhSiBgiNjc63Ude7QBkBBMeixtStN5efaUbvVQMqWKYu/f/4WUBfWQwq7ECXQ3RWS7nqmfkdizvxDvbZv4Fa90SO3E0WDFHYhSqD7l78DcCzjSvvXvn7odqLokVPaQpRALet7oFGrjG5TmMvfCfOSwi5ECeTnUwWNxkRhL4Tl70TBkMIuRAnk5uzI6J5eaG3VeVruGrUKO1tNgS1/Jwqe9LELUUJ513RhxnAfdhyOJjgi+8rTu8vfDfB7DhvFYHonwirlq7Bv2bKFb7/9lqysLF577TVeffXVXI+fPHmSKVOmkJqaStOmTfn4449lWSshigA3Z0cG+9ZhsG+dXPe7VihFQsJtC0UlnpbJrpi4uDgWLFjAypUrCQgIYM2aNZw7dy7XNv/973+ZNm0a27dvR1EU1q5dW2ABCyGEMM5kYQ8KCqJFixaUK1cOR0dH/Pz8CAwMzHn86tWrZGRk0KhR9tjX3r1753pcCCFE4TLZXxIfH4+rq2vObTc3N8LCwh75uKurK3FxcY8VhIuL6XmfH+Tq6vTYzylpJEfGSX6Mk/yYZq05MlnYDQYDKtW9s+aKouS6berx/EhMTMFw3+XNpri6Okn/nwmSI+MkP8ZJfkyzZI7UapXRBrHJrhgPDw8SEhJybickJODm5vbIx69fv57rcSGEEIXLZGFv1aoVwcHBJCUlkZ6ezo4dO2jbtm3O45UrV8bOzo6jR48CsGnTplyPCyGEKFwmu2Lc3d2ZOHEiQ4cOJTMzk759++Lt7c2IESMYP348Xl5efPHFF0ydOpWUlBTq16/P0KFDHysItYlLm831nJJGcmSc5Mc4yY9plsqRqddVKYqS/85tIYQQVk+mFBBCiGJGCrsQQhQzUtiFEKKYkcIuhBDFjBR2IYQoZqSwCyFEMSOFXQghihkp7EIIUcxIYRdCiGLGqgv7li1b6Nq1K76+vqxYsSLP4ydPnqR37974+fkxZcoUBwTCTgAAA8VJREFUsrKyLBCl5ZjKz65du+jRowf+/v6MHj2amzdvWiBKyzKVo7v27t1Lx44dCzEy62AqP1FRUQwZMgR/f3/eeOONEncMmcpPZGQkffr0wd/fn5EjR3Lr1i0LRPkQipWKjY1VOnTooCQnJyupqalK9+7dlbNnz+ba5uWXX1aOHz+uKIqifPDBB8qKFSssEapFmMrP7du3ldatWyuxsbGKoijKl19+qcycOdNS4VpEfo4hRVGUhIQEpXPnzkqHDh0sEKXlmMqPwWBQfH19lX379imKoiiff/658tlnn1kq3EKXn+Nn4MCByt69exVFUZTZs2cr8+fPt0SoeVhti11WbjLOVH4yMzOZPn067u7uANSpU4dr165ZKlyLMJWju6ZOncrYsWMtEKFlmcpPZGQkjo6OObO1jho1Ks96x8VZfo4fg8FAamoqAOnp6djb21si1DystrA/bOWm+1dmMsfKTUWZqfw4Ozvz0ksvAZCRkcH3339Pp06dCj1OSzKVI4Bff/2VevXq0bBhw8IOz+JM5efy5ctUqFCByZMn06tXL6ZPn46jo6MlQrWI/Bw/77//PlOnTqVNmzYEBQUxYMCAwg7zoay2sBfGyk1FWX7f/+3bt3nrrbeoW7cuvXr1KswQLc5Ujs6cOcOOHTsYPXq0JcKzOFP5ycrKIiQkhIEDB/L7779TpUoV5syZY4lQLcJUfjIyMpgyZQrLli3jn3/+YdCgQUyaNMkSoeZhtYVdVm4yzlR+ILvFMWjQIOrUqcOsWbMKO0SLM5WjwMBAEhIS6NOnD2+99VZOvkoKU/lxdXWlWrVqeHl5AdCtW7dc6x0Xd6byc+bMGezs7PD29gagf//+hISEFHqcD2O1hV1WbjLOVH70ej2jRo2iS5cuTJkypUT9mrnLVI7Gjx/P9u3b2bRpE99//z1ubm6sXLnSghEXLlP5ady4MUlJSZw6dQqAPXv2UL9+fUuFW+hM5adatWrExsYSFRUFwO7du3O+BC3OkmduTdm8ebPy8ssvK76+vsr333+vKIqivPnmm0pYWJiiKIpy8uRJpU+fPoqfn5/y7rvvKnfu3LFkuIXOWH527Nih1KlTR/H398/5b/LkyRaOuPCZOobuio6OLnGjYhTFdH7+/fdfpU+fPkrXrl2V4cOHK9evX7dkuIXOVH727t2rdO/eXenWrZvy2muvKZcvX7ZkuDlkBSUhhChmrLYrRgghxJORwi6EEMWMFHYhhChmpLALIUQxI4VdCCGKGSnsQghRzEhhF0KIYkYKuxBCFDP/D9ld48uDPrSYAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k = 2 # Queremos 2 vecinos, así que necesitaremos 3 puntos (el primero es uno mismo!)\n",
    "nearest_partition = np.argpartition(square_dist, k+1, axis=1)\n",
    "\n",
    "# Dibujamos los puntos y las líneas que unen cada punto con sus k vecinos más cercanos\n",
    "plt.scatter(data[:, 0], data[:, 1], s=100)\n",
    "\n",
    "for i in range(data.shape[0]):\n",
    "    for j in nearest_partition[i, :k+1]:\n",
    "        plt.plot(*zip(data[j], data[i]), color='black')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays estructurados\n",
    "\n",
    "NumPy soporta también arrays para datasets heterogéneos, aunque para ese tipo de datos es recomendable usar los **Dataframes** de **pandas** :)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  },
  "toc": {
   "base_numbering": "0",
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Mis notas: NumPy",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "316.4px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}