2-intro-numpy-con-salidas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 2: Numpy\n",
    "\n",
    "Prof: Oscar E. Ramos Ponce, Universidad de Ingeniería y Tecnología - UTEC\n",
    "\n",
    "Nota: este (segundo) tutorial es una introducción a la biblioteca Numpy de Python, de manera muy directa. Se debe tener en cuenta que no se cubre de forma exhaustiva todas las funcionalidades de NumPy sino solamente las más utilizadas. Para mayor detalle de las funciones, se recomienda consultar la documentación oficial de NumPy (http://docs.scipy.org/doc/numpy/reference/). \n",
    "\n",
    "__Sugerencias:__ \n",
    "\n",
    "- Para ejecutar el código de una celda, presionar Ctrl-Enter.\n",
    "- Para crear una celda, presionar Ctrl-m seguido de b\n",
    "\n",
    "Numpy es la biblioteca principal para los cálculos científicos en Python. Provee arreglos multidimensionales de alta eficiencia, llamados `numpy arrays` (o `ndarrays`), así como herramientas para trabajar con estos arreglos.\n",
    "\n",
    "A pesar de que los arreglos de numpy no son parte de las bibliotecas base de Python, su uso es fundamental para álgebra lineal a través del manejo de matrices y vectores. Así, cuando se realiza cálculos científicos con Python, es recomendable utilizar `ndarrays` en lugar de otros tipos de contenedores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se debe importar la biblioteca de numpy para tener acceso a sus funciones. Normalmente se suele importar\n",
    "# con el alias \"np\"\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Arreglos\n",
    "\n",
    "Un `Numpy array` es un arreglo de dimensión n que contiene valores del mismo tipo, y se indexa mediante enteros no negativos. La forma del arreglo (`shape`) es una tupla de enteros que contiene el tamaño del arreglo a lo largo de cada dimensión.\n",
    "\n",
    "Los arreglos se pueden inicializar usando listas anidadas de Python, y se puede acceder a sus elementos usando corchetes.\n",
    "\n",
    "### 1.1 Arreglos Unidimensionales\n",
    "\n",
    "Son arreglos con solamente una dimensión. Si tienen n elementos, su dimensión será (n,). Al tener una sola dimensión, se comportan como vectores genéricos, pero no son ni vectores columna ni vectores fila. Por ejemplo, su transpuesta resulta en exactamente el mismo arreglo. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [10 20 30]\n",
      "Tipo del arreglo a: <class 'numpy.ndarray'>\n",
      "Tamaño del arreglo a: (3,)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([10, 20, 30])                      # Creación de un arreglo de dimensión 1\n",
    "print(\"a =\", a)\n",
    "print(\"Tipo del arreglo a:\", type(a))\n",
    "print(\"Tamaño del arreglo a:\", a.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los arreglos unidimensionales se pueden indexar como si fueran listas o tuplas, y es posible modificar el valor de cada uno de sus elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[0] = 10 a[1] = 20 a[2] = 30\n",
      "Arreglo luego del cambio:  [ 4 20 30]\n"
     ]
    }
   ],
   "source": [
    "print(\"a[0] =\", a[0], \"a[1] =\", a[1], \"a[2] =\", a[2])\n",
    "a[0] = 4             # Cambia un elemento del arreglo\n",
    "print(\"Arreglo luego del cambio: \", a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Arreglos Multidimensionales\n",
    "\n",
    "Son arreglos que tienen más de una dimensión. Se crean utilizando corchetes como se muestra a continuación. Es importante notar que estos arreglos sí se comportan como matrices, en el caso de ser bidimensionales, o como tensores, en caso de tener más de dos dimensiones.\n",
    "\n",
    "En adelante, a los arreglos de dos dimensiones se les llamará matrices. Si su tamaño es (n,1) o (1,n), se les llamará vectores columna (o simplemente vectores), o vectores fila, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B =\n",
      " [[10 20 30]\n",
      " [40 50 60]]\n",
      "Tamaño de B: (2, 3)\n",
      "Elementos: B[0,0] = 10 , B[0,1] = 20 , B[1,0] = 40\n"
     ]
    }
   ],
   "source": [
    "B = np.array( [[10,20,30], [40,50,60]] )    # Creación de un arreglo bidimensional\n",
    "print(\"B =\\n\", B)\n",
    "print(\"Tamaño de B:\", B.shape)   \n",
    "print(\"Elementos: B[0,0] =\", B[0,0], \", B[0,1] =\", B[0,1], \", B[1,0] =\", B[1,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un arreglo de una dimensión puede ser convertido a un arreglo de dos dimensiones de varias formas:\n",
    "\n",
    "- Usando el método `reshape`, pero se necesita conocer exactamente el tamaño del vector de entrada\n",
    "- Utilizando `None` como índice. Considerar que `x` es de tamaño `(n,)`. El vector columna `(n,1)` se obtiene como `x[:,None]`, y el vector fila `(1,n)` como `x[None,:]` o simplemente `x[None]`\n",
    "\n",
    "Un arreglo de dos dimensiones puede ser convertido a uno de una dimensión usando el método `flatten`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tamaño de x: (4,)\n",
      "Tamaño del vector columna: (4, 1)\n",
      "Tamaño del vector fila: (1, 4)\n",
      "\n",
      "Tamaño de v: (1, 3)\n",
      "Tamaño del arreglo unidimensional: (3,)\n"
     ]
    }
   ],
   "source": [
    "# De arreglo unidimensional a vector fila o columna\n",
    "x = np.array([10, 20, 30, 40])      # Arreglo unidimensional (4,)\n",
    "print(\"Tamaño de x:\", x.shape)\n",
    "# Conversión a vector columna \n",
    "x1 = x[:,None]                      # Equivalente a x.reshape(3,1)\n",
    "print(\"Tamaño del vector columna:\", x1.shape)\n",
    "# Conversión a vector fila\n",
    "x2 = x[None,:]                      # Equivalente a x.reshape(1,3) o x[None]\n",
    "print(\"Tamaño del vector fila:\", x2.shape)\n",
    "\n",
    "# De arreglo bidimensional (vector fila o columna) a arreglo unidimensional\n",
    "v = np.array([[10, 20, 30]])\n",
    "print(\"\\nTamaño de v:\", v.shape)\n",
    "# Conversión a arreglo unidimensional\n",
    "v0 = v.flatten()\n",
    "print(\"Tamaño del arreglo unidimensional:\", v0.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Algunos Arreglos Especiales\n",
    "\n",
    "Algunas funciones para crear arreglos especiales son: `zeros` (para matrices de ceros), `ones` (para matrices de unos), `full` (para matrices con un valor constante), `eye` (para matrices identidad), `random.random` (para matrices aleatorias)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.zeros((2,2)):\n",
      " [[0. 0.]\n",
      " [0. 0.]]\n",
      "np.ones((1,2)):\n",
      " [[1. 1.]]\n",
      "np.full((3,2), 7):\n",
      " [[7 7]\n",
      " [7 7]\n",
      " [7 7]]\n",
      "np.eye(3):\n",
      " [[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "np.random.random((2,4)):\n",
      " [[0.2845032  0.34818652 0.26697219 0.46223605]\n",
      " [0.28954808 0.51249734 0.47510142 0.18521304]]\n"
     ]
    }
   ],
   "source": [
    "A1 = np.zeros((2,2))   # Crea una matriz de tamaño (2 x 2) con ceros\n",
    "print(\"np.zeros((2,2)):\\n\", A1)\n",
    "\n",
    "A2 = np.ones((1,2))    # Crea una matriz de unos de tamaño (1 x 2)\n",
    "print(\"np.ones((1,2)):\\n\", A2)\n",
    "\n",
    "A3 = np.full((3,2), 7)  # Crea una matriz constante con \"7\"s de tamaño (3 x 2)\n",
    "print(\"np.full((3,2), 7):\\n\", A3)\n",
    "\n",
    "A4 = np.eye(3)         # Crea una matriz identidad de 3 x 3\n",
    "print(\"np.eye(3):\\n\", A4)\n",
    "\n",
    "A5 = np.random.random((2,4))  # Crea una matriz aleatoria de 2x4\n",
    "print(\"np.random.random((2,4)):\\n\", A5) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 Tipos de Datos\n",
    "\n",
    "Cada arreglo de NumPy es un conjunto de elementos del mismo tipo. NumPy provee diferentes tipos de datos que se puede utilizar para la creación de arreglos, y trata de adivinar el tipo de dato deseado al momento de crear el arreglo. Sin embargo, se puede también indicar de manera explícita el tipo de dato a través del arcumento `dtype`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tipo de dato de x: int32\n",
      "Tipo de dato de y: float64\n",
      "Tipo de dato de z: int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2])       # NumPy adivina el tipo de dato\n",
    "print(\"Tipo de dato de x:\", x.dtype)\n",
    "\n",
    "y = np.array([1.0, 2.0])   # NumPy adivina el tipo de dato\n",
    "print(\"Tipo de dato de y:\", y.dtype)             \n",
    "\n",
    "# En el siguiente arreglo se indica explícitamente el tipo de dato: int64\n",
    "z = np.array([1, 2], dtype=np.int64) \n",
    "print(\"Tipo de dato de z:\", z.dtype)                       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Indexamiento\n",
    "\n",
    "### 2.1 Slicing\n",
    "\n",
    "Al igual que con listas de Python, se puede seleccionar un conjunto de datos de un arreglo Numpy (llamado \"slice\"). Debido a que en este caso los arreglos pueden ser de varias dimensiones, se debe especificar los límites (inicio y fin) para cada dimensión.\n",
    "\n",
    "Cuando se realiza \"slicing\", el arreglo resultante siempre será un subarreglo del arreglo inicial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz A:\n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "Submatriz B=A[:2, 1:3]:\n",
      " [[2 3]\n",
      " [6 7]]\n",
      "Matriz B modificada:\n",
      " [[ 2  3]\n",
      " [ 6 50]]\n",
      "Matriz A resultante:\n",
      " [[ 1  2  3  4]\n",
      " [ 5  6 50  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "print(\"Matriz A:\\n\", A)\n",
    "\n",
    "# Sub-matriz\n",
    "B = A[:2, 1:3]    # Toma las filas 0, 1 (excluyendo a 2), y las columnas 1, 2 (excluyendo a 3)\n",
    "print(\"Submatriz B=A[:2, 1:3]:\\n\", B)\n",
    "\n",
    "# Una submatriz es una vista de los mismos datos, así que modificarla modificará\n",
    "# también la matriz inicial\n",
    "B[1, 1] = 50     # B[1,1] contiene la misma información que A[1, 2]\n",
    "print(\"Matriz B modificada:\\n\", B)\n",
    "print(\"Matriz A resultante:\\n\", A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede mezclar índices enteros con \"slices\" (indices de tipo i:j). Sin embargo, al hacerlo así se obtendrá un arreglo de menor dimensión que el arreglo original. \n",
    "\n",
    "Este comportamiento es diferente de la forma en la que MATLAB u Octave realizan este proceso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz A:\n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "Resultado de: A[1:2,:]: [[5 6 7 8]] , tamaño: (1, 4)\n",
      "Resultado de: A[1,:]: [5 6 7 8] , tamaño: (4,)\n",
      "\n",
      "Resultado de: A[:, 1:2]:\n",
      " [[ 2]\n",
      " [ 6]\n",
      " [10]] \n",
      "     ->tamaño: (3, 1)\n",
      "Resultado de: A[:, 1]:\n",
      " [ 2  6 10] \n",
      "     ->tamaño: (3,)\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "print(\"Matriz A:\\n\", A)\n",
    "\n",
    "# Dos maneras de acceder a los datos de la fila central de la matriz A:\n",
    "# 1. Si se usa solo \"slices\", se obtiene un arreglo de la misma dimensión (2)\n",
    "f1_dim2 = A[1:2, :]  # Fila 1 (no incluye a 2) y todas las columnas: dimensión 2\n",
    "print(\"\\nResultado de: A[1:2,:]:\", f1_dim2, \", tamaño:\", f1_dim2.shape)\n",
    "# 2. Si se mezcla un entero con un \"slice\", se obtiene un arreglo de dimensión menor (1)\n",
    "f1_dim1 = A[1, :]    # Fila 1 y todas las columnas: dimensión 1\n",
    "print(\"Resultado de: A[1,:]:\", f1_dim1, \", tamaño:\", f1_dim1.shape)\n",
    "\n",
    "# Se puede realizar lo mismo con el acceso a columnas\n",
    "c1_dim2 = A[:, 1:2]\n",
    "c1_dim1 = A[:, 1]\n",
    "print(\"\\nResultado de: A[:, 1:2]:\\n\", c1_dim2, \"\\n     ->tamaño:\", c1_dim2.shape)\n",
    "print(\"Resultado de: A[:, 1]:\\n\", c1_dim1, \"\\n     ->tamaño:\", c1_dim1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. Indexamiento con Arreglos Enteros\n",
    "\n",
    "Este tipo de Indexamiento permite construir arreglos arbitrarios usando los datos de otro arreglo. Para el caso de arreglos bidimensionales (matrices), consiste en utilizar dos arreglos como índices: el primer arreglo indica las filas, y el segundo arreglo indica las columnas.\n",
    "\n",
    "Por ejemplo, si se desea obtener los elementos en las posiciones `[f1,c1]`, `[f2,c2]`, `[f3,c3]`, de una matriz `A`, donde \"f\" representa fila y \"c\" columna, se indexa como: `A[[f1,f2,f3],[c1,c2,c3]]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      " [[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "B1: [1 4 5]\n",
      "B2: [1 4 5]\n",
      "C1: [2 2]\n",
      "C2: [2 2]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print(\"A:\\n\", A)\n",
    "\n",
    "# Extracción término a término (elementos [0,0], [1,1], [2,0] de A)\n",
    "B1 = np.array([A[0, 0], A[1, 1], A[2, 0]])\n",
    "# Usando indexamiento con arreglos enteros, B2 es equivalente a B1. El tamaño resultante es (3,)\n",
    "B2 = A[[0, 1, 2], [0, 1, 0]]\n",
    "\n",
    "print(\"B1:\", B1)\n",
    "print(\"B2:\", B2)\n",
    "\n",
    "# Se puede reusar elementos del arreglo inicial\n",
    "C1 = A[[0, 0], [1, 1]]\n",
    "C2 = np.array([A[0, 1], A[0, 1]])    # Equivalente a C1\n",
    "print(\"C1:\", C1)\n",
    "print(\"C2:\", C2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una operación útil al indexar con arreglos enteros consiste en seleccionar (o modificar) un elemento de cada fila de una matriz. Para ello, se utiliza `np.arange` para las filas, y se selecciona las columnas deseadas de cada fila (una sola columna por fila)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      " [[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "Índices de las filas: [0 1 2 3]\n",
      "Índices de las columnas: [0 2 0 1]\n",
      "B: [ 1  6  7 11]\n",
      "Matriz A modificada:\n",
      " [[ 100    2    3]\n",
      " [   4    5  600]\n",
      " [ 700    8    9]\n",
      " [  10 1100   12]]\n"
     ]
    }
   ],
   "source": [
    "# Arreglo inicial\n",
    "A = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print(\"A:\\n\", A)\n",
    "\n",
    "# Arreglo que indica el número de columna que se utilizará para cada fila (una columna por fila)\n",
    "fs = np.arange(4)             # Índices de las filas\n",
    "cs = np.array([0, 2, 0, 1])   # Índices de las columnas\n",
    "# Selección de un elemento de cada fila usando los índices de cs\n",
    "B = A[fs, cs]\n",
    "print(\"Índices de las filas:\", fs)\n",
    "print(\"Índices de las columnas:\", cs)\n",
    "print(\"B:\", B)\n",
    "\n",
    "# Modificar un elemento de cada fila usando los índices de cs\n",
    "A[fs, cs] *= 100\n",
    "print(\"Matriz A modificada:\\n\", A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. Indexamiento con Arreglos Booleanos\n",
    "\n",
    "Este tipo de indexamiento permite seleccionar elementos arbitrarios de un arreglo. Este tipo de indexamiento se utiliza con frecuencia para seleccionar elementos que satisfacen alguna condición."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      " [[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "Bool_idx:\n",
      " [[False False]\n",
      " [ True  True]\n",
      " [ True  True]]\n",
      "A[bool_idx]: [3 4 5 6]\n",
      "A[A > 2]: [3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print(\"A:\\n\", A)\n",
    "\n",
    "# Índices Booleanos para encontrar elementos que son mayores a 2\n",
    "bool_idx = (A > 2)   # Contendrá un arreglo de Booleanos del mismo tamaño que A con True o False según la condición\n",
    "print(\"Bool_idx:\\n\", bool_idx)\n",
    "\n",
    "# Cuando el arreglo Booleano se usa para indexar, crea un arreglo de dimensión 1\n",
    "print(\"A[bool_idx]:\", A[bool_idx])\n",
    "\n",
    "# Se puede realizar lo anterior de forma compacta:\n",
    "print(\"A[A > 2]:\", A[A > 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Operaciones Matemáticas\n",
    "\n",
    "\n",
    "### 3.1 Operaciones Elemento a Elemento\n",
    "\n",
    "Las operaciones matemáticas básicas operan elemento a elemento, y se encuentran disponibles como una sobrecarga de operadores básicos, o como funciones del módulo NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma:\n",
      " [[ 6.  8.]\n",
      " [10. 12.]]\n",
      "Resta:\n",
      " [[-4. -4.]\n",
      " [-4. -4.]]\n",
      "Producto elemento a elemento:\n",
      " [[ 5. 12.]\n",
      " [21. 32.]]\n",
      "División elemento a elemento:\n",
      " [[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "Raíz cuadrada elemento a elemento:\n",
      " [[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "B = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "# Suma elemento a elemento\n",
    "print(\"Suma:\\n\", A + B)       # Equivalente a np.add(A, B)\n",
    "# Diferencia elemento a elemento\n",
    "print(\"Resta:\\n\", A - B)      # Equivalente a np.subtract(A, B)\n",
    "# Producto elemento a elemento\n",
    "print(\"Producto elemento a elemento:\\n\", A * B)   # Equivalente a np.multiply(A, B)\n",
    "# División elemento a elemento\n",
    "print(\"División elemento a elemento:\\n\", A / B)    # Equivalente a np.divide(A, B)\n",
    "# Raíz cuadrada elemento a elemento\n",
    "print(\"Raíz cuadrada elemento a elemento:\\n\", np.sqrt(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Multiplicación\n",
    "\n",
    "A diferencia de MATLAB, Octave, o Scilab, al utilizar `*` se obtiene una multiplicación término a término, no una multiplicación matricial. Con NumPy, para realizar multiplicaciones matriciales se utiliza `dot`, el cual se encuentra disponible como función, o como un método de los arreglos.\n",
    "\n",
    "La function `np.dot` funciona de la siguiente manera:\n",
    "- Si `x`, `y` son arreglos unidimensionales de tamaño `(n,)`, `np.dot(x,y)` realiza el producto interno de vectores (y el resultado es un escalar).\n",
    "- Si `A` es una matrix de tamaño `(n, m)`, y el arreglo unidimensional `y` es de tamaño `(m,)`, la operación `np.dot(X, y)` considera a `y` como si fuera de tamaño `(m,1)`. El resultado es un arreglo unidimensional `(n,)`.\n",
    "- Si `A` es una matrix de tamaño `(n, m)`, y el arreglo unidimensional `y` es de tamaño `(n,)`, la operación `np.dot(y, X)` considera a `y` como si fuera de tamaño `(1,n)`. El resultado es un arreglo unidimensional `(m,)`.\n",
    "- En todos los demás casos `np.dot` se comporta como un producto de matriz con matriz. El tamaño del resultado es coherente con álgebra lineal.\n",
    "\n",
    "Debido a esta forma de funcionamiento de `np.dot`, en muchos casos se recomienda trabajar con arreglos bidimensionales (matrices, vectores columna, vectores fila), evitando los arreglos unidimensionales, para evitar errores o comportamientos no deseados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Producto interno: 23\n",
      "Producto matriz matriz: AB = \n",
      " [[ 58  64]\n",
      " [139 154]]\n",
      "Producto: Az = [ 44 107]\n",
      "Producto: xA = [14 19 24]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2,3],[4,5,6]])        # Tamaño (2,3)\n",
    "B = np.array([[7,8],[9,10],[11,12]])   # Tamaño (3,2)\n",
    "\n",
    "x = np.array([2,3])    # Tamaño (2,)\n",
    "y = np.array([4,5])    # Tamaño (2,)\n",
    "z = np.array([6,7,8])  # Tamaño (3,)\n",
    "\n",
    "# Producto interno de arreglos unidimensionales\n",
    "print(\"Producto interno:\", x.dot(y))                  # Equivalente a: np.dot(x, y)\n",
    "# Producto matriz/matriz (como en álgebra lineal)\n",
    "print(\"Producto matriz matriz: AB = \\n\", A.dot(B))    # Equivalente a: np.dot(A, B)\n",
    "# Producto matriz con arreglo unidimensional: (2,3)x(3,) = (2,3)x(3,1) = (2,1), pero el resultado es (2,)\n",
    "print(\"Producto: Az =\", A.dot(z))                     # Equivalente a: np.dot(A, x)\n",
    "# Producto arreglo unidimensional con matriz: (2,)x(2,3) = (1,2)x(2,3) = (1,3), pero el resultado es (3,)\n",
    "print(\"Producto: xA =\", x.dot(A))                     # Equivalente a: np.dot(A, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Otras Operaciones\n",
    "\n",
    "Numpy provee muchas funciones útiles para realizar cálculos con arreglos. Por ejemplo, la función `sum` suma los elementos (suma vertical si axis=0, suma horizonal si axis=1) del arreglo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      " [[1 2]\n",
      " [3 4]]\n",
      "Suma de todos los elementos: 10\n",
      "Suma vertical (de cada columna): [4 6]\n",
      "Suma horizontal (de cada fila) [3 7]\n",
      "Seno de A:\n",
      " [[ 0.84147098  0.90929743]\n",
      " [ 0.14112001 -0.7568025 ]]\n"
     ]
    }
   ],
   "source": [
    "# Suma de elementos\n",
    "A = np.array([[1,2],[3,4]])\n",
    "print(\"A:\\n\", A)\n",
    "\n",
    "print(\"Suma de todos los elementos:\", np.sum(A))              # Suma de todos los elementos\n",
    "print(\"Suma vertical (de cada columna):\", np.sum(A, axis=0))  # Suma de cada columna\n",
    "print(\"Suma horizontal (de cada fila)\", np.sum(A, axis=1))    # Suma de cada fila\n",
    "\n",
    "print(\"Seno de A:\\n\", np.sin(A))     # Igualmente se puede usar np.cos, np.log, np.exp, etc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A veces se requiere cambiar la forma de una matriz. Una de las operaciones más simples es obtener la transpuesta de una matrix (se usa ``comillas``), para lo cual se utiliza el atributo `T`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz A:\n",
      " [2 3]\n",
      "Transpuesta:\n",
      " [2 3]\n",
      "Valor de v: [1 2 3]\n",
      "Valor de v.T [1 2 3]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2], [3,4]])\n",
    "print(\"Matriz A:\\n\", x)\n",
    "print(\"Transpuesta:\\n\", x.T)\n",
    "\n",
    "# Notar que tomar la transpuesta de un arreglo de dimensión 1 no hace nada\n",
    "v = np.array([1,2,3])\n",
    "print(\"Valor de v:\", v)    # Prints \"[1 2 3]\"\n",
    "print(\"Valor de v.T\", v.T)  # Prints \"[1 2 3]\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Traza de A: 5\n",
      "Rango de A: 2\n",
      "Determinante de A: -2.0000000000000004\n",
      "Inversa de A:\n",
      " [[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n",
      "Pseudo-inversa de A:\n",
      " [[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n",
      "Norma L-1 de x: 6.0\n",
      "Norma L-2 de x: 3.7416573867739413\n",
      "Norma de Frobenius de A: 5.477225575051661\n"
     ]
    }
   ],
   "source": [
    "# Algunas operaciones de álgebra lineal\n",
    "A = np.array([[1,2], [3,4]])\n",
    "x = np.array([1,2,3])\n",
    "# Traza\n",
    "print(\"Traza de A:\", np.trace(A))\n",
    "# Rango\n",
    "print(\"Rango de A:\", np.linalg.matrix_rank(A))\n",
    "# Determinante\n",
    "print(\"Determinante de A:\", np.linalg.det(A))\n",
    "# Inversa:\n",
    "print(\"Inversa de A:\\n\", np.linalg.inv(A))\n",
    "# Pseudo-inversa de Moore-Penrose:\n",
    "print(\"Pseudo-inversa de A:\\n\", np.linalg.pinv(A))\n",
    "# Norma de un vector (o matriz)\n",
    "print(\"Norma L-1 de x:\", np.linalg.norm(x,1))\n",
    "print(\"Norma L-2 de x:\", np.linalg.norm(x))\n",
    "print(\"Norma de Frobenius de A:\", np.linalg.norm(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.dot(L, L.T):\n",
      " [[2. 1.]\n",
      " [1. 4.]]\n",
      "USV^T:\n",
      " [[2. 1.]\n",
      " [1. 4.]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2,1], [1,4]])\n",
    "# Descomposición de Cholelsky (L*L^T=A)\n",
    "L = np.linalg.cholesky(A)\n",
    "print(\"np.dot(L, L.T):\\n\", np.dot(L, L.T))\n",
    "# Descomposición SVD\n",
    "U, S, V = np.linalg.svd(A)\n",
    "S = np.diag(S)\n",
    "print(\"USV^T:\\n\", U.dot(S).dot(V.T))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Autovalores: [-0.37228132  5.37228132]\n",
      "Autovectores:\n",
      " [[-0.82456484 -0.41597356]\n",
      " [ 0.56576746 -0.90937671]]\n",
      "Av = \n",
      " [[ 0.30697009 -2.23472698]\n",
      " [-0.21062466 -4.88542751]]\n",
      "lambda*v =\n",
      " [[ 0.30697009 -2.23472698]\n",
      " [-0.21062466 -4.88542751]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2], [3,4]])\n",
    "# Autovalores (Av = lb*v)\n",
    "lb, v = np.linalg.eig(A)\n",
    "print(\"Autovalores:\", lb)\n",
    "print(\"Autovectores:\\n\", v)\n",
    "print(\"Av = \\n\", A.dot(v))\n",
    "print(\"lambda*v =\\n\", lb*v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la documentación de NumPy se puede consultar la lista completa de funciones matemáticas que NumPy provee."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Broadcasting\n",
    "\n",
    "Broadcasting es un mecanismo potente que permite a numpy trabajar con arreglos de diferentes tamaños al realizar operaciones aritméticas. Frecuentemente se tiene un arreglo grande y uno pequeño, y se desea usar el pequeño múltiples veces para realizar alguna operación con el arreglo grande. El broadcasting en general se debe utilizar en la medida de lo posible para evitar los bucles, debido a que si se tiene una matriz muy grande, realizar un bucle puede ser muy lento.\n",
    "\n",
    "Un ejemplo de \"broadcasting\" se da cuando se desea añadir un vector constante a cada fila de una matriz. Otro ejemplo, muy frecuente, ocurre cuando se desea añadir una constante a cada elemento de una matriz o de un vector.\n",
    "\n",
    "A continuación se mostrará un ejemplo donde no se realiza \"broadcasting\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      " [[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "x: [100   0 300]\n",
      "Sin broadcasting A+x:\n",
      " [[101   2 303]\n",
      " [104   5 306]\n",
      " [107   8 309]\n",
      " [110  11 312]]\n",
      "X:\n",
      " [[100   0 300]\n",
      " [100   0 300]\n",
      " [100   0 300]\n",
      " [100   0 300]]\n",
      "Sin broadcasting A+X:\n",
      " [[101   2 303]\n",
      " [104   5 306]\n",
      " [107   8 309]\n",
      " [110  11 312]]\n"
     ]
    }
   ],
   "source": [
    "# Se añadirá el vector x a cada fila de la matriz A, almacenando el resultado en la matriz y\n",
    "A = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "x = np.array([100, 0, 300])\n",
    "y = np.empty_like(A)            # Matriz vacía con el mismo tamaño que A\n",
    "print(\"A:\\n\", A)\n",
    "print(\"x:\", x)\n",
    "\n",
    "# Sin broadcasting (forma 1): se tiene que usar un bucle para añadir x a cada fila\n",
    "for i in range(4):\n",
    "    y[i, :] = A[i, :] + x\n",
    "print(\"Sin broadcasting A+x:\\n\", y)\n",
    "\n",
    "# Sin broadcasting(forma 2): primero se crea una matriz que contiene x como sus filas\n",
    "X = np.tile(x, (4, 1))   # Almacena 4 copias de x, una \"sobre\" la otra\n",
    "y = A + X                # Suma A y la matriz X que contiene copias de x\n",
    "print(\"X:\\n\", X)\n",
    "print(\"Sin broadcasting A+X:\\n\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El \"broadcasting\" de NumPy permite realizar una operación similar a la \"forma 2\" anterior pero de manera directa, sin crear múltiples copias de un vector (en el caso anterior, sin necesidad de crear la matriz X a partir del vector x). En este caso, y = A + x funcionará a pesar de que el tamaño de A es (4, 3) y el tamaño de v es (3,). Debido al \"broadcasting\", esta línea funciona como si x tuviese tamaño (4,3), donde cada fila es una copia de x, y la suma se realiza elemento a elemento (como en la forma 2 sin broadcasting)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Con broadcasting, A+x:\n",
      " [[101   2 303]\n",
      " [104   5 306]\n",
      " [107   8 309]\n",
      " [110  11 312]]\n"
     ]
    }
   ],
   "source": [
    "# Usando broadcasting\n",
    "A = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "x = np.array([100, 0, 300])\n",
    "y = A + x           # Se realiza la suma de manera \"directa\".\n",
    "print(\"Con broadcasting, A+x:\\n\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones que soportan broadcasting se llaman \"universales\". Se puede encontrar una lista de todas las funciones universales en la documentación de NumPy.\n",
    "\n",
    "Algunos otros ejemplos de \"broadcasting\" son los siguientes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A+x:\n",
      " [[101 202 303]\n",
      " [104 205 306]]\n",
      "(A.T + x2).T:\n",
      " [[101 102 103]\n",
      " [204 205 206]]\n",
      "A + np.reshape(x2,(2, 1)):\n",
      " [[101 102 103]\n",
      " [204 205 206]]\n",
      "A+20:\n",
      " [[21 22 23]\n",
      " [24 25 26]]\n"
     ]
    }
   ],
   "source": [
    "# Añadir un vector a cada fila de una matriz\n",
    "A = np.array([[1,2,3], [4,5,6]])   # tamaño (2,3)\n",
    "x = np.array([100,200,300])        # tamaño (3,)\n",
    "# Al sumarlos se realiza broadcasting a (2,3)\n",
    "print(\"A+x:\\n\", A + x)\n",
    "\n",
    "# Añadir un vector a cada columna de una matriz\n",
    "x2 = np.array([100, 200])           # Tamaño (2,)\n",
    "# Alternativa 1: \n",
    "# Transponer A para tener tamaño (3,2), sumarlo, y transponerlo nuevamente para recuperar el tamaño (2,3) original\n",
    "print(\"(A.T + x2).T:\\n\", (A.T + x2).T)\n",
    "# Alternativa 2: \n",
    "# Convertir x2 a tamaño (2,1) y sumarlo directamente\n",
    "print(\"A + np.reshape(x2,(2, 1)):\\n\",  A + np.reshape(x2, (2, 1)))\n",
    "\n",
    "# Sumar una matriz (o vector) con una constante\n",
    "print(\"A+20:\\n\", A+20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para más detalles de NumPy, ver la referencia: http://docs.scipy.org/doc/numpy/reference/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}