3_Librerías_para_cómputo_científico.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "TzJ4wQ6xhSzh",
   "metadata": {
    "id": "TzJ4wQ6xhSzh"
   },
   "source": [
    "<center>\n",
    "    \n",
    "    \n",
    "# Curso de Python básico\n",
    "## Instituto Mexicano del Petróleo\n",
    "\n",
    "### Dra. Gabriela Berenice Díaz Cortés (gbdiaz@imp.mx)\n",
    "\n",
    "### Dr. Luis Antonio López Peña (llopezp@imp.mx) \n",
    "\n",
    "#### Dirección de Investigación en Exploración y Producción\n",
    "#### Gerencia de Ingeniería de Yacimientos\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50a5c995",
   "metadata": {
    "id": "50a5c995"
   },
   "source": [
    "# Librerías\n",
    "Como se mencionó anteriormente, las librerias son conjuntos de funciones específicas, algunas de ellas son:\n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/f2031a840a330db98a65ac392e85a34acd040904/wrapper.png?raw=1\" width=\"600\">\n",
    "    \n",
    "\n",
    "## Instalación de librerías en equipo local\n",
    "Se puede crear el **entorno virtual** instalando desde la creación las librerías o crear el entorno virtual e ir añadiendo las librerías. Por temas de compatibilidad es recomendado crear el environment con todas las librerías requeridas.\n",
    "\n",
    "En windows o linux se abre la terminal (*Anaconda Prompt* en windows), y se siguen los siguientes pasos:\n",
    "\n",
    "\n",
    "1.   Crear entorno virtual con librerías: \n",
    "\n",
    "`\\$conda create -n my_env python=3.5 numpy sympy`\n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/933cad2a83e4b2ca815eea6dbf80faedc77e7f33/anaconda_promt.png?raw=1\" width=\"600\">\n",
    "\n",
    "2.   Activar entorno virtual:\n",
    "\n",
    "`\\$conda activate my_env`\n",
    "\n",
    "3.   Instalar más librerías:\n",
    "\n",
    "`(my_env)\\$conda install sympy`\n",
    "\n",
    "4.   Instalar jupyter-notebook:\n",
    "\n",
    "`(my_env)\\$conda install -c conda-forge jupyterlab`\n",
    "\n",
    "5.   Abrir jupyter-notebook:\n",
    "\n",
    "`(my_env)\\$jupyter-notebook`\n",
    "\n",
    "\n",
    "\n",
    "## Instalar librerías en Anaconda navigator\n",
    "\n",
    "Se selecciona el entorno virtual y se buscan las librerías requeridas\n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/6a8676672527a82efef51a8598ffd84c9255b71c/libreria.png?raw=1\" width=\"600\">\n",
    "    \n",
    "\n",
    "Se instalan las librerías requeridas\n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/4a3ec3fde040e6181b82be8d9382c7321e031b43/install_libreria.png?raw=1\" width=\"600\">\n",
    "\n",
    "## Sympy\n",
    "\n",
    "Para llamar la librería de cálculo simbolico [sympy], esta se importa como sigue \n",
    "\n",
    "\\begin{array}{llL} \n",
    "import  & \\text{sympy }            &    as &   \\text{ sp}\\\\ \n",
    "\\end{array}\n",
    "\n",
    "Su propósito es realizar cálculos de manera simbolica, es decir con variables que no tienen un valor definido de la forma mas sencilla posible, estas variables simbolicas se tienen que declarar de forma explícita.\n",
    "\n",
    "Esta librería es capas de simplificar expresiones, calcular derivadas, integrales, limites, resolver ecuaciones, trabajar con matrices, etc.\n",
    "\n",
    "[sympy]: https://www.sympy.org/en/index.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "733bd054",
   "metadata": {
    "id": "733bd054"
   },
   "outputs": [],
   "source": [
    "from sympy import symbols\n",
    "x, y = symbols('x y')\n",
    "expr = x + 2*y\n",
    "expr\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c3c2002",
   "metadata": {
    "id": "3c3c2002"
   },
   "outputs": [],
   "source": [
    "expr + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6168bad",
   "metadata": {
    "id": "f6168bad"
   },
   "outputs": [],
   "source": [
    "expr - x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32146406",
   "metadata": {
    "id": "32146406"
   },
   "outputs": [],
   "source": [
    "x*expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a431e05",
   "metadata": {
    "id": "5a431e05"
   },
   "outputs": [],
   "source": [
    "from sympy import expand, factor\n",
    "expanded_expr = expand(x*expr)\n",
    "expanded_expr\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e4bbe76",
   "metadata": {
    "id": "4e4bbe76"
   },
   "outputs": [],
   "source": [
    "factor(expanded_expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4680c4bf",
   "metadata": {
    "id": "4680c4bf"
   },
   "source": [
    "### Integrales\n",
    "\n",
    "\n",
    "$\\int(e^x sin(x)+e^x cos(x))dx$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fb401b0",
   "metadata": {
    "id": "3fb401b0"
   },
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "x, t, z, nu = symbols('x t z nu')\n",
    "integrate(exp(x)*sin(x) + exp(x)*cos(x), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72a7281e",
   "metadata": {
    "id": "72a7281e"
   },
   "source": [
    "$\\int_{-\\infty}^{\\infty}(sin(x^2)dx$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6a6e713",
   "metadata": {
    "id": "e6a6e713"
   },
   "outputs": [],
   "source": [
    "integrate(sin(x**2), (x, -oo, oo))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93474107",
   "metadata": {
    "id": "93474107"
   },
   "source": [
    "### Derivadas\n",
    "\n",
    "\n",
    "$\\frac{d(e^x sin(x))}{dx}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2baf2bc",
   "metadata": {
    "id": "a2baf2bc"
   },
   "outputs": [],
   "source": [
    "diff(sin(x)*exp(x), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19dbb01c",
   "metadata": {
    "id": "19dbb01c"
   },
   "source": [
    "### Limites\n",
    "\n",
    "$lim_{x\\rightarrow 0} \\frac{sin(x)}{x}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1eb86be0",
   "metadata": {
    "id": "1eb86be0"
   },
   "outputs": [],
   "source": [
    "limit(sin(x)/x, x, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78b25a9e",
   "metadata": {
    "id": "78b25a9e"
   },
   "source": [
    "### Solución de ecuaciones\n",
    "\n",
    "$x^2-2=0$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6660820",
   "metadata": {
    "id": "b6660820"
   },
   "outputs": [],
   "source": [
    "solve(x**2 - 2, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b6a697e",
   "metadata": {
    "id": "6b6a697e"
   },
   "source": [
    "$y''-y = e^t$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9a67a20",
   "metadata": {
    "id": "a9a67a20"
   },
   "outputs": [],
   "source": [
    "y = Function('y')\n",
    "dsolve(Eq(y(t).diff(t, t) - y(t), exp(t)), y(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b8ce4e8",
   "metadata": {
    "id": "7b8ce4e8"
   },
   "source": [
    "### Imprimir usando latex \n",
    "\n",
    "\n",
    "$\\int_0 ^{\\pi} cos(x)^2dx$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7ee76ff",
   "metadata": {
    "id": "e7ee76ff"
   },
   "outputs": [],
   "source": [
    "print(latex(Integral(cos(x)**2, (x, 0, pi))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lt7hhJ0p5gJe",
   "metadata": {
    "id": "lt7hhJ0p5gJe"
   },
   "source": [
    "# Challenge break\n",
    "### 1\n",
    "Crea las siguientes variables de manera simbólica\n",
    "\n",
    "$z = 3x + 8y + 2xy + x^2 + y^2$\n",
    "\n",
    "$w = 7x + 2y + 2xy + x^2 + y^2$\n",
    "\n",
    "suma ambas expresiones y simplificalas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "AWf0HDS_6zpT",
   "metadata": {
    "id": "AWf0HDS_6zpT"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "23a28fd3",
   "metadata": {
    "id": "23a28fd3"
   },
   "source": [
    "### 2\n",
    "Resolver la siguiente ecuación para x y y con sympy\n",
    "\n",
    "$x + 5y - 2, -3x + 6y - 15$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb6a7199",
   "metadata": {
    "id": "bb6a7199"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1d8477d4",
   "metadata": {
    "id": "1d8477d4"
   },
   "source": [
    "\n",
    "## Numpy \n",
    "\n",
    "\n",
    "Con la librería de [numpy] se pueden crear vectores y matrices de la siguiente forma:\n",
    "\n",
    "\n",
    "* Vector con N entradas \n",
    "\n",
    "    `x = np.array([1, 2, ..., N])`\n",
    "\n",
    "* Vector en un intervalo dado [init,fin] en pasos de tamaño step, si el paso es 1 se puede omitir el step \n",
    "\n",
    "    `x = np.array(init,fin,step) `\n",
    "\n",
    "    `x = np.array(init,fin)` \n",
    " \n",
    "* Vector con N ceros    \n",
    "\n",
    "    `x = np.zeros(N)`\n",
    "\n",
    "\n",
    "* Vector con N unos  \n",
    "\n",
    "   ` x = np.ones(N)`\n",
    "    \n",
    "    \n",
    "* Matriz con (N,N) entradas \n",
    "\n",
    "   `A = np.array(([1, 2, ..., N],[1, 2, ..., N],[1, 2, ..., N],[1, 2, ..., N]))`\n",
    "\n",
    "[numpy]: https://www.numpy.org/devdocs/user/quickstart.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c8b28b3",
   "metadata": {
    "id": "8c8b28b3"
   },
   "outputs": [],
   "source": [
    "# Ejemplos\n",
    "import numpy as np\n",
    "N = 4\n",
    "\n",
    "# Vector con 4 entradas distintas de cero\n",
    "x = np.array([1, 2, 3, 4])    \n",
    "print('x = {}'.format(x))\n",
    "print('tTipo de variable: {}'.format(type(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "090e3563",
   "metadata": {
    "id": "090e3563"
   },
   "outputs": [],
   "source": [
    "# Vector con 4 entradas iguales a cero\n",
    "x = np.zeros(N)\n",
    "print('x = {}'.format(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c0d5441",
   "metadata": {
    "id": "2c0d5441"
   },
   "outputs": [],
   "source": [
    "# Vector con 4 entradas iguales a uno\n",
    "x = np.ones(N)\n",
    "print('x = {}'.format(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67dacc9f",
   "metadata": {
    "id": "67dacc9f"
   },
   "outputs": [],
   "source": [
    "# Vector con numeros enteros del 0 al 15\n",
    "x = np.arange(0,15)\n",
    "print('x = {}'.format(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccc46d32",
   "metadata": {
    "id": "ccc46d32"
   },
   "outputs": [],
   "source": [
    "# Vector conmultiplos de 5 del 0 al 100\n",
    "x = np.arange(0,100,5)\n",
    "print('x = {}'.format(x))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "CGMSRYVy4vWL",
   "metadata": {
    "id": "CGMSRYVy4vWL"
   },
   "outputs": [],
   "source": [
    "# Vector con 4 entradas aleatorias\n",
    "x = np.random.random(N)\n",
    "print('x = {}'.format(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd7c109f",
   "metadata": {
    "id": "bd7c109f"
   },
   "outputs": [],
   "source": [
    "# Seleccionar un elemento del vector x\n",
    "x_0 = x[0]\n",
    "print('x = {}'.format(x_0))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8223b4c",
   "metadata": {
    "id": "c8223b4c"
   },
   "outputs": [],
   "source": [
    "# Invertir el vector x\n",
    "x_1 = x[::-1]\n",
    "print('x = {}'.format(x_1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d6a902d",
   "metadata": {
    "id": "5d6a902d"
   },
   "outputs": [],
   "source": [
    "# Encontrar los indices que no son ceros de un vector\n",
    "x = np.array([1,2,4,2,4,0,1,0,0,0,12,4,5,6,7,0])\n",
    "nz = np.argwhere( x!=0 )\n",
    "print('El vector x = {} no es cero en:\\n nz = {}'.format(x,nz))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9832f554",
   "metadata": {
    "id": "9832f554"
   },
   "outputs": [],
   "source": [
    "print('x[1] = {}'.format(x[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5873e991",
   "metadata": {
    "id": "5873e991"
   },
   "outputs": [],
   "source": [
    "# Crear una matriz 3x3 con valores de 0 a 8\n",
    "A = np.arange(0,9).reshape(3,3)\n",
    "print('A = \\n{}'.format(A))\n",
    "print('Tipo de variable: {}'.format(type(A)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba7c3c49",
   "metadata": {
    "id": "ba7c3c49"
   },
   "outputs": [],
   "source": [
    "# Matrix de cuatro por cuatro\n",
    "A = np.array(([1, 2, 3, 4],[1, 2, 3, 4],[1, 2, 3, 4],[1, 2, 3, 4]))\n",
    "print('A = \\n{}'.format(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01b0f9e4",
   "metadata": {
    "id": "01b0f9e4"
   },
   "outputs": [],
   "source": [
    "# Matriz identidad de 3x3\n",
    "A = np.identity(3)\n",
    "print('A = \\n{}'.format(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c00280d",
   "metadata": {
    "id": "5c00280d"
   },
   "outputs": [],
   "source": [
    "# Matriz de numeros aleatorios de 3x3x3\n",
    "A = np.random.random((3,3,3))\n",
    "print('A = \\n{}'.format(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fjMPwq95m8CB",
   "metadata": {
    "id": "fjMPwq95m8CB"
   },
   "outputs": [],
   "source": [
    "# Multplicación escalar vector\n",
    "x = np.arange(0,100,5)\n",
    "a = 10\n",
    "\n",
    "print(a*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7XjqAreroWVu",
   "metadata": {
    "id": "7XjqAreroWVu"
   },
   "outputs": [],
   "source": [
    "# Producto punto\n",
    "c = np.dot(x,x)\n",
    "print(c, 'producto punto')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hsBY48kxoyPX",
   "metadata": {
    "id": "hsBY48kxoyPX"
   },
   "outputs": [],
   "source": [
    "# Multiplicación matriz vector\n",
    "A = np.arange(0,9).reshape(3,3)\n",
    "x = np.arange(0,3)\n",
    "b = np.dot(A,x)\n",
    "print(A, 'A')\n",
    "print(x, 'x')\n",
    "print(b, 'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99tpGMdkru6n",
   "metadata": {
    "id": "99tpGMdkru6n"
   },
   "outputs": [],
   "source": [
    "# Operaciones con arreglos\n",
    "\n",
    "x = np.arange(0,100,5)\n",
    "y = np.exp(x)\n",
    "z = np.sqrt(x)\n",
    "\n",
    "print(y,'y')\n",
    "print(z,'z')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d70b307",
   "metadata": {
    "id": "0d70b307"
   },
   "source": [
    "## Challenge break\n",
    "### 3\n",
    "Crea un arreglo de numpy que contenga los primeros 9 número naturales. Considera el cero como un número natural. \n",
    "\n",
    "Modifica el arreglo para que en las posiciones impares se le asigne el número -1\n",
    "\n",
    "Modifica el arreglo unidimensional en un arreglo de 2 dimensiones de 3x3, en donde los primeros 3 elementos del arreglo unidimensional sería el primer reglón del arreglo de 2 dimensiones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee08a5f6",
   "metadata": {
    "id": "ee08a5f6"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a8e8ec43",
   "metadata": {
    "id": "a8e8ec43"
   },
   "source": [
    "### 4\n",
    "Crear un vector con valores dentro del rango 10 a 100 en pasos de 5\n",
    "\n",
    "Invierte el vector "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "407bcf26",
   "metadata": {
    "id": "407bcf26"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "89xtkpwLBPw_",
   "metadata": {
    "id": "89xtkpwLBPw_"
   },
   "source": [
    "### 5\n",
    "Suma los elementos de la siguiente matriz\n",
    "\n",
    "A = [[1,2,3],\n",
    "     [4,5,6],\n",
    "     [7,8,9]]\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "Y81WK-nkBhae",
   "metadata": {
    "id": "Y81WK-nkBhae"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1874c180",
   "metadata": {
    "id": "1874c180"
   },
   "source": [
    "### Condición np.where\n",
    "\n",
    "Regresa una tupla con los indices del arreglo numpy en donde se cumple la condición"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8f73e0d",
   "metadata": {
    "id": "e8f73e0d"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "\n",
    "x = np.array([2 , 6, 5, 9, 3, 9, 4, 6, 1, 8])\n",
    "print('x: ',x )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d817008d",
   "metadata": {
    "id": "d817008d"
   },
   "outputs": [],
   "source": [
    "idx = np.where(x>5)\n",
    "print('Índices en donde x > 5 : ',idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bc9ac1b",
   "metadata": {
    "id": "5bc9ac1b"
   },
   "outputs": [],
   "source": [
    "print('Valores en donde x > 5 : ',x[idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "144a8cf1",
   "metadata": {
    "id": "144a8cf1"
   },
   "source": [
    "También se pueden poner dos condiciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88a483a6",
   "metadata": {
    "id": "88a483a6"
   },
   "outputs": [],
   "source": [
    "idx = np.where((x>5) & (x<9))\n",
    "print('Índices en donde x > 5 y x < 9 : ',idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb4d3a72",
   "metadata": {
    "id": "fb4d3a72"
   },
   "source": [
    "Se pueden sustituir los valores seleccionados por un valor dado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ebe8009",
   "metadata": {
    "id": "2ebe8009"
   },
   "outputs": [],
   "source": [
    "print('x: ',x )\n",
    "x[idx] = 0\n",
    "print('Sustitir por cero valores en donde x > 5 y x < 9: \\n x:',x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "415e7c04",
   "metadata": {
    "id": "415e7c04"
   },
   "source": [
    "### Dos condiciones np.where (condicion, [x, y])\n",
    "\n",
    "Donde la condición es verdadera, produce x, donde no produce y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85ac2818",
   "metadata": {
    "id": "85ac2818"
   },
   "outputs": [],
   "source": [
    "x = np.array([2, 6, 5, 9, 3, 9, 4, 6, 1, 8])\n",
    "print('x_{original}: ',x )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c62ad97d",
   "metadata": {
    "id": "c62ad97d"
   },
   "outputs": [],
   "source": [
    "idx = np.where((x>5) & (x<9))\n",
    "print('Índices en donde x > 5 y x < 9 : ',idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c5173f9",
   "metadata": {
    "id": "8c5173f9"
   },
   "outputs": [],
   "source": [
    "x1 = np.where((x>5) & (x<9), 0, x)\n",
    "print('x_{nuevo}: ',x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f0bd668",
   "metadata": {
    "id": "3f0bd668"
   },
   "source": [
    "## Challenge break\n",
    "### 6\n",
    "Considera los siguientes arreglos de numpy\n",
    "\n",
    "a = np.array([1,2,3,2,3,4,3,4,5,6])\n",
    "\n",
    "b = np.array([7,2,10,2,7,4,9,4,9,8])\n",
    "\n",
    "¿Que se obtiene al aplicar el comando np.where(a==b)?\n",
    "\n",
    "Explica el significado de lo que resulta al aplicar el comando anterior\n",
    "\n",
    "Escribe los elementos del arreglo numpy b, que tienen valores entre 2 y 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "526b691d",
   "metadata": {
    "id": "526b691d"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ed799fb2",
   "metadata": {
    "id": "ed799fb2"
   },
   "source": [
    "## Se pueden comparar dos arreglos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89065226",
   "metadata": {
    "id": "89065226"
   },
   "outputs": [],
   "source": [
    "a = np.array([1,2,3,2,3,4,3,4,5,6])\n",
    "b = np.array([7,2,10,2,7,4,9,4,9,8])\n",
    "print('a: ',a )\n",
    "print('b: ',b )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dda519f",
   "metadata": {
    "id": "3dda519f"
   },
   "outputs": [],
   "source": [
    "idx = np.where(a==b)\n",
    "tidx = type(np.where(a==b))\n",
    "print(\"a es igual a b en las entradas: \",idx,\" que son de tipo: \", tidx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9c3c8d3",
   "metadata": {
    "id": "c9c3c8d3"
   },
   "outputs": [],
   "source": [
    "print('a[idx]: ',a[idx] )\n",
    "print('b[idx]: ',b[idx] )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f95c6a33",
   "metadata": {
    "id": "f95c6a33"
   },
   "source": [
    "### Máscaras en numpy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "475e2ab5",
   "metadata": {
    "id": "475e2ab5"
   },
   "outputs": [],
   "source": [
    "x = np.array([2 , 6, 5, 9, 3, 9, 4, 6, 1, 8])\n",
    "print('x: ',x )\n",
    "print((x>5) & (x<9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a9a1ced",
   "metadata": {
    "id": "7a9a1ced"
   },
   "outputs": [],
   "source": [
    "y = (x>5) & (x<9)\n",
    "print('y: ',y )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3feb4c95",
   "metadata": {
    "id": "3feb4c95"
   },
   "outputs": [],
   "source": [
    "print('Valores en donde x > 5 y x < 9: \\n x:',x[y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22259fb7",
   "metadata": {
    "id": "22259fb7"
   },
   "outputs": [],
   "source": [
    "x[y] = 0\n",
    "print('Sustitir por cero valores en donde x > 5 y x < 9: \\n x:',x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cd3d308",
   "metadata": {
    "id": "9cd3d308"
   },
   "source": [
    "### Comparación entre arreglos bi dimensionales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ffa1c9f",
   "metadata": {
    "id": "6ffa1c9f"
   },
   "outputs": [],
   "source": [
    "a = np.random.randint(1,10,(3,3))\n",
    "b = np.random.randint(1,10,(3,3))\n",
    "print('a: \\n',a )\n",
    "print('b: \\n',b )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99e83dd4",
   "metadata": {
    "id": "99e83dd4"
   },
   "outputs": [],
   "source": [
    "d = a == b\n",
    "print('d es la matriz que nos muestra donde son iguales a y b, \\n d:\\n',d )\n",
    "print(\"tipo de d: \",type(d))\n",
    "print(\"tamaño de d: \",np.shape(d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e38f2911",
   "metadata": {
    "id": "e38f2911"
   },
   "outputs": [],
   "source": [
    "print(\"mostrar las entradas en donde a==b : \",np.where(a==b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ffe64d0",
   "metadata": {
    "id": "4ffe64d0"
   },
   "outputs": [],
   "source": [
    "print(\"valor de las entradas en donde a==b : \",a[d])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61d63d6b",
   "metadata": {
    "id": "61d63d6b"
   },
   "outputs": [],
   "source": [
    "print(\"valor de las entradas en donde a==b : \",a[0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f9c6a12",
   "metadata": {
    "id": "4f9c6a12"
   },
   "outputs": [],
   "source": [
    "a1 = a<5\n",
    "print(\"valor de a en donde a<5\\n\",a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26c588e5",
   "metadata": {
    "id": "26c588e5"
   },
   "outputs": [],
   "source": [
    "a1 = a<5\n",
    "print(\"entradas de a en donde a<5\\n\",a[a1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2520c9d0",
   "metadata": {
    "id": "2520c9d0"
   },
   "outputs": [],
   "source": [
    "print(\" a:\\n\",a)\n",
    "a[a1]=0\n",
    "print(\"cambiar entradas de a en donde a<5 por cero\\n a:\\n\",a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b607561",
   "metadata": {
    "id": "3b607561"
   },
   "source": [
    "### np.where con arreglos bidimensionales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3b50357",
   "metadata": {
    "id": "c3b50357"
   },
   "outputs": [],
   "source": [
    "c = np.random.randint(1,10,(3,3))\n",
    "d = np.random.randint(1,10,(3,3))\n",
    "print('c: \\n',c )\n",
    "print('d: \\n',d )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3498c06",
   "metadata": {
    "id": "d3498c06"
   },
   "outputs": [],
   "source": [
    "c = np.where(c==d, c, 10)\n",
    "print(\"sustituir las entradas diferentes en c y d por 10\\nc:\\n\",c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "651c7dd3",
   "metadata": {
    "id": "651c7dd3"
   },
   "outputs": [],
   "source": [
    "print('d: \\n',d )\n",
    "d = np.where(d<5, 0, 10)\n",
    "print(\"sustituir las entradas en d menores que 5\\nd:\\n\",c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f0beb4f",
   "metadata": {
    "id": "1f0beb4f"
   },
   "source": [
    "## Challenge break\n",
    "### 7\n",
    "Crea dos arreglos al azar A y B de tamaño 3x3, verificar si los arreglos son iguales componente a componente.\n",
    "\n",
    "Verifica si los arreglos son iguales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01fce978",
   "metadata": {
    "id": "01fce978"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c9b24457",
   "metadata": {
    "id": "c9b24457"
   },
   "source": [
    "### 8\n",
    "Construye dos matrices de enteros entre 1 y 10, A y B de tamaño 10x10, puedes usar el comando \n",
    "\n",
    "```\n",
    "np.random.randint(min,max,(N,N))\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70548972",
   "metadata": {
    "id": "70548972"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "j8J1fjPTf7PI",
   "metadata": {
    "id": "j8J1fjPTf7PI"
   },
   "source": [
    "### 9\n",
    "\n",
    "Encuentra que entradas de los arreglos anteriores son iguales (si es que hay sustituye el valor en a por \"equal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "DcwQjKKYgK-x",
   "metadata": {
    "id": "DcwQjKKYgK-x"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6a6ea280",
   "metadata": {
    "id": "6a6ea280"
   },
   "source": [
    "## SciPy \n",
    "[Scipy][] es una librería libre y de código abierto para Python que cuenta con herramientas y algoritmos matemáticos. SciPy contiene módulos para optimización, álgebra lineal ([linalg]), integración, interpolación, funciones especiales, FFT, procesamiento de señales y de imagen, resolución de ODEs, entre otros.\n",
    "\n",
    "[Scipy]:https://scipy.org/\n",
    "[linalg]:https://docs.scipy.org/doc/scipy/reference/linalg.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5b64cac",
   "metadata": {
    "id": "a5b64cac"
   },
   "outputs": [],
   "source": [
    "# Calcular el determinante de una matriz\n",
    "\n",
    "from scipy import linalg\n",
    "import numpy as np\n",
    "A = np.array([[1, 2],\n",
    "                [3, 4]])\n",
    "\n",
    "print(\"det(A):\\n \", linalg.det(A))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "NiVG3MlZ8XRn",
   "metadata": {
    "id": "NiVG3MlZ8XRn"
   },
   "outputs": [],
   "source": [
    "# Resolver un sistema lineal\n",
    "\n",
    "from scipy import linalg\n",
    "import numpy as np\n",
    "A = np.array([[1, 2],\n",
    "                [3, 4]])\n",
    "b = np.array([1, 2])\n",
    "print(\"A:\\n \", A)\n",
    "print(\"b:\\n \", b)\n",
    "\n",
    "print(\"x:\\n \", linalg.solve(A,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "855f3e9a",
   "metadata": {
    "id": "855f3e9a"
   },
   "outputs": [],
   "source": [
    "# Calcular la inversa de una matriz\n",
    "A = np.array([[1, 2],\n",
    "                [3, 4]])\n",
    "print(\"A^{-1}:\\n \", linalg.inv(A))\n",
    "\n",
    "Z=np.dot(A,linalg.inv(A) )\n",
    "print(Z, 'Z')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "xmOWP1PM8Nic",
   "metadata": {
    "id": "xmOWP1PM8Nic"
   },
   "source": [
    "## Challenge break\n",
    "### 10\n",
    "Resuelve el siguiente sistema lineal con scipy\n",
    "\n",
    "\\begin{array}\n",
    ".x + 2y - 3z &= -3 \\\\\n",
    "2x - 5y + 4z &= 13  \\\\\n",
    "5x + 4y - z &= 5  \n",
    "\\end{array}\n",
    "\n",
    "Verifica que tu resultado este correcto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "Fipth4oE8MWS",
   "metadata": {
    "id": "Fipth4oE8MWS"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "IpDWqm3dwRNs",
   "metadata": {
    "id": "IpDWqm3dwRNs"
   },
   "source": [
    "# Visualización\n",
    "### Graficas 2D\n",
    "Python cuenta con varias librerias que contienen funciones predefinidas. Para usarlas, se tienen que importar con la función *import*. En este curso se utilizará una libreria con funciones matemáticas [numpy] y una librería para graficar [matplotlib](https://matplotlib.org/gallery/index.html#gallery). Si el nombre de la librería es muy largo, se pueden renombrar con *as*.\n",
    "\n",
    "\\begin{array}{llL} \n",
    "import  & \\text{numpy }            &    as &   \\text{ np}\\\\ \n",
    "import  & \\text{matplotlib.pyplot }&    as &   \\text{ plt}\\\\ \n",
    "\\end{array}\n",
    "\n",
    "#### Matplotlib\n",
    "Esta librería sirve para graficar funciones, la sintaxis básica es:\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook\n",
    "\n",
    "* Graficar x vs y \n",
    "\n",
    "*plt.plot(x,y)*\n",
    "* Agregar título \n",
    "\n",
    "*plt.title('Grafica de x vs y', fontsize=16)*\n",
    "* Agregar nombre al eje x \n",
    "\n",
    "*plt.xlabel('Valores', fontsize=14)*\n",
    "* Agregar nombre al eje y \n",
    "\n",
    "*plt.ylabel('Promedios', fontsize=14)*\n",
    "* Mostrar la gráfica\n",
    "\n",
    "*plt.show()*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9vLdNVIZwMJM",
   "metadata": {
    "id": "9vLdNVIZwMJM"
   },
   "outputs": [],
   "source": [
    "# Ejemplo: Gráfica de la función $f(x)= 2x^2$\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "N = 10\n",
    "x = np.array([x for x in range(N)]) \n",
    "y = 2 * x**2\n",
    "plt.plot(x,y)\n",
    "plt.title('Grafica de x vs $f(x)$', fontsize=16)\n",
    "plt.xlabel('x', fontsize=14)\n",
    "plt.ylabel('$f(x)$', fontsize=14)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "DqWWH8IiwXpW",
   "metadata": {
    "id": "DqWWH8IiwXpW"
   },
   "source": [
    "Para modificar las lineas o el color, se pueden agregar opciones extra en la instrucción de graficar. Por ejemplo podemos agregar 'ro' para poner circulos rojos "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "gv8Y7APswUvU",
   "metadata": {
    "id": "gv8Y7APswUvU"
   },
   "outputs": [],
   "source": [
    "N = 10\n",
    "x = np.array([x for x in range(N)]) \n",
    "#x = np.linspace(0,N, 100)\n",
    "y = 2 * x**2\n",
    "plt.plot(x,y,'ro')\n",
    "plt.title('Grafica de x vs $f(x)$', fontsize=16)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('$f(x)$')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8vE29E2QwgKa",
   "metadata": {
    "id": "8vE29E2QwgKa"
   },
   "source": [
    "Las posibilidades se muestran a continuación\n",
    "\n",
    "\n",
    "| Symbol  | Description  | Symbol  |  Description |\n",
    "|:---:|:---:|:---:|:---:|\n",
    "|  b | blue  |  T |  T |\n",
    "|  g | green |  s | square  |\n",
    "|  r |  red |  d |  diamond |\n",
    "|  c |  cyan |  v | triangle (down)  |\n",
    "|  m |  magenta | ^  | triangle (up)   |\n",
    "|  y |  yellow | <  | triangle (left)   |\n",
    "|  k | black  |  > |  triangle (right)  |\n",
    "|  w |  white | p  | pentagram  |\n",
    "|  . |  point |  h |  hexagram |\n",
    "|  o |  circle | -  |  solid |\n",
    "|  x | x-mark  |  : |  dotted |\n",
    "|  + |  plus | -.  | dashdot  |\n",
    "|  * |  star |  --  | dashed  |\n",
    "\n",
    "\n",
    "Tambien se pueden cambiar cualquier parte de la figura, el tamaño, los nombres de los ejes, su tamaño, con *fontsize*. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fRimkrRN_rrr",
   "metadata": {
    "id": "fRimkrRN_rrr"
   },
   "outputs": [],
   "source": [
    "N = 10\n",
    "x = np.array([x for x in range(N)]) \n",
    "#x = np.linspace(0,N, 100)\n",
    "y = 2 * x**2\n",
    "plt.plot(x,y,'ro')\n",
    "plt.title('Grafica de x vs $f(x)$', fontsize=16)\n",
    "plt.xlabel('x', fontsize=14)\n",
    "plt.ylabel('$f(x)$', fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "qKqHyvzz_sK5",
   "metadata": {
    "id": "qKqHyvzz_sK5"
   },
   "source": [
    "Existen unos estilos predefinidos que tienen valores dados, las posibilidades se encuentran como sigue: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ER7mYnZVwiO6",
   "metadata": {
    "id": "ER7mYnZVwiO6"
   },
   "outputs": [],
   "source": [
    "print(plt.style.available)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "oMp9Dq61wlTM",
   "metadata": {
    "id": "oMp9Dq61wlTM"
   },
   "outputs": [],
   "source": [
    "plt.style.use('_classic_test_patch')\n",
    "plt.figure(figsize = (10,6))\n",
    "N = 10\n",
    "x = np.array([x for x in range(N)]) \n",
    "#x = np.linspace(0,N, 100)\n",
    "y = 5 * x**2\n",
    "plt.plot(y, 'bo')\n",
    "y =  x**3\n",
    "plt.plot(y,'g*')\n",
    "plt.title('Grafica de x vs $f(x)$')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('$f(x)$')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5t-ovrewuVg",
   "metadata": {
    "id": "c5t-ovrewuVg"
   },
   "source": [
    "Se puede agregar los nombres de cada grafica, usando la función *legend* y agregando un argumento llamado *label* en el comando de graficar *plot*. La función leyenda también toma el argumento *loc* para indicar en donde se ubican los nombres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "X5ogWuWBwnlW",
   "metadata": {
    "id": "X5ogWuWBwnlW"
   },
   "outputs": [],
   "source": [
    "plt.style.use('_classic_test_patch')\n",
    "plt.figure(figsize = (10,6))\n",
    "N = 10\n",
    "x = np.array([x for x in range(N)]) \n",
    "#x = np.linspace(0,N, 100)\n",
    "y = 5 * x**2\n",
    "plt.plot(x, y, 'bo', label = '$f(x) = 5x^2$')\n",
    "y =  x**3\n",
    "plt.plot(x, y, 'r*', label = '$f(x) = x^3$')\n",
    "plt.title('Grafica de x vs $f(x)$')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('$f(x)$')\n",
    "plt.legend(loc = 0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sckjxrWGwz7C",
   "metadata": {
    "id": "sckjxrWGwz7C"
   },
   "source": [
    "También se pueden cambiar los límites de cada eje usando las funciones *xlim* o *ylim*, y agregar la funcion *grid* para agregar una malla a la figura. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "strK-h-9wwb6",
   "metadata": {
    "id": "strK-h-9wwb6"
   },
   "outputs": [],
   "source": [
    "\n",
    "plt.figure(figsize = (10,6))\n",
    "N = 10\n",
    "x = np.array([x for x in range(N)]) \n",
    "#x = np.linspace(0,N, 100)\n",
    "y = 5 * x**2\n",
    "plt.plot(x, y, 'bo', label = '$f(x) = 5x^2$')\n",
    "y =  x**3\n",
    "plt.plot(x, y, 'r*', label = '$f(x) = x^3$')\n",
    "plt.title('Grafica de x vs $f(x)$')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('$f(x)$')\n",
    "plt.legend(loc = 2)\n",
    "\n",
    "plt.xlim(-5,12)\n",
    "plt.ylim(-100,800)\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "xX9MnW2hxyF4",
   "metadata": {
    "id": "xX9MnW2hxyF4"
   },
   "source": [
    "Se puede hacer una tabla de graficas en una sola figura con la función  *subplot* que tiene 3 entradas: \n",
    "- Número de renglones \n",
    "- Número de columnas\n",
    "- Cual elemento de la tabla se va a graficar\n",
    "\n",
    "Adicionalmente, hay varias funciones que se pueden para realizar graficas específicas: \n",
    "- *scatter*:  es similar a plot solo que usa siempre circulos, scatter(x,y) es equivalente a  plot(x,y,'o')\n",
    "- *bar*: grafica barras centradas en x con altura y\n",
    "- *loglog*: escala logaritmica en los ejes x y y\n",
    "- *semilogx*: escala logaritmica en el eje x\n",
    "- *semilogy*: escala logaritmica en el eje "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ULD_ooBYz2KE",
   "metadata": {
    "id": "ULD_ooBYz2KE"
   },
   "outputs": [],
   "source": [
    "plt.style.use('_classic_test_patch')\n",
    "x = np.arange(11)\n",
    "y = x**2\n",
    "\n",
    "plt.figure(figsize = (14, 8))\n",
    "\n",
    "plt.subplot(2, 3, 1)\n",
    "plt.plot(x,y)\n",
    "plt.title('Plot')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(2, 3, 2)\n",
    "plt.scatter(x,y)\n",
    "plt.title('Scatter')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(2, 3, 3)\n",
    "plt.bar(x,y)\n",
    "plt.title('Bar')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(2, 3, 4)\n",
    "plt.loglog(x,y)\n",
    "plt.title('Loglog')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.grid(which='both')\n",
    "\n",
    "plt.subplot(2, 3, 5)\n",
    "plt.semilogx(x,y)\n",
    "plt.title('Semilogx')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.grid(which='both')\n",
    "\n",
    "plt.subplot(2, 3, 6)\n",
    "plt.semilogy(x,y)\n",
    "plt.title('Semilogy')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.grid()\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pAM1dSYYyTC_",
   "metadata": {
    "id": "pAM1dSYYyTC_"
   },
   "source": [
    "Para guardar las figuras se usa la función `plt.savefig`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "Kwy4Jc12yMB1",
   "metadata": {
    "id": "Kwy4Jc12yMB1"
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize = (8,6))\n",
    "plt.plot(x,y)\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.savefig('figura.pdf') # pdf, jpg, png ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "s3gRYt7ryWny",
   "metadata": {
    "id": "s3gRYt7ryWny"
   },
   "source": [
    "## Gráficas 3D\n",
    "Para hacer gráficas en 3D con matplotlib, se tiene que importar la herramienta *mplot3d*, que permite que matplotlib haga gráficas en 3D.\n",
    "\n",
    "Para crear los ejes en 3D se usa la función *ax = plt.axes(projection='3d')* y se agregan datos, nombres de los ejes, etc.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "MGkQU8goyWEr",
   "metadata": {
    "id": "MGkQU8goyWEr"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from mpl_toolkits import mplot3d\n",
    "import matplotlib.pyplot as plt\n",
    "fig = plt.figure(figsize = (10,10))\n",
    "ax = plt.axes(projection='3d')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "Qo4qtXb1ya-T",
   "metadata": {
    "id": "Qo4qtXb1ya-T"
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize = (8,8))\n",
    "ax = plt.axes(projection='3d')\n",
    "ax.grid()\n",
    "t = np.arange(0, 10*np.pi, np.pi/50)\n",
    "x = np.sin(t)\n",
    "y = np.cos(t)\n",
    "\n",
    "ax.plot3D(x, y, t)\n",
    "ax.set_title('3D Parametric Plot')\n",
    "\n",
    "# Set axes label\n",
    "ax.set_xlabel('x', labelpad=20)\n",
    "ax.set_ylabel('y', labelpad=20)\n",
    "ax.set_zlabel('t', labelpad=20)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "syRGJcK_zKyY",
   "metadata": {
    "id": "syRGJcK_zKyY"
   },
   "source": [
    "Para crear la malla es necesario convertir los vectores en matrices, esto se hace con la función *meshgrid*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6RB6S2aUyovv",
   "metadata": {
    "id": "6RB6S2aUyovv"
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3, 4]\n",
    "y = [3, 4, 5]\n",
    "X, Y = np.meshgrid(x, y)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "iT3bMldHzRo_",
   "metadata": {
    "id": "iT3bMldHzRo_"
   },
   "outputs": [],
   "source": [
    "print(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "A3RntDRlzQBs",
   "metadata": {
    "id": "A3RntDRlzQBs"
   },
   "source": [
    "Para graficar superficies, se usa la función *plot_surface(X,Y,Z)*, en donde la malla se genera con la función *meshgrid*, and $Z = f (X,Y)$ or $Z (i,j) = f (X (i,j),Y (i,j))$.\n",
    "Tambien se puede agregar un mapa de color [colormap][] con la opcion *plt.cm.cividis* en el comando que grafica la superficie.\n",
    "\n",
    "[colormap]:https://matplotlib.org/stable/tutorials/colors/colormaps.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18sAxWWezPYn",
   "metadata": {
    "id": "18sAxWWezPYn"
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize = (12,10))\n",
    "ax = plt.axes(projection='3d')\n",
    "\n",
    "x = np.arange(-5, 5.1, 0.2)\n",
    "y = np.arange(-5, 5.1, 0.2)\n",
    "\n",
    "X, Y = np.meshgrid(x, y)\n",
    "Z = np.sin(X)*np.cos(Y)\n",
    "\n",
    "surf = ax.plot_surface(X, Y, Z, cmap = plt.cm.cividis)\n",
    "#surf = ax.plot_surface(X, Y, Z, cmap = plt.cm.hsv)\n",
    "\n",
    "# Ejes\n",
    "ax.set_xlabel('x', labelpad=20)\n",
    "ax.set_ylabel('y', labelpad=20)\n",
    "ax.set_zlabel('z', labelpad=20)\n",
    "\n",
    "fig.colorbar(surf, shrink=0.5, aspect=8)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mqS8kI_Yzw5O",
   "metadata": {
    "id": "mqS8kI_Yzw5O"
   },
   "source": [
    "## Challenge break\n",
    "### 1\n",
    "Graficar las funciones $f(x) = x^2$ y $f(x) = x^3$ en el intervalo $-5\\le x \\le 5$ con distintos colores, agregar el nombre de cada función como etiqueta y poner una malla.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "j8GtR7HRzjk0",
   "metadata": {
    "id": "j8GtR7HRzjk0"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "O1BkzzZWz2ej",
   "metadata": {
    "id": "O1BkzzZWz2ej"
   },
   "source": [
    "## 2\n",
    "Realiza la grafica de las siguientes funciones en una sola figura (como sub plots) y pon como título la función que se esta graficando, y agrega nombre a los ejes, grafica en el intervalo $-5\\le x \\le 5$, agrega una malla \n",
    "*   $f(x) = x^2$ \n",
    "*   $f(x) = x^3$ \n",
    "*   $f(x) = x^4$ \n",
    "*   $f(x) = x^5$ \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "xOwlYBLNzs96",
   "metadata": {
    "id": "xOwlYBLNzs96"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "zgOTtUCAGEr6",
   "metadata": {
    "id": "zgOTtUCAGEr6"
   },
   "source": [
    "# Números de punto flotante\n",
    "Los números reales se almacenan como números flotantes. Los números de punto flotante son números como $\\pi \\approx 3.141 592 6$, o el número de Avogadro $\\approx 6.03 × 10^{23}$, o la carga de un electrón $\\approx 1.602 1773 3 × 10 ^{-19} $ coulombs.\n",
    "\n",
    "Estos tienen la forma\n",
    "\n",
    "$$±x \\times b ^e$$\n",
    "\n",
    "donde $x$, las cifras significativas o *mantisa*, *e* es el exponente y *b* es la base del sistema de punto flotante. Si la mantisa está en el rango de 1 a m, entonces tiene la forma\n",
    "\n",
    "$$x = x_0x_1 x_2 x_3 . . . x_{m−1}$$\n",
    "\n",
    "en base b donde cada $x_i$ es un dígito de base-b (0, 1, 2, . . . , b − 1) y m es la longitud de la mantisa.\n",
    "\n",
    "La longitud de la mantisa describe con qué precisión se pueden aproximar los números. Ya que\n",
    "\n",
    "$$x \\times b^e = (x_0x_1 x_2 x_3 . . . x_{m−1} \\text{ base b) }\\times b^e$$\n",
    "$$= (x_0 + x_1 b^{ −1} + x_2 b^{−2 }+ x_3 b^{−3 }+ · · · + x_{m−1} b^{ −m+1} )\\times b^e .$$\n",
    "\n",
    "\n",
    "\n",
    "El sistema de punto flotante más conocido y más utilizado es el **sistema de punto flotante IEEE**, que a veces se denomina estándar IEEE 754.\n",
    "\n",
    "Esto especifica un conjunto de tres formatos diferentes de punto flotante: *precisión simple*, *precisión doble* y *precisión extendida*.\n",
    "\n",
    "La mayoría de los lenguajes de programación admiten sistemas de punto flotante de precisión simple y doble. Por lo general, los tipos real o float representan números de precisión simple, mientras que los tipos double, double precision o long real/longreal representan números de precisión doble.\n",
    "\n",
    "**Rango de los números de punto flotante:** ¿cuáles son los números de punto flotante más grande y más pequeño?\n",
    "\n",
    "Esto depende del rango del exponente. Si $−e_{max} \\leq e \\leq +e_{max}$ y $1/b \\leq x < 1$,\n",
    "entonces el número representable más grande está cerca de $b^{e_{max}}$ y el número representable más pequeño es $b^{ −e_ {max} −1}$. Por lo general, se da $b^{e_{ max}}$ para indicar el rango de los números de punto flotante.\n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/e1e312c42286e801604e2d213e75df88633ddeaa/fp.png?raw=1\" width=\"600\">\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cFXwnbyNIt5N",
   "metadata": {
    "id": "cFXwnbyNIt5N"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "print(2**15)\n",
    "x = np.float16(2**15)\n",
    "#x = np.float16(2**16)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "oiUB_zxEJRWZ",
   "metadata": {
    "id": "oiUB_zxEJRWZ"
   },
   "outputs": [],
   "source": [
    "print(2**127)\n",
    "x = np.single(2**127)\n",
    "#x = np.single(2**128)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1Ui64KziJdCz",
   "metadata": {
    "id": "1Ui64KziJdCz"
   },
   "outputs": [],
   "source": [
    "print(2**1023)\n",
    "x = float(2**1023)\n",
    "#x = float(2**1024)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "PScJc4cDJmFa",
   "metadata": {
    "id": "PScJc4cDJmFa"
   },
   "outputs": [],
   "source": [
    "print(2**1024)\n",
    "x = np.double(2**1023)\n",
    "#x = np.double(2**1024)\n",
    "#x = np.longdouble(2**1024)\n",
    "print(x)#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "As8cwm0KJypm",
   "metadata": {
    "id": "As8cwm0KJypm"
   },
   "outputs": [],
   "source": [
    "print(2**1023)\n",
    "x = np.longdouble(2**1023)\n",
    "x = np.longdouble(2**1024)\n",
    "print(x)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}