ALG06-Vectores_COMPLETO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vectores\n",
    "\n",
    "<img src=\"./Images/vectores.jpg\" alt=\"Drawing\" style=\"width: 250px;\"/>\n",
    "\n",
    "Imagina que un avión está volando dirección al este a unos __800 km/h__. De repente, una corriente de aire frío a __35 km/h__ proveniente del sur-este golpea al avión. \n",
    "\n",
    "<img src=\"./Images/plane.jpg\" alt=\"Drawing\" style=\"width: 200px;\"/>\n",
    "\n",
    "El efecto del viento sobre el avión vendrá determinado por su __velocidad__ y su __dirección__. Las magnitudes físicas o variables se pueden clasificar en dos grandes grupos:\n",
    "\n",
    "- __Escalares:__ Son aquellas que quedan definidas exclusivamente por un módulo, es decir, por un número acompañado de una unidad de medida. Es el caso de masa, tiempo, temperatura, distancia. Por ejemplo, 5,5 kg, 2,7 s, 400 °C y 7,8 km, respectivamente.\n",
    "\n",
    "\n",
    "- __Vectoriales:__ Son aquellas que quedan totalmente definidas con un módulo, una dirección y un sentido. Es el caso de la fuerza, la velocidad, el desplazamiento. En estas magnitudes es necesario especificar hacia dónde se dirigen y, en algunos casos  dónde se encuentran aplicadas. Todas las magnitudes vectoriales se representan gráficamente mediante vectores, que sesimbolizan a través de una flecha."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3- Vectores\n",
    "\n",
    "## 3.1- ¿Qué es un vector?\n",
    "\n",
    "Se denomina __vector de dimensión__ $n$, a una tupla de números reales (que se llaman componentes del vector). Así, un vector $v$ perteneciente a un espacio ${R}^{n}$ se representa como:\n",
    "\n",
    "<center>$v = (a_{1}, a_{2}, a_{3}, ... a_{n})$ donde $v \\in {R}^{n}$</center>\n",
    "\n",
    "Un vector también se puede ver desde el punto de vista de la geometría como __vector geométrico__ (usando frecuentemente el espacio tridimensional $R^{3}$ o bidimensional ${R}^{2}$).\n",
    "\n",
    "## 3.2- Notación de vectores geométricos\n",
    "\n",
    "Considerando el siguiente vector de $O$ a $A$, contenido en el espacio bidimensional $R^{2}$:\n",
    "\n",
    "<img src=\"./Images/vector.jpg\" alt=\"Drawing\" style=\"width: 500px;\"/>\n",
    "\n",
    "La __posición__ del vector puede ser representada como $\\overrightarrow{OA}$ o $\\vec{v}$. \n",
    "\n",
    "El __módulo__ puede ser denotado como: $|\\overrightarrow{OA}|$ o $OA$ o $|\\vec{v}|$. Está representado por el tamaño del vector, y hace referencia a la intensidad de la magnitud (número).\n",
    "\n",
    "La __dirección__ corresponde a la inclinación de la recta, y representa al ángulo entre ella y un eje horizontal imaginario.\n",
    "\n",
    "El __sentido__ está indicado por la punta de la flecha (signo positivo que por lo general no se coloca, o un signo negativo).\n",
    "\n",
    "\n",
    "## 3.3- ¿Qué podemos representar con un vector?\n",
    "\n",
    "Considerando que un __vector__ es una tupla de números reales, podemos usarlo para representar:\n",
    "\n",
    "- __Cadenas binarias:__ La clave secreta de un criptosistema 101101011 puede ser representada como:\n",
    "\n",
    "<center>$[1, 0, 1, 1, 0, 1, 0, 1, 1]$</center>\n",
    "\n",
    "- __Palabras:__ Usando ciertos algoritmos (word2vec, glove...), podemos codificar las palabras a vectores únicos que representan dicha palabra.\n",
    "    \n",
    "```\n",
    "king = [ 0.50451 , 0.68607 , -0.59517 , -0.022801, 0.60046 , -0.13498 , -0.08813 , 0.47377 , -0.61798 , -0.31012 ... 0.78321 , -0.91241 , -1.6106 , -0.64426 , -0.51042 ]\n",
    "```\n",
    "    \n",
    "- __Distribuciones de probabilidad:__  La probabilidad de un dado: \n",
    "\n",
    "<center>$[1/6, 1/6, 1/6, 1/6, 1/6, 1/6]$</center>\n",
    "\n",
    "## 3.4- Vectores en Python\n",
    "\n",
    "Para crear un vector en Python usamos la función `array()` de la biblioteca `numpy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "ex = np.array([2, 3, 4, 5, 6, 7])\n",
    "print(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(ex))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6,)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 4, 5]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [2, 5]\n",
    "b = [4, 5]\n",
    "\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6, 10])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([2, 5])\n",
    "b = np.array([4, 5])\n",
    "\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.1- Suma y resta de Vectores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./Images/suma_vectores.png\" style=\"width: 300px;\"/>\n",
    "\n",
    "El __vector suma__ está definido por:\n",
    "\n",
    "\n",
    "<center>$[u_{1}, u_{2}, ..., u_{n}] + [v_{1}, v_{2}, ..., v_{n}] = [u_{1}+v_{1}, u_{2}+v_{2}, ..., u_{n}+v_{n}]$</center>\n",
    "\n",
    "Para cualesquiera vectores **u**, **v**, **w**, se tiene:\n",
    "* Propiedad asociativa: $(u+v)+w=u+(v+w)$\n",
    "* Propiedad conmutativa: $u+v=v+u$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 9, 3])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np # !pip install numpy\n",
    "\n",
    "x_np = np.array([1, 5, 2])\n",
    "y_np = np.array([7, 4, 1])\n",
    "\n",
    "x_np + y_np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué sucede si no usamos `np.array`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "x_list = list(x_np)\n",
    "y_list = list(y_np)\n",
    "\n",
    "print(type(x_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 2, 7, 4, 1]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_list + y_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python considera las variables `x` y `y` como listas, por lo que las concatena al usar el operador `+`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, al usar `np.array` es considerado como `array`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(x_np + y_np))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De forma similar para la `resta`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-6,  1,  1])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_np - y_np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué hace internamente numpy cuando sumamos dos arrays?\n",
    "<a id='ex1'></a>\n",
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Realizar la suma de estos dos arrays <b>[2, 3, 10]</b> y <b>[10, 20, 30]</b> sin usar numpy. (Usa un bucle para realizarlo).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2, 3, 10]\n",
    "b = [10, 20, 30]\n",
    "\n",
    "res = []\n",
    "for i, z in zip(a, b):\n",
    "    res.append(i + z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12, 23, 40]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De una forma más compacta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12, 23, 40]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i+z for i, z in zip(a, b)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué sucede si introducimos dos `arrays` de distinta longitud?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (2,) (3,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/zb/r_57byp97tx0mcljd3fd0_640000gn/T/ipykernel_78587/4180901569.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0my_np\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mx_np\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my_np\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,) (3,) "
     ]
    }
   ],
   "source": [
    "x_np = np.array([1, 5])\n",
    "y_np = np.array([2, 3, 4])\n",
    "\n",
    "x_np + y_np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos imprimir su longitud usando `shape`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2,)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_np.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_np.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b>⚠️ ATENCIÓN ⚠️</b> Hay una diferencia entre usar `len` y usar `shape`\n",
    "</div>\n",
    "\n",
    "Por ejemplo, si definimos el siguiente `array`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "z_np = np.array([1, 2, 3])\n",
    "w_np = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "\n",
    "print(len(z_np))\n",
    "print(len(w_np))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La longitud del array `z_np` es 3 y la longitud de `w_np` es 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z_np.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w_np.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#z_np = np.array([1, 2, 3]) # (1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto sucede porque `w_np` es una matriz de 2 filas y 3 columnas. Sin embargo, `z_np` es solo un vector de 3 dimensiones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Un segundo...esto es importante!\n",
    "\n",
    "Al principio puede resultar un poco confuso, pero...¿cómo se representa visualmente un array cuando los creamos de la siguiente forma?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si creamos un `1D array`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:  (4,)\n",
      "Shape: (4,)\n",
      "Shape: (4,)\n"
     ]
    }
   ],
   "source": [
    "arr_1d = np.array([2, 3, 4, 5])\n",
    "print(\"Shape: \", arr_1d.shape)\n",
    "print(f\"Shape: {arr_1d.shape}\")\n",
    "print(\"Shape: {}\".format(arr_1d.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También lo podemos crear de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_1d = np.arange(2, 6)\n",
    "arr_1d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./Images/array1D.PNG\" alt=\"Drawing\" style=\"width: 200px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al crear un `2D array`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4)\n"
     ]
    }
   ],
   "source": [
    "arr_2d = np.array([[2, 3, 4, 5], [6, 7, 8, 9]])\n",
    "print(arr_2d.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que antes, lo podemos crear usando `arange()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d = np.arange(2, 10).reshape(2, 4)\n",
    "arr_2d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3, 4, 5],\n",
       "       [6, 7, 8, 9]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./Images/array2D.PNG\" alt=\"Drawing\" style=\"width: 200px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, si creamos un array con 3 dimensiones, `3D array`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 2)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_3d = np.array([[[0, 1], [2, 3], [4, 5]], [[2, 4], [5, 6], [7, 8]]])\n",
    "arr_3d.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De una forma más concisa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 4,  5]],\n",
       "\n",
       "       [[ 6,  7],\n",
       "        [ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[12, 13],\n",
       "        [14, 15],\n",
       "        [16, 17]],\n",
       "\n",
       "       [[18, 19],\n",
       "        [20, 21],\n",
       "        [22, 23]]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_3d = np.arange(0, 24).reshape(4, 3, 2)\n",
    "arr_3d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./Images/array3D.PNG\" alt=\"Drawing\" style=\"width: 200px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.2- Suma de un escalar a un array\n",
    "\n",
    "Dado un escalar $a$ y un vector $v$, la suma viene definida por:\n",
    "<br>\n",
    "<center>$a + (v_{1}, v_{2}, ... v_{n}) = (a + v_{1}, a + v_{2}, ... a + v_{n})$</center>\n",
    "\n",
    "`numpy` nos simplifica mucho las cosas, nos permite sumar un escalar a todos los elementos de un `array` realizando simplemente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 20\n",
    "v = np.array([1, 5, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21, 25, 22])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Internamente está realizando algo muy parecido a lo realizado en el [ejercicio anterior](#ex1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[21, 25, 22]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = []\n",
    "for i in v:\n",
    "    res.append(i + a)\n",
    "    \n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.3- Multiplicación por escalares: Multiplicar un escalar por un vector\n",
    "\n",
    "Dado un número $a$ y un vector $v$, la multiplicación viene definida por:\n",
    "<br>\n",
    "<center>$a \\cdot (v_{1}, v_{2}, ... v_{n}) = (a \\cdot v_{1}, a \\cdot v_{2}, ... a \\cdot v_{n})$</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si no usaramos `numpy`, `python` considera que queremos duplicar una lista `n` veces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 3\n",
    "v = np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 6, 9])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "v = list(v)\n",
    "print(v)\n",
    "print(type(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando `numpy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 6, 9])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 3\n",
    "v = np.array([1, 2, 3])\n",
    "b * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué hace internamente numpy cuando multiplicamos un escalar por un array?\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Realizar la multiplicación de un escalar por un array sin usar numpy. <b>a = 12</b>, <b>v = [3, 5, 6]</b>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[36, 60, 72]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 12\n",
    "v = [3, 5, 6]\n",
    "\n",
    "mult = []\n",
    "for i in v:\n",
    "    mult.append(a * i)\n",
    "    \n",
    "mult"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De una forma más compacta y aplicando buenas prácticas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([36, 60, 72])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([a * i for i in v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dado un vector **v** y dos números cualesquiera $\\alpha$, $\\beta \\in \\mathbb{R}$, se tiene:\n",
    "* *Propiedad asociativa*: $\\alpha$($\\beta$**v**)=($\\alpha$$\\beta$)**v**  \n",
    "* *Propiedad distributiva*: $\\alpha$(**u**+**v**)=$\\alpha$**u**+ $\\alpha$**v**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.4- Producto escalar o interior\n",
    "\n",
    "El producto escalar de dos vectores se define como la suma de los productos de sus elementos. Geométricamente se entiende, como el módulo de uno de ellos por la proyección del otro sobre él.\n",
    "\n",
    "<img src=\"Images/producto_escalar.png\" style=\"width: 300px;\"/>\n",
    "\n",
    "Considerando dos vectores $\\overrightarrow{u}$ y $\\overrightarrow{v}$, el producto escalar viene definido por:<br><br>\n",
    "\n",
    "<center>$\\overrightarrow{u} \\cdot \\overrightarrow{v} = \\sum_{i \\in D}\\overrightarrow{u}_{i} \\cdot \\overrightarrow{v}_{i} = u_{1} \\cdot v_{1} + u_{2} \\cdot v_{2} + ... u_{n} \\cdot v_{n}$</center>\n",
    "\n",
    "También puede escribirse de la siguiente forma - interesante para poder calcular la similitud entre 2 vectores, lo haremos más adelante! 😃:<br><br>\n",
    "<center>$\\overrightarrow{u} \\cdot \\overrightarrow{v} = |\\overrightarrow{u}||\\overrightarrow{v}| \\cos \\theta $</center>\n",
    "\n",
    "Lo que genera como resultado un **ESCALAR**\n",
    "\n",
    "Las **propiedades algebraicas del producto escalar**:  \n",
    "* **Propiedad conmutativa**: **u** · **v** = **v** · **u**  \n",
    "* **Homogeneidad**: (α u) · v = α (u · v)  \n",
    "* **Propiedad distributiva**: (v<sub>1</sub> + v<sub>2</sub>) · **x** = v<sub>1</sub> · **x** + v<sub>2</sub> · **x**  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "u = np.array([1, 2, 3])\n",
    "v = np.array([4, 5, 6])\n",
    "\n",
    "u @ v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = np.array([3, 2, 1])\n",
    "\n",
    "u @ v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = np.array([3, 2, 1])\n",
    "v = np.array([6, 5, 4])\n",
    "\n",
    "u @ v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El producto `escalar` puede ser calculado usando el operador `@`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = np.array([3, 2, 1])\n",
    "v = np.array([6, 5, 4])\n",
    "\n",
    "u @ v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b>⚠️ ATENCIÓN ⚠️</b> El operador <b>@</b> es valido para <b>numpy arrays</b>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for @: 'list' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/zb/r_57byp97tx0mcljd3fd0_640000gn/T/ipykernel_78587/3103626873.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mv_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mu_list\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mv_list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for @: 'list' and 'list'"
     ]
    }
   ],
   "source": [
    "u_list = list(u)\n",
    "v_list = list(v)\n",
    "\n",
    "u_list @ v_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué sucede si introducimos vectores de distinto tamaño? Echándo un vistazo a la ecuación que define el `producto escalar` podemos determinar el comportamiento que tendrá.\n",
    "\n",
    "$\\overrightarrow{u} \\cdot \\overrightarrow{v}$ = $\\sum_{i \\in D}$ **u**[i]$\\cdot$**v**[i] = u<sub>1</sub> $\\cdot$ v<sub>1</sub> + u<sub>2</sub> $\\cdot$ v<sub>2</sub> + ... + u<sub>n</sub> $\\cdot$ v<sub>n</sub> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/zb/r_57byp97tx0mcljd3fd0_640000gn/T/ipykernel_78587/1854091520.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb_np\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0ma_np\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mb_np\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 2)"
     ]
    }
   ],
   "source": [
    "a_np = np.array([1, 2])\n",
    "b_np = np.array([2, 3, 4])\n",
    "\n",
    "a_np @ b_np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Realiza el producto escalar de dos vectores sin usar numpy. <b>u = [1, 3, 5, 7]</b> <b>v = [2, 4, 6, 8]</b>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = [1, 3, 5, 7]\n",
    "v = [2, 4, 6, 8]\n",
    "\n",
    "res = []\n",
    "for i, k in zip(u, v):\n",
    "    res.append(i*k)\n",
    "\n",
    "sum(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De una forma más compacta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = [1, 3, 5, 7]\n",
    "v = [2, 4, 6, 8]\n",
    "\n",
    "sum(i*k for i, k in zip(u, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O incluso mejor aún!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2, 12, 30, 56])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(u)*np.array(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(np.array(u)*np.array(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra más...¿Por qué no?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(np.array(u), np.array(v)) # @"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u_array = np.array(u)\n",
    "v_array = np.array(v)\n",
    "\n",
    "u_array.dot(v_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Norma\n",
    "\n",
    "Se llama `norma` (módulo o longitud) del vector $v$ (asociada al producto escalar anterior) al número real no negativo. \n",
    "\n",
    "<center>$||v|| =+ \\sqrt{v \\cdot v} = (\\sum_{i=1}^{n}x_{i}^2)^\\frac{1}{2}$</center>\n",
    "\n",
    "¿Por qué es interesante esto? Porque en física y geometría interesa conocer la longitud de dicho vector, por ello se difine la `norma`.\n",
    "\n",
    "Por ejemplo, si definimos la **distancia** entre dos vectores **u** y **v** como la longitud de la diferencia **u - v**, debemos definir la longitud de un vector. En lugar de usar el término \"longitud\" para vectores, generalmente usamos el término **norma** y viene denotada por $||v||$\n",
    "\n",
    "<img src=\"Images/norma.jpg\" style=\"width: 300px;\"/>\n",
    "\n",
    "La norma de un vector cumple las siguientes propiedades:  \n",
    "* $\\|v\\|$ es un número real no negativo.  \n",
    "* $\\|v\\|$ = 0 $\\leftrightarrow$ **v**=0.   \n",
    "* Para cualquier escalar $\\alpha$, $\\|\\alpha\\cdot v\\|$ = $| \\alpha | \\cdot$ $\\|v\\|$.  \n",
    "* $\\|u+v\\|$ ≤ $\\|u\\|$ + $\\|v\\|$.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Cómo la calculamos?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7]\n",
      "[2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "u_array = np.array(u)\n",
    "v_array = np.array(v)\n",
    "print(u_array)\n",
    "print(v_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.16515138991168"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(u_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> ¿Se te ocurre otra forma de calcular la norma del vector <b>u</b>?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al final, estamos realizando la raíz cuadrada del producto escalar de dicho vector `u` por él mismo `u`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7]\n",
      "84\n"
     ]
    }
   ],
   "source": [
    "print(u_array)\n",
    "print(u_array * u_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.16515138991168"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(sum(u_array * u_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vectores Ortogonales\n",
    "\n",
    "Dos vectores son ortogonales o lo que es lo mismo, perpendiculares, cuando su **producto escalar** es nulo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 = np.array([3, 4])\n",
    "v2 = np.array([4, -3])\n",
    "\n",
    "v1 @ v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por tanto, los vectores $\\overrightarrow{v_{1}}$ y $\\overrightarrow{v_{2}}$ son ortogonales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 = np.array([1, 0])\n",
    "v2 = np.array([0, 1])\n",
    "\n",
    "v1 @ v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.5- Visualización de vectores\n",
    "\n",
    "Estamos acostumbrados a visualizar los vectores como flechas que parten desde el origen hacia un punto. Pero...¿cómo podemos hacer eso usando Python?\n",
    "\n",
    "<img src=\"./Images/interesting.gif\" alt=\"Drawing\" style=\"width: 300px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importamos `matplotlib`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usamos la función `quiver` que nos proporciona `matplotlib` para visualizar vectores. Simplemente debemos definir el punto de inicio de los vectores y su dirección."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_1 = 1\n",
    "y_1 = 0\n",
    "ux_1 = 0\n",
    "uy_1 = 3\n",
    "\n",
    "x_2 = 1.5\n",
    "y_2 = 0\n",
    "ux_2 = -1\n",
    "uy_2 = -1\n",
    "\n",
    "ax = plt.subplot()\n",
    "ax.quiver(x_1, y_1, ux_1, uy_1)\n",
    "ax.quiver(x_2, y_2, ux_2, uy_2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> \n",
    "    <p>Un sensor consta de los siguientes componentes:</p>\n",
    "    <ul>\n",
    "        <li>CPU</li>\n",
    "        <li>Radio</li>\n",
    "        <li>Sensor de temperatura</li>\n",
    "        <li>Memoria</li>\n",
    "        <li>LCD</li>\n",
    "    </ul>\n",
    "    <p>Este sensor va a ser colocado en un lugar donde no hay acceso a energía eléctrica, por lo que usará paneles solares para alimentarse. Por ello, necesitamos conocer el consumo de energía que consume todos los componentes.</p>\n",
    "    <p>Suponiendo que conocemos el consumo eléctrico de cada componente</p><br>\n",
    "    <center><b>consumo = {memoria: 0.06W, radio: 0.06W, sensor: 0.004W, CPU: 0.0025W, LCD: 0.03W}</b></center>\n",
    "    \n",
    "Estos datos fueron tomados experimentalmente y anotamos el tiempo que estuvo trabajando cada componente de forma continuada.<br><br>\n",
    "    <center><b>duracion = {memoria: 1.0s, radio: 0.2s, sensor: 0.05s, CPU: 1.0s, LCD: 1.2s}</b></center><br>\n",
    "\n",
    "Debemos calcular el total de energía consumida en Julios:\n",
    "    <center><b>total_energia = consumo.duración</b></center>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primero debemos escribir y extraer de ambos diccionarios, `consumo` y `duracion` los respectivos valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "consumo = {\"memoria\": \"0.06W\", \n",
    "           \"radio\": \"0.06W\", \n",
    "           \"sensor\": \"0.004W\", \n",
    "           \"CPU\": \"0.0025W\",\n",
    "           \"LCD\": \"0.03W\"}\n",
    "\n",
    "duracion = {\"memoria\": \"1.0s\", \n",
    "           \"radio\": \"0.2s\", \n",
    "           \"sensor\": \"0.05s\", \n",
    "           \"CPU\": \"1.0s\",\n",
    "           \"LCD\": \"1.2s\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print(type(consumo))\n",
    "print(type(duracion))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extraemos los valores de ambos diccionarios usando `values()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0.06W', '0.06W', '0.004W', '0.0025W', '0.03W']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cons_list = list(consumo.values())\n",
    "cons_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1.0s', '0.2s', '0.05s', '1.0s', '1.2s']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "duracion_list = list(duracion.values())\n",
    "duracion_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si nos fijamos bien, los elementos de ambas lista son de tipo `string` y debemos operar con valores numéricos, para ello debemos eliminar sus unidades `W` o `s` y convertirlos a variables de tipo `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.06'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"0.06W\"\n",
    "a[:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 0.2, 0.05, 1.0, 1.2]\n",
      "[0.06, 0.06, 0.004, 0.0025, 0.03]\n"
     ]
    }
   ],
   "source": [
    "cons_list_float = []\n",
    "dur_list_float = []\n",
    "\n",
    "for c, d in zip(cons_list, duracion_list):\n",
    "    cons_list_float.append(float(c[:-1]))\n",
    "    dur_list_float.append(float(d[:-1]))\n",
    "    \n",
    "print(dur_list_float)\n",
    "print(cons_list_float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(cons_list_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora mismo ya tenemos dos listas que podemos convertir a `array`. Si pensamos bien en este problema, simplemente nos están pidiendo que sumemos el resultado de calcular el **producto del consumo de cada componente por su duración**, es decir, que calculemos el producto escalar entre ambos vectores y eso ya lo sabemos hacer! :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.11069999999999999"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = np.array(cons_list_float) @ np.array(dur_list_float)\n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.6- Similitud entre dos vectores ... Importante y guay 😃\n",
    "\n",
    "Como hemos comentado anteriormente, los vectores pueden ser usados para representar palabras o incluso frases:\n",
    "\n",
    "```\n",
    "casa = [ 0.50451 , 0.68607 , -0.59517 , -0.022801, 0.60046 , -0.13498 , -0.08813 , 0.47377 , -0.61798 , -0.31012 ... 0.78321 , -0.91241 , -1.6106 , -0.64426 , -0.51042 ]\n",
    "```\n",
    "\n",
    "Y haciendo uso del `producto escalar`, podemos calcular la similitud entre dos vectores. Por ejemplo, si convertimos nuestras palabras `casa` y `casita` en vectores (usando un determinado algoritmo) y calculamos el `producto escalar`de ambos vectores, el resultado debe ser que dichos vectores son muy similares.\n",
    "\n",
    "En otros módulos veréis esto en profundidad, aquí lo vamos a analizar desde el punto de vista de la algebra lineal para entender como funciona.\n",
    "\n",
    "Partiendo de:\n",
    "\n",
    "<center>$\\overrightarrow{u} \\cdot \\overrightarrow{v} = |\\overrightarrow{u}||\\overrightarrow{v}| \\cos \\theta $</center>\n",
    "\n",
    "Podemos derivar que la ecuación de similaridad viene definida por:<br><br>\n",
    "\n",
    "<center>$\\cos \\theta = \\frac{\\overrightarrow{u} \\cdot \\overrightarrow{v}}{|\\overrightarrow{u}||\\overrightarrow{v}|}$</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Considerando los siguientes vectores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = np.array([1, 2, 3])\n",
    "v = np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La similitud viene definida por el `producto escalar` $\\overrightarrow{u} \\cdot \\overrightarrow{v}$ entre el `producto del modulo` de ambos vectores $|\\overrightarrow{u}||\\overrightarrow{v}|$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "similarity = (u @ v) / (np.linalg.norm(u)*np.linalg.norm(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al ser el vector `u` igual al vector `v` el calculo de la similaridad nos debe decir que son iguales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(similarity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué sucede si un vector es completamente distinto, es decir va en la dirección opuesta?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = np.array([1, 2, 3])\n",
    "v = np.array([-1, -2, -3])\n",
    "\n",
    "similarity = (u @ v) / (np.linalg.norm(u)*np.linalg.norm(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Son totalmente opuestos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "similarity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Similaridad entre dos frases - Cosine Similarity\n",
    "\n",
    "Vamos a intentar calcular la similitud entre dos frases usando el producto escalar.\n",
    "\n",
    "Primero debemos convertir ambas frases a un vector, para ello vamos a hacer uso de la librería `nltk` - típica librería para un data science!😃 y que la conoceréis en profundidad en los siguientes módulos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install nltk\n",
    "#nltk.download()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.tokenize import word_tokenize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "sent_1 =\"Me encantan los perros\"\n",
    "sent_2 =\"Tengo 5 perros porque me encantan\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'alex'"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = \"AlEx\"\n",
    "test.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ALEX'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "sent1_list = word_tokenize(sent_1.lower())\n",
    "sent2_list = word_tokenize(sent_2.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['me', 'encantan', 'los', 'perros']\n",
      "['tengo', '5', 'perros', 'porque', 'me', 'encantan']\n"
     ]
    }
   ],
   "source": [
    "print(sent1_list)\n",
    "print(sent2_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(type(sent1_list))\n",
    "print(type(sent2_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vimos en el módulo pasado, vamos a crear un conjunto único de palabras, para ello usamos `set`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "sent1_set = set(sent1_list)\n",
    "sent2_set = set(sent2_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'porque', '5', 'tengo', 'encantan', 'me', 'perros', 'los'}\n"
     ]
    }
   ],
   "source": [
    "join_set = sent1_set.union(sent2_set)\n",
    "print(join_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vamos a crear un vector en base a si la frase contine una palabra del conjunto o no, por ejemplo:\n",
    "\n",
    "`sent = hola tengo miedo`\n",
    "`conjunto = {'hola', 'miedo'}`\n",
    "\n",
    "Por tanto, el vector quedará definido por:\n",
    "\n",
    "`res = [1, 0, 1]`\n",
    "\n",
    "Porque tanto `hola` como `miedo` están en el conjunto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "porque\n",
      "5\n",
      "tengo\n",
      "encantan\n",
      "me\n",
      "perros\n",
      "los\n",
      "....\n",
      "Frase 1:  [0, 0, 0, 1, 1, 1, 1]\n",
      "Frase 2:  [1, 1, 1, 1, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "sent1_array = []\n",
    "sent2_array = []\n",
    "\n",
    "# Iteramos sobre el conjunto para crear vectors con la misma longitud\n",
    "for word in join_set:\n",
    "    print(word)\n",
    "    if word in sent1_list:\n",
    "        sent1_array.append(1)\n",
    "    else:\n",
    "        sent1_array.append(0)\n",
    "    if word in sent2_list:\n",
    "        sent2_array.append(1)\n",
    "    else:\n",
    "        sent2_array.append(0)\n",
    "    \n",
    "print('....')\n",
    "print(\"Frase 1: \", sent1_array)\n",
    "print(\"Frase 2: \", sent2_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['tengo', '5', 'perros', 'porque', 'me', 'encantan']"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sent2_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora simplemente convertimos ambas listas a `np.array` y calculamos la similaridad con la ecuación anterior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(type(sent1_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "sent1_array = np.array(sent1_array)\n",
    "sent2_array = np.array(sent2_array)\n",
    "\n",
    "print(sent1_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Similarity:  0.6123724356957946\n"
     ]
    }
   ],
   "source": [
    "def similarity(u, v):\n",
    "    return (u @ v) / (np.linalg.norm(u)*np.linalg.norm(v))\n",
    "\n",
    "sim = similarity(sent1_array, sent2_array)\n",
    "print(\"Similarity: \", sim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Me encantan los perros'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sent_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tengo 5 perros porque me encantan'"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sent_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por tanto, ambas frases son muy parecidas entre ellas. Esto tiene un problema y es que no consideramos el significado de las frases, por ejemplo, `Tengo miedo` y `No tengo miedo` son frases que resultarán muy parecidas pero significan todo lo contrario."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Calcula la similaridad entre las siguientes frases:\n",
    "    <ul>\n",
    "            <li><b>Tengo miedo</b></li>\n",
    "            <li><b>No tengo miedo</b></li>\n",
    "     <ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Tengo miedo\"\n",
    "b = \"No tengo miedo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['tengo', 'miedo']\n"
     ]
    }
   ],
   "source": [
    "ex1_list = word_tokenize(a.lower())\n",
    "ex2_list = word_tokenize(b.lower())\n",
    "\n",
    "print(ex1_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creamos los conjuntos de ambas frases y los unimos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'no', 'miedo', 'tengo'}\n"
     ]
    }
   ],
   "source": [
    "ex1_set = set(ex1_list)\n",
    "ex2_set = set(ex2_list)\n",
    "\n",
    "join_set = ex1_set.union(ex2_set)\n",
    "print(join_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construimos los vectores para ambas frases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no\n",
      "miedo\n",
      "tengo\n",
      "[0, 1, 1]\n",
      "[1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "sent1_array = []\n",
    "sent2_array = []\n",
    "\n",
    "# Iteramos sobre el conjunto para crear vectors con la misma longitud\n",
    "for word in join_set:\n",
    "    print(word)\n",
    "    if word in ex1_list:\n",
    "        sent1_array.append(1)\n",
    "    else:\n",
    "        sent1_array.append(0)\n",
    "    if word in ex2_list:\n",
    "        sent2_array.append(1)\n",
    "    else:\n",
    "        sent2_array.append(0)\n",
    "        \n",
    "print(sent1_array)\n",
    "print(sent2_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, calculamos la similitud:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sim 0.8164965809277259\n"
     ]
    }
   ],
   "source": [
    "sim = similarity(np.array(sent1_array), np.array(sent2_array))\n",
    "print(\"Sim\", sim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vemos, son frases muy parecidas, pero realmente significan totalmente lo contrario. Normalmente se suele denominar `cosine similarity` al calcular la similaridad entre dos vectores/frases usando este método.\n",
    "\n",
    "Hay formas, que veréis en los siguientes módulos de NLP y Deep Learning, para tener en cuenta el contexto que engloba a la palabra y así determinar una similitud más precisa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.7- Producto vectorial\n",
    "\n",
    "El **producto vectorial** de dos vectores **u** y **v**, a diferencia del producto interno, el cual produce un escalar, tiene como resultado un **vector**. Una de las características de dicho vector es que resulta ser perpendicular al plano generado por los vectores **u** y **v**.\n",
    "Si ambos vectores son no nulos, la única forma de que **el vector resultante sea nulo** es que tanto **u** como **v** no formen un plano y que por lo tanto sean colineales.\n",
    "\n",
    "La biblioteca `numpy` cuenta con una función que permite obtener el producto vectorial de manera sencilla. La función `cross(u, v)` devuelve un array con el producto vectorial.\n",
    "\n",
    "Además, el **módulo del producto vectorial** es igual al área del paralelogramos de lado asociado a ambos vectores.\n",
    "\n",
    "<img src=\"Images/producto_vectorial.png\" style=\"width: 300px;\"/> \n",
    "\n",
    "\n",
    "<center>$|a\\times b| = |a| \\cdot |b|\\cdot sen(a, b)$</center>\n",
    "\n",
    "En este módulo veremos como se calcula el producto vectorial usando `numpy`. Más adelante veremos en profundidad como numpy lo calcula internamente, ya que hace falta tener conocimientos de determinantes que veremos en detalle en otro módulo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definiendo los vectores **u** y **v**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3 -2  4] [ 1  2 -3]\n"
     ]
    }
   ],
   "source": [
    "u = np.array([3, -2, 4])\n",
    "v = np.array([1, 2, -3])\n",
    "\n",
    "print(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El `producto vectorial` viene definido por:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2 13  8]\n"
     ]
    }
   ],
   "source": [
    "c = np.cross(u, v)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuyo resultante es un vector perpendicular a **u** y **v**, además el módulo del **vector C** es el área del paralelogramos de lado asociado a ambos vectores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.394804318340652"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como hemos mencionado antes, el **producto vectorial** de dos vectores **colineales** es nulo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = np.array([1, -9, 14])\n",
    "v = np.array([-4, 36, -56])\n",
    "\n",
    "np.cross(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resultado es 0 ya que el segundo vector se obtiene del primero multiplicandolo por -4 y por tanto ambos vectores son colineales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "#embeddings - vectores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5- Numpy Arrays Attributes\n",
    "\n",
    "Manipular datos en Python es sinónimo de usar `Numpy`, incluso `Pandas` está construido sobre `Numpy`. En este apartado vamos a ver algunos ejemplos de como realizar operaciones como **split**, **reshape** y **join** usando `numpy`. La mayor parte de las operaciones realizadas sobre nuestros datos, se pueden englobar en los siguientes bloques:\n",
    "\n",
    "* **Attributes of arrays:** `size`, `shape`, `memory consumption` y `data types`\n",
    "* **Indexing:** Obtener y modificar valores individuales del `array`\n",
    "* **Slicing:** Obtener subconjuntos que pertenecen a un `array`.\n",
    "* **Reshaping:** Modificar la forma del `array`\n",
    "* **Joining and splitting:** Combinar varios `arrays` en uno, o dividir uno en varios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Attributes of arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "\n",
    "x1 = np.random.randint(10, size=3)\n",
    "x2 = np.random.randint(10, size=(3, 4))\n",
    "x3 = np.random.randint(10, size=(4, 3, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 0, 3])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 7, 9, 3],\n",
       "       [5, 2, 4, 7],\n",
       "       [6, 8, 8, 1]])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[6, 7, 7, 8, 1],\n",
       "        [5, 9, 8, 9, 4],\n",
       "        [3, 0, 3, 5, 0]],\n",
       "\n",
       "       [[2, 3, 8, 1, 3],\n",
       "        [3, 3, 7, 0, 1],\n",
       "        [9, 9, 0, 4, 7]],\n",
       "\n",
       "       [[3, 2, 7, 2, 0],\n",
       "        [0, 4, 5, 5, 6],\n",
       "        [8, 4, 1, 4, 9]],\n",
       "\n",
       "       [[8, 1, 1, 7, 9],\n",
       "        [9, 3, 6, 7, 2],\n",
       "        [0, 3, 5, 9, 4]]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada `array` tiene varios atributos:\n",
    "\n",
    "* `ndim`: El número de dimensiones\n",
    "* `shape`: El tamaño de cada dimensión\n",
    "* `size`: El tamaño total del array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3, 5)"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos mostrar también el tipo de variables que contiene, usando `dtype`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O el tamaño en bytes que ocupa dicho `array`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "480"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si os fijáis, el vector `x3` tiene `60 elementos` en total y cada elemento ocupa `4 bytes`. El total de bytes que ocupa dicho array viene dado por: `60 x 4 = 240`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing\n",
    "\n",
    "Es similar a lo que aprendimos en el módulo anterior con el `indexing` para listas en Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.array([5, 4, 1, 2, 3])\n",
    "x1[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b>⚠️ ATENCIÓN ⚠️</b> Los elementos empiezan en <b>index=0</b>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder al último elemento usando `-1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O incluso acceder a elementos desde el final del array usando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 1])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En caso de `arrays` con más de una dimensión"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "x2[0, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[-1, -1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing\n",
    "\n",
    "Podemos extraer `subconjuntos` perteneciente a un `array` usando:\n",
    "\n",
    "`x[start:stop:step]`\n",
    "\n",
    "Si alguno de ellos no los definimos, los valores por defecto son: `start=0`, `stop=size of dimension`, `step=1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para `arrays` con más de una dimensión"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "\n",
    "z[:, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 5, 4])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z[1, ::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E incluso modificar sus elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "z[0, 0] = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100,   2,   3],\n",
       "       [  4,   5,   6]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reshaping\n",
    "\n",
    "Otra de las herramientas más usadas es `reshape`. Por ejemplo si queremos transformar:\n",
    "\n",
    "<center>$x = [1, 2, 3, 4, 5, 6, 7, 8, 9]$</center>\n",
    "\n",
    "A una matriz:\n",
    "\n",
    "<center>$x = \\begin{bmatrix}\n",
    "    1 & 2 & 3\\\\\n",
    "    4 & 5 & 6\\\\\n",
    "    7 & 8 & 9\n",
    "\\end{bmatrix}\n",
    "$</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = np.arange(1, 10)\n",
    "grid.reshape(3, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Joining and Splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([grid, grid])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para `arrays` con distinta dimensiones, se suele usar `vstack` (vertical stack) o `hstack` (horizontal)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid_reshape = grid.reshape(3, 3)\n",
    "grid_reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 4,  5,  6],\n",
       "       [ 7,  8,  9],\n",
       "       [20, 20, 20]])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([20, 20, 20])\n",
    "np.vstack([grid_reshape, x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos dividir los `arrays` usando `split`, `hsplit` o `vsplit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(1, 10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5]\n",
      "[6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "x1, x2, x3 = np.split(x, [3, 5])\n",
    "print(x1)\n",
    "print(x2)\n",
    "print(x3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}