03-numpy-tecnicalidades.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-0",
   "metadata": {},
   "source": [
    "# 03: Tecnicalidades de *NumPy*\n",
    "\n",
    "<table style=\"margin:0; max-width: 1000px;\">\n",
    "    <tbody>\n",
    "        <tr>\n",
    "            <td>\n",
    "                <a href=\"https://thatcsharpguy.com\">\n",
    "                    <img src=\"assets/general/Sharp@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://twitter.com/io_exception\">\n",
    "                    <img src=\"assets/general/Twitter@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://tcsg.dev/discord\">\n",
    "                    <img src=\"assets/general/Discord@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://github.com/thatcsharpguy/df\">\n",
    "                    <img src=\"assets/general/GitHub@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://youtube.com/thatcsharpguy\">\n",
    "                    <img src=\"assets/general/YouTube@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://youtu.be/YwHQC4KEtBE\">\n",
    "                    <img src=\"assets/general/EnVivo@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://twitch.tv/thatcsharpguy\">\n",
    "                    <img src=\"assets/general/Twitch@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "        </tr>\n",
    "    </tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-1",
   "metadata": {},
   "source": [
    "## Paquetes  \n",
    "\n",
    " - `numpy`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from df.number_internals import show_float\n",
    "from df.array_internals import show_array_details"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-3",
   "metadata": {},
   "source": [
    "Recordando la semana pasada, los arreglos:\n",
    "\n",
    " - Tienen un tamaño pre-determinado\n",
    " - Tienen que ser *\"rectangulares\"*\n",
    " - Todos los elementos tienen el mismo tipo\n",
    " - Los elementos son números\n",
    "\n",
    "A partir de este punto, vamos a conocer sobre:\n",
    "\n",
    " - **Representación de arreglos en memoria**\n",
    " - **Representación de números en memoria**  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-4",
   "metadata": {},
   "source": [
    "## Arreglos en memoria  \n",
    "\n",
    "Los arreglos en *NumPy* implementados de forma compacta en memoria; la información numérica está almacenada de forma contigua (un número después del otro) con un pequeño encabezado que describe cómo es que el arreglo debe ser manipulado.\n",
    "\n",
    "No importa si estamos hablando de un arreglo unidimensional o de un tensor de 6 dimensiones, los arreglos en *NumPy* son planos, un número después del otro con un poco de información extra al inicio:\n",
    "\n",
    "<img src=\"assets/03/flat_2d@1x.png\" />\n",
    "\n",
    "### Zancadas o *strides*  \n",
    "\n",
    "El *truco* detrás de la implementación de los arreglos es el uso de algo llamado *zancada (!???!)* o <b><i>stride</i></b> en inglés. Estas *strides* especifican cómo es que se debe indexar el arreglo. Hay un *stride* por cada dimensión.\n",
    "\n",
    "Se llama zancada porque se usa para especificar qué tan grande es el *\"paso\" en bytes* que se debe dar para acceder a cada uno de los elementos; y este es el truco que le permite a *NumPy* mantener el arreglo como una sola secuencia plana de números:\n",
    "\n",
    "<img src=\"assets/03/flat_with_strides@1x.png\" />\n",
    "\n",
    "Es más claro cuando vemos este concepto aplicado a un arreglo de dos dimensiones, para calcular la ubicación en memoria de el elemento en la posición [$i$, $j$] se puede usar la fórmula:  \n",
    "\n",
    "<img src=\"assets/03/2d_with_strides@1x.png\" />\n",
    "\n",
    "$$location = i * stride_0 + j * stride_1$$  \n",
    "\n",
    "Podemos generalizar esta idea para arreglos de 3, 4 y demás dimensiones."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-5",
   "metadata": {},
   "source": [
    "### Transformaciones rígidas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-6",
   "metadata": {},
   "outputs": [],
   "source": [
    "base = np.zeros((3, 4), dtype=np.float32)\n",
    "show_array_details(base)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-7",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Original\")\n",
    "show_array_details(base)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(\"Transpuesta\")\n",
    "base_t = base.T\n",
    "show_array_details(base_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-9",
   "metadata": {},
   "outputs": [],
   "source": [
    "flipud = np.flipud(base)\n",
    "print(\"Invertida\")\n",
    "show_array_details(flipud)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-10",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Reflejada\")\n",
    "fliplr = np.fliplr(base)\n",
    "show_array_details(fliplr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-11",
   "metadata": {},
   "outputs": [],
   "source": [
    "rotated = np.rot90(base)\n",
    "print(\"Girada 90 grados\")\n",
    "show_array_details(rotated)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-12",
   "metadata": {},
   "source": [
    "## Tipos de datos en *NumPy*  \n",
    "\n",
    "Por default habrás visto más arriba, los tipos de dato de *NumPy* son `float64` si creamos arreglos con números flotantes e `int32` si estamos creando arreglos con números enteros, pero no son los únicos\n",
    "\n",
    "### Tipos numéricos  \n",
    "\n",
    "#### Enteros  \n",
    "\n",
    "Los enteros representan números sin partes fraccionales; hay de dos tipos: con signo y si  signo. La representación de ellos es en forma de una cadena binaria.  \n",
    "\n",
    "Aquí una tabla con los detalles sobre algunos de estos números:\n",
    "\n",
    "| Nombre | bytes | Mínimo                     | Máximo                     |\n",
    "|--------|-------|----------------------------|----------------------------|\n",
    "| int8   | 1     | -128                       | 127                        |\n",
    "| uint8  | 1     | 0                          | 255                        |\n",
    "| int16  | 2     | -32,768                    | 32,767                     |\n",
    "| uint16 | 2     | 0                          | 65,535                     |\n",
    "| int32  | 4     | -2,147,483,648             | 2,147,483,647              |\n",
    "| uint32 | 4     | 0                          | 4,294,967,295              |\n",
    "| int64  | 8     | -9,223,372,036,854,775,808 | +9,223,372,036,854,775,807 |\n",
    "| uint64 | 8     | 0                          | 18,446,744,073,709,551,615 |\n",
    "\n",
    "##### Desbordamiento  \n",
    "\n",
    "Si una operación se sale de los límites del número entero del tipo de dato ocurre un desbordamiento o *overflow*. En muchos sistemas el número simplemente va a reiniciar desde el valor más pequeño: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-13",
   "metadata": {},
   "outputs": [],
   "source": [
    "int_array = np.array([100, 110, 120], dtype=np.int8)\n",
    "print(int_array)\n",
    "print(int_array + 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-14",
   "metadata": {},
   "outputs": [],
   "source": [
    "uint_array = np.array([100, 110, 120], dtype=np.uint8)\n",
    "print(uint_array)\n",
    "\n",
    "print(uint_array + 20)\n",
    "print(uint_array + 150)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-15",
   "metadata": {},
   "source": [
    "#### *Floats*  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-16",
   "metadata": {},
   "source": [
    "### IEEE 754  \n",
    "\n",
    "La forma más común de representar números de punto flotante es el estándar *IEEE 754*, que especifica una forma de representar números y representaciones específicas para representar números \"especiales\".\n",
    "\n",
    "Este es un resumen de los tipos definidos:\n",
    "\n",
    "| Name         | Nombre común        | Base | Mantissa | Bits del exponente | Sesgo exponente | $E_{min}$ | $E_{max}$ |\n",
    "|--------------|---------------------|------|----------|--------------------|-----------------|-----------|-----------|\n",
    "| binary16     | Precisión media     | 2    | 11       | 5                  | 2^4−1 = 15      | −14       | +15       |\n",
    "| **binary32** | Precisión simple    | 2    | 24       | 8                  | 2^7−1 = 127     | −126      | +127      |\n",
    "| **binary64** | Precisión doble     | 2    | 53       | 11                 | 2^10−1 = 1023   | −1022     | +1023     |\n",
    "| binary128    | Precisión cuádruple | 2    | 113      | 15                 | 2^14−1 = 16383  | −16382    | +16383    |\n",
    "| binary256    | Precision óctuple   | 2    | 237      | 19                 | 2^18−1 = 262143 | −262142   | +262143   |\n",
    "\n",
    "\n",
    "\n",
    "#### Simples y dobles \n",
    "\n",
    "Remarcadas en la tabla de arriba están las precisiones simples y dobles, puesto que estas son las más comunes en la actualidad. Como te podrás imaginar, **float32** ocupa 32 bits (4 bytes) por número y **float64** usa 64 bits (8 bytes) por número.\n",
    "\n",
    "Inclusive las GPUs de la actualidad siguen usando **float32** por default, algunas llegan a **float64**, pero la verdadera rapidez proviene de usar el número de 32 bits.\n",
    "\n",
    "Sistemas de precisiones fuera de 32 y 64 bits son raras y muy limitadas; en particular, 128 y 256 son usadas cuando se habla de aplicaciones de escala astronómica: \n",
    "\n",
    " > In addition, the range from the Sun to the pulsar source may exceed ten thousand light years away, so it needs at least quadruple precision (128 bits of floating point representation). Otherwise, the numerical error of computing will result in poor navigation accuracy.In addition, the range from the Sun to the pulsar source may exceed ten thousand light years away, so it needs at least quadruple precision (128 bits of floating point representation). Otherwise, the numerical error of computing will result in poor navigation accuracy. ~ [Autonomous Navigation of Mars Probes by Single X-ray Pulsar Measurement and Optical Data of Viewing Martian Moons](https://www.cambridge.org/core/journals/journal-of-navigation/article/autonomous-navigation-of-mars-probes-by-single-x-ray-pulsar-measurement-and-optical-data-of-viewing-martian-moons/E0C7BEB033776F4211289E7916D7EA52)\n",
    "\n",
    " > 🚨 *NumPy* no soporta números de 128 a 256"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-17",
   "metadata": {},
   "source": [
    "## Representación binaria \n",
    "\n",
    "Un *float* se representa binariamente por tres partes, cada una de estas partes es... un entero 🤪. Cada una de estas partes tiene un nombre específico:  \n",
    "\n",
    " - Signo\n",
    " - Mantissa\n",
    " - Exponente  \n",
    "\n",
    "Para reconstruir un número flotante a partir de estos tres números debemos seguir la siguiente fórmula:  \n",
    "\n",
    "$$signo \\times (1 + mantissa) \\times 2^{exponente}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-18",
   "metadata": {},
   "source": [
    "### Flotantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-19",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-20",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(-1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-21",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-22",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(1e-8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-23",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(1.5e200, type_=np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-24",
   "metadata": {},
   "source": [
    "### Enteros  \n",
    "\n",
    "Recordemos que para **float64** el tamaño de la mantissa es de 53 bits, lo cual significa que cualquier entero en los rangos  $-2^{53}$ to $2^{53}$ es representable. Números fuera de este rango no son representados exactamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-25",
   "metadata": {},
   "outputs": [],
   "source": [
    "entero = 2 ** 53 - 1\n",
    "show_float(1.0 * entero)\n",
    "print(entero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-26",
   "metadata": {},
   "outputs": [],
   "source": [
    "entero = 2 ** 53 + 1\n",
    "show_float(1.0 * entero)\n",
    "print(entero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-27",
   "metadata": {},
   "outputs": [],
   "source": [
    "entero = 3 ** 55\n",
    "show_float(1.0 * entero)\n",
    "print(entero)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-28",
   "metadata": {},
   "source": [
    "### Errores   \n",
    "\n",
    "Cuando operamos con números flotantes podemos provocar errores **a nivel de hardware**:  \n",
    "\n",
    " - **Operación inválida**: cuando provocamos una operación sin un valor definido: $\\frac{0}{0}$, $\\sqrt{-1}$\n",
    " - **División entre cero**: ...\n",
    " - **Underflow**: cuando el resultado de una operación es más pequeño que el número más pequeño que se puede representar (usualmente el resultado se redondea a cero)\n",
    " - **Overflow**: cuando el resultado de una operación es más grande que el número más grande que se puede representar.\n",
    " - **Resultado inexacto**: cuando una operación va a generar un resultado inexacto por redondeo  \n",
    " \n",
    "Las excepciones son generadas en el hardware y son escaladas por el sistema operativo y pueden o no ser interceptadas por alguna capa antes de llegar al usuario. Cada sistema (o framework) puede decidir qué hacer con ellas: informar al usuario, detener la ejecución del programa...\n",
    "\n",
    "*NumPy* por default intercepta los errores y le informa al usuario a través de una *warning*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-29",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(0.0) / np.array(0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-30",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(1.0) / np.array(0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-31",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(0.1) * np.array(1e-307)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-32",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(2.0) / np.array(3.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-33",
   "metadata": {},
   "source": [
    "## Números especiales  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-34",
   "metadata": {},
   "source": [
    "### ¿Cero negativo?  \n",
    "\n",
    "Gracias a la forma en que se pueden representar los números bajo el estándar IEEE 754, podemos tener dos ceros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-35",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(-0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-36",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-37",
   "metadata": {},
   "source": [
    "### Dos infinitos  \n",
    "\n",
    "También existe una definición explícita para infinito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-38",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(np.inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-39",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(-np.inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-40",
   "metadata": {},
   "outputs": [],
   "source": [
    "0 * np.inf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-41",
   "metadata": {},
   "source": [
    "### No es un número - NaN (*Not A Number*) \n",
    "\n",
    "Otro número muy especial, usado para representar valores inválidos:  \n",
    "\n",
    " - $\\frac{0}{0}$\n",
    " - $\\frac{\\infty}{\\infty}$\n",
    " - $\\infty - \\infty$ o $-\\infty + \\infty$\n",
    " - $0 \\times \\infty$\n",
    " - $\\sqrt(x)$ para toda $x < 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-42",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(-np.nan)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-43",
   "metadata": {},
   "source": [
    " > 🚨 NaN se propaga, una vez que en un cálculo se genera un NaN, cualquier operación en la que este se vea involucrado resultará en NaN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-44",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.nan * np.inf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-45",
   "metadata": {},
   "source": [
    "## Redondeo y precisión  \n",
    "\n",
    "Debido a las limitaciones en tamaño de bits para representar ciertos números los flotantes son propensos a presentar errores de redondeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-46",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(1.0 + 1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-47",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(1.0 + 1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-48",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(1.0 + 1e-8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-49",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_float(1.0 + 1e-16, type_=np.float128)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-50",
   "metadata": {},
   "source": [
    " > 🚨 **NUNCA** uses números flotantes para cálculos financieros; un error gracias al redondeo (por más pequeño que sea) repetido muchas veces puede resultar en un error gigantesco. Python tiene un módulo llamado `decimal` que es lento, pero seguro."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-51",
   "metadata": {},
   "source": [
    "### Algunas reglas...\n",
    "\n",
    "El redondeo en números flotantes es un problema que para la mayoría de aplicaciones no es tan grande; aún así existen algunas cosas que podemos hacer para mitigarlo a la hora de escribir código:  \n",
    " - **Error de magnitud**: evita sumas $x + y$ donde $x$ e $y$ sean de magnitudes diferentes.\n",
    " - **Error de magnificación**: evita divisiones $\\frac{x}{y}$ en donde $y$ sea muy pequeña.\n",
    " - **Error de cancelación**: evita restas $x - y$ en donde $x \\simeq y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-52",
   "metadata": {},
   "outputs": [],
   "source": [
    "(1e30 + 1.0) - 1e30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-53",
   "metadata": {},
   "outputs": [],
   "source": [
    "(1e30 - 1e30) + 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-54",
   "metadata": {},
   "source": [
    "## Comparaciones numéricas  \n",
    "\n",
    "Gracias a estos errores de redondeo, comparaciones directas entre números flotantes pueden resultar *\"incorrectas\"*, y por tanto no es apropiado usarlas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-55",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0.1\n",
    "y = 50000.0\n",
    "z = 0.1\n",
    "x = (x + y) - y\n",
    "\n",
    "print(x == z)\n",
    "print(x - z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-56",
   "metadata": {},
   "source": [
    "La solución es usar la diferencia absoluta comparada contra un determinado valor muy pequeño:\n",
    "\n",
    "$$|x-z|<\\epsilon$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-57",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0.1\n",
    "y = 50000.0\n",
    "z = 0.1\n",
    "\n",
    "epsilon = 1e-8\n",
    "\n",
    "x = (x + y) - y\n",
    "\n",
    "print(abs(x - z) < epsilon)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-58",
   "metadata": {},
   "source": [
    "### All close  \n",
    "\n",
    "*NumPy* al rescate con la función: `np.allclose`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-59",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0.1\n",
    "y = 50000.0\n",
    "z = 0.1\n",
    "\n",
    "x = (x + y) - y\n",
    "\n",
    "print(x, z)\n",
    "np.allclose(x, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03-numpy-tecnicalidades-60",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.full((3, 3), 0.1)\n",
    "y = np.full((3, 3), 500000000.0)\n",
    "z = np.full((3, 3), 0.1)\n",
    "\n",
    "x = (x + y) - y\n",
    "\n",
    "\n",
    "print(x)\n",
    "print(z)\n",
    "np.allclose(x, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03-numpy-tecnicalidades-61",
   "metadata": {},
   "source": [
    "----------\n",
    "\n",
    "## Referencias\n",
    "\n",
    "<table style=\"margin:0; max-width: 1000px;\">\n",
    "    <tbody>\n",
    "        <tr>\n",
    "            <td>\n",
    "                <a href=\"https://thatcsharpguy.com\">\n",
    "                    <img src=\"assets/general/Sharp@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://twitter.com/io_exception\">\n",
    "                    <img src=\"assets/general/Twitter@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://tcsg.dev/discord\">\n",
    "                    <img src=\"assets/general/Discord@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://github.com/thatcsharpguy/df\">\n",
    "                    <img src=\"assets/general/GitHub@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://youtube.com/thatcsharpguy\">\n",
    "                    <img src=\"assets/general/YouTube@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://youtu.be/YwHQC4KEtBE\">\n",
    "                    <img src=\"assets/general/EnVivo@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "            <td>\n",
    "                <a href=\"https://twitch.tv/thatcsharpguy\">\n",
    "                    <img src=\"assets/general/Twitch@1x.png\" />\n",
    "                </a>\n",
    "            </td>\n",
    "        </tr>\n",
    "    </tbody>\n",
    "</table>\n",
    "\n",
    "\n",
    "### Libros  \n",
    "\n",
    " - **Elegant SciPy: The Art of Scientific Python**: [México](https://amzn.to/3c0ZNZM) &middot; [España](https://amzn.to/30WWmge) · [US](https://amzn.to/2PbkbhC)  \n",
    " - **High Performance Python: Practical Performant Programming for Humans**: [México](https://amzn.to/310hEtt) &middot; [España](https://amzn.to/3cVZsXD) · [US](https://amzn.to/3s9eUFW)  \n",
    "\n",
    "\n",
    "### Sitios web  \n",
    "\n",
    " - **What makes Numpy Arrays Fast: Memory and Strides** - [https://www.jessicayung.com/numpy-arrays-memory-and-strides](https://www.jessicayung.com/numpy-arrays-memory-and-strides)  \n",
    " - **What Every Computer Scientist Should Know About Floating-Point Arithmetic** - [https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html](https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html)\n",
    " - **IEEE 754 en Wikipedia** - [https://es.wikipedia.org/wiki/IEEE_754](https://es.wikipedia.org/wiki/IEEE_754)\n",
    " - **PEP 754** - [https://www.python.org/dev/peps/pep-0754/](https://www.python.org/dev/peps/pep-0754/)\n",
    " - **Machine epsilon en Wikipedia** - [https://en.wikipedia.org/wiki/Machine_epsilon](https://en.wikipedia.org/wiki/Machine_epsilon)"
   ]
  }
 ],
 "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}