3_numpy/3_2_operaciones_matematicas_y_estadistica.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operaciones Matemáticas y Estadística"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones entre arrays y escalares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Las operaciones entre arrays y escalares se hacen término a término"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  6],\n",
       "       [ 8, 10, 12]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.5       , 0.33333333],\n",
       "       [0.25      , 0.2       , 0.16666667]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4,  9],\n",
       "       [16, 25, 36]], dtype=int32)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones de broadcasting entre arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Los arrays tienen que tener la misma longitud al menos en una de sus dimensiones\n",
    "- Pueden operar siempre que sean compatibles con el broadcasting:\n",
    "    - El rango de ambos es el mismo\n",
    "    - El tamaño en cada dimensión o es igual, o es 1 para cada uno de ellos\n",
    "<center>\n",
    "<img src=\"imgs/np_4.png\"  alt=\"drawing\" width=\"70%\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- El (3,) en broadcasting se interpreta como (3,1), y el número 5 se interpreta con dimensiones (1,1)\n",
    "- Las dimensiones cumplen la condición de que tienen una dimensión que es 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3) + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Aquí se cumple la condición de que ambos tienen una dimensión que es 1, tenemos (3,1) y (1,3)\n",
    "    - Lo que hace que tengamos de dimensiones (3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [1, 2, 3],\n",
       "       [2, 3, 4]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3).reshape(1,3) + np.arange(3).reshape(3,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Esto se puede cumplir de multiples formas, aquí otro ejemplo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5],\n",
       "        [ 6,  7,  8]],\n",
       "\n",
       "       [[ 9, 10, 11],\n",
       "        [12, 13, 14],\n",
       "        [15, 16, 17]],\n",
       "\n",
       "       [[18, 19, 20],\n",
       "        [21, 22, 23],\n",
       "        [24, 25, 26]]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(27).reshape(3,3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3).reshape(3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 4,  5,  6],\n",
       "        [ 8,  9, 10]],\n",
       "\n",
       "       [[ 9, 10, 11],\n",
       "        [13, 14, 15],\n",
       "        [17, 18, 19]],\n",
       "\n",
       "       [[18, 19, 20],\n",
       "        [22, 23, 24],\n",
       "        [26, 27, 28]]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(27).reshape(3,3,3) + np.arange(3).reshape(3,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones matemáticas con arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Vamos a probar distintos tipos de funciones, así como operaciones entre arrays\n",
    "- Las operaciones entre arrays deben de cumplir las condiciones de broadcasting\n",
    "- Se pueden ver todas las funciones disponibles [aquí](https://numpy.org/doc/stable/reference/routines.math.html)\n",
    "- Las más usadas son:\n",
    "\n",
    "|Función|Descripcción|\n",
    "|----|---|\n",
    "|`abs, fabs`| Valor absoluto.|\n",
    "|`sqrt`| Raíz cuadrada (equivalente a array \\*\\* 0.5).|\n",
    "|`square`| Potencia al cuadrado (equivalente a array ** 2).|\n",
    "|`exp`| Potencia de e.|\n",
    "|`log, log10, log2, log1p`| Logaritmos en distintas bases.|\n",
    "|`ceil`| Techo.|\n",
    "|`floor`| Suelo.|\n",
    "|`rint`| Redondeo al entero más cercano.|\n",
    "|`modf`| Devuelve dos arrays uno con la parte fraccionaria y otro con la parte entera.|\n",
    "|`isnan`| Devuelve un array booleano indicando si el valor es NaN o no.|\n",
    "|`isfinite, isinf`| Devuelve un array booleano indicando si el valor es finito o no.|\n",
    "|`cos, cosh, sin, sinh, tan, tanh`| Funciones trigonométricas.|\n",
    "|`arccos, arccosh, arcsin, arcsinh, arctan, arctanh`| Funciones trigonométricas inversas.|\n",
    "|`logical_not`| Inverso booleano de todos los valores del array (equivalente a -(array)).|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5]\n",
      "[ 6  7  8  9 10 11]\n"
     ]
    }
   ],
   "source": [
    "array_1 = np.arange(6)\n",
    "array_2 = np.arange(6,12)\n",
    "print(array_1)\n",
    "print(array_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6,  8, 10, 12, 14, 16])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1 + array_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  7, 16, 27, 40, 55])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1 * array_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([       0,        1,      256,    19683,  1048576, 48828125],\n",
       "      dtype=int32)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1 ** array_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ahora vamos a ver distintas funciones, que son muy utilizadas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25], dtype=int32)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1 = np.arange(6)**2\n",
    "array_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(array_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 1.57079633, 3.14159265, 4.71238898, 6.28318531])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_2 = np.linspace(0, 2*np.pi, 5)\n",
    "array_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.0000000e+00,  1.0000000e+00,  1.2246468e-16, -1.0000000e+00,\n",
       "       -2.4492936e-16])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(array_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones incorporadas en arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Los arrays llevan incorporadas funciones (métodos) tanto matemáticas como estadísticas.\n",
    "- Todos los métodos de los arrays se pueden consultar [aquí](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html)\n",
    "\n",
    "|Función|Descripcción|\n",
    "|----|---|\n",
    "|`sum`| Suma de elementos.|\n",
    "|`mean`| Media aritmética de los elementos.|\n",
    "|`median`| Mediana de los elementos.|\n",
    "|`std`| Desviación estándar de los elementos.|\n",
    "|`var`| Varianza de los elementos.|\n",
    "|`min`| Valor mínimo de los elementos.|\n",
    "|`max`| Valor máximo de los elementos.|\n",
    "|`argmin`| Índice del valor mínimo.|\n",
    "|`argmax`| Índice del valor máximo.|\n",
    "|`cumsum`| Suma acumulada de los elementos.|\n",
    "|`cumprod`| Producto acumulado de los elementos.|\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1 = np.arange(6)\n",
    "array_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1** Crea un array con los numeros del 0 al 100:\n",
    "    - crea una variable con los anteriores valores en forma de matriz 10x10\n",
    "    - multiplica el primer vector término a término por 5\n",
    "    - saca la media y la desviación estándar del primer vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2** Genera un array aleatorio de 100 posiciones y muestra los cuantiles 95 y 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3**  Crea una función que sume el valor absoluto de todos los elementos negativos de una matriz recibida como parámetro. O devuelva \"No hay negativos\" en caso de que no los haya."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.8 ('base')",
   "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"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3a2a03ea413f8be244ba01daf0e257f98f0dabeb03c7836e7000a0f3738aa8c9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}