ALG03-Error_y_Límites_COMPLETO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/keepcoding.png\" width=200 align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/me.jpg\" width=150 align=\"right\">\n",
    "\n",
    "# Análisis del error y límites computacionales\n",
    "\n",
    "Autor: Carlos Moreno Morera\n",
    "\n",
    "Contacto: carlos.moreno@ibm.com\n",
    "\n",
    "Última revisión: 11/Jul/2022"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.- Introducción\n",
    "En muy pocas ocasiones la información de entrada que se suministra es exacta, pues se obtiene, en general, mediante instrumentos de medida; como, por otra parte, tanto el almacenamiento de los datos como el propio algoritmo de cálculo introducen también errores, la información de salida contendrá errores que provendrán de las tres fuentes, es decir, los errores de salida se producen debido a:\n",
    "- Los errores de entrada\n",
    "- Los errores de almacenamiento\n",
    "- Los errores algorítmicos\n",
    "\n",
    "Sobre el primer tipo de errores nada podemos decir: están relacionados con el diseño de los aparatos de medición o la precisión de la percepción a través de los órganos sensoriales. Analizaremos los otros dos tipos de errores. Antes de comenzar, recordemos cierta terminología estándar en el tratamiento de errores. El error cometido al calibrar cierta magnitud puede ser:\n",
    "- **Error absoluto**: que viene dado por la fórmula $\\lvert\\widetilde{z}-z\\rvert$ donde $\\widetilde{z}$ es la aproximación de la cantidad $z$.\n",
    "- **Error relativo**: que viene dado por la fórmula:\n",
    "$$\n",
    "\\frac{\\lvert\\widetilde{z}-z\\rvert}{\\lvert z\\rvert}\n",
    "$$\n",
    "\n",
    "Suele ser más relevante el error relativo, ya que depende de la magnitud que se está utilizando. Veamos un ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El error absoluto es de 0.25\n"
     ]
    }
   ],
   "source": [
    "#Calculamos el error absoluto cuando z = 0.007 cm y su aproximación es 0.257 cm\n",
    "def error_absoluto(z_aprox, z):\n",
    "    return abs(z_aprox - z)\n",
    "\n",
    "z = .007 #También podemos escribir 7e-3\n",
    "z_aprox = .257\n",
    "\n",
    "print(f'El error absoluto es de {error_absoluto(z_aprox, z)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El error relativo es de 35.714285714285715\n"
     ]
    }
   ],
   "source": [
    "#Calculamos el error relativo del ejemplo anterior\n",
    "def error_relativo(z_aprox, z):\n",
    "    return abs(z_aprox - z)/abs(z)\n",
    "\n",
    "print(f'El error relativo es de {error_relativo(z_aprox, z)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resultado anterior nos indica que el error es 35 veces más grande que la magnitud (gigantesco). Se suele decir que el error relativo es del 3571.4% (lo cual es una cantidad inmensa). Aunque a simple vista 0.25 cm parece un error pequeño, si estamos tratando con magnitudes como 0.007 cm es un error enorme.\n",
    "\n",
    "## 2.- Números máquina\n",
    "### 2.1.- Definición e inconvenientes\n",
    "Como se ha visto en la introducción, a la hora de almacenar los datos, también se producen errores. Pero, ¿a qué se debe esto? En el tema anterior vimos algunos ejemplos de conjuntos como los números racionales y los reales. En ambos, nos encontramos con elementos, como $\\pi$ y $1/3$ cuya representación decimal es infinita. Sin embargo, la capacidad de almacenamiento de los ordenadores (la memoria) es finita (solo se puede almacenar una cantidad limitada, grande pero limitada, de números). Esto significa que no siquiera somos capaces de almacenar adecuadamente $\\pi$ o $1/3$. De hecho, la solución a este problema es que **cada número se representa con una cantidad máxima de cifras decimales**, lo que produce que solo se guarden de forma exacta los números que no excedan de ese máximo.\n",
    "\n",
    "Este hecho, a su vez, no solo produce un error inevitable a la hora de almacenar datos, sino que también implica que **hay una cantidad finita de números distintos que pueden almacenarse**. Estos números que pueden almacenarse se denominan números máquina. Expliquémoslo con un ejemplo:\n",
    "\n",
    "Supongamos que en nuestro ordenador primitivo solo podemos guardar los números con una cifra. Esto quiere decir, que no solo se tendrá que $\\pi=3$ (o sea, que $\\pi$ se guardaría como el número 3) sino que el conjunto de números que pueden almacenarse es $\\{0,1,2,3,4,5,6,7,8,9\\}$, y, el resto de números reales, se representará con alguno de ellos. Es decir, nuestro ordenador solo puede guardar diez valores distintos (el cardinal de ese conjunto).\n",
    "\n",
    "Lo mismo ocurriría si pudiéramos almacenar solo una cifra y una cifra decimal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "{'4.4', '9.6', '1.0', '3.1', '0.8', '1.7', '4.3', '0.6', '6.8', '5.9', '4.7', '5.5', '3.4', '3.8', '9.2', '3.5', '8.2', '6.5', '9.4', '1.8', '0.9', '6.4', '9.1', '8.7', '7.0', '2.5', '4.1', '4.5', '5.4', '8.1', '3.6', '6.2', '0.5', '1.2', '1.4', '9.3', '4.0', '8.3', '7.8', '6.1', '0.4', '8.9', '1.1', '5.7', '8.8', '5.6', '7.2', '0.3', '4.9', '9.5', '0.7', '2.4', '2.2', '8.4', '2.8', '5.1', '2.0', '4.2', '1.9', '4.8', '1.6', '9.7', '3.2', '2.9', '5.0', '3.3', '5.2', '0.2', '9.0', '7.7', '8.5', '4.6', '7.3', '2.1', '2.3', '0.0', '2.6', '7.4', '6.7', '0.1', '5.8', '3.0', '6.0', '1.5', '1.3', '7.1', '7.9', '7.6', '6.6', '7.5', '3.9', '3.7', '2.7', '9.8', '6.9', '6.3', '5.3', '8.6', '9.9', '8.0'}\n"
     ]
    }
   ],
   "source": [
    "#Construimos el conjunto de los números que tienen una cifra entera y una decimal\n",
    "S = {f'{entero}.{decimal}' for entero in range(10) for decimal in range(10)}\n",
    "print(len(S))\n",
    "print(S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5.0, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6.0, 6.1, 6.2, 6.3, 6.4, 6.5, 6.6, 6.7, 6.8, 6.9, 7.0, 7.1, 7.2, 7.3, 7.4, 7.5, 7.6, 7.7, 7.8, 7.9, 8.0, 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9, 9.0, 9.1, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 9.9]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAABYCAYAAABPlgrKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAR9UlEQVR4nO3deZBlZXnH8e9Phn0bdHABgZFNBatAMwLuJFAKLsEqo1EEEdFUJCgqxD2ARCxNRDSCuLAoYXFBSpGIAuq44TaDo6KIAgIDDDCA7KIMPPnjvK2Xprvp7unue4f+fqqm6Hvue8/znPecw/R55n3fm6pCkiRJkiRJg+UR/U5AkiRJkiRJD2bRRpIkSZIkaQBZtJEkSZIkSRpAFm0kSZIkSZIGkEUbSZIkSZKkAWTRRpIkSZIkaQBZtJEk9VWS9ZP8PskO/c5lpiR5ZZIfJJkzRft7d5ITpmJfs1WSc5Ps1/P6/UluSnJ9P/PS6JK8NskPVnIfmye5M8lqU5VXz76PSHLqVO9XkjS7TMkvi5Ik9UpyJbA2sGVV3dW2vR7Yp6p2Hdb8g8CHq+oXM5pknyR5FPAeYI+qWjEV+6yqD0zFfmazqtpz6OckmwGHAFtU1Y39y+qv+SwETq0qC3NTrKquBtbrdx6SJI3GkTaSpOkyBzh4rAZJ1gYurqpPzUxKMFWjW1bCdsAbquraPueh0W0B3DxawWYArqEJmY5RJJIkaWZYtJEkTZf/Bg5NMnf4G0nmJyng3qo6vm1b2EbjDE17+GGSY5LcmuSKJM9s25cmuXHYVJY1k3w4ydVJbkjyyVYQIsmuSa5J8o421eXk1v6jSa5rfz6aZM3Wfl6Sc1rcW5J8P8mIf18mqSQHtulddyT5zyRbJflRktuTfDHJGq3tRknOAc4Czm0xHt+zryck+W7bz/lJjh2aWjF0DMNiX5lk9/bzET1t57e89mv9cVOS9/R8bqeW361JlrU4a4x2EpM8O8mFrf3SJK9t2zdMckqS5UmuSvLeoX4amrbSzskfk/whyZ5jxKgkW/e8/myS9w87f4e0874syf49bV+U5Oetv5cmOWK0OK39XkmWtPaXJ9mjbV+Y5PWtT88HNkk3beazPX16QJKrgW+3z3wpyfVJbkvyvSTbjxF3wyQntvyvTTf9arWH6q8kRwHPAY5t+Rzbtj+pXSe3JLk0ySuG9d/xSb6e5C7g7yfST0kuTvKSntert+toxxHaPmiKUu/5bLkcl+T/2rX9kyRb9bT9WMvn9iSLkzxnjLweleTs1vanwFbD3h+rT9ZOcnS7Vm9r/b12z7md09otbOfmwtbfX2txT2txf5Zk/mTylyRpMizaSJKmyyJgIXDoJD+/M/BL4FHA6cDngacDWwP70D3EDk1r+BCwLbBje39T4LCefT0WeCTdCIp/oZuetEtrvwOwE/De1vYQ4BpgY+AxwLuBGiPPPYC/a/t7O/Bp4NXAZsBTgFe1do8APtty2Bz4E3Bsz35OBxYD84D/BPZj5TwbeCKwG3BYkie37fcBb21xntHeP3CkHSTZHDgX+Dhdf+wILGlvfxzYENgSeB7wGmD/no/vDFza4vwXcGKSTPJYHttibQocAByXZKP23l0t9lzgRcAbk7x0lOPZCTgF+PfW/rnAlb1tquoCYE/guqpar6pe2/P284AnAy9or88FtgEeDVwEnDbGMXwOWEF3fT4VeD7w+p73R+yvqnoP8H3goJbPQUnWpSssnd5ivwr4xLCi0d7AUcD6wA8m0k90fbRPz+sXAsuqaskYxzeWVwHvAzYCLmt5DfkZ3XX1yHY8X0qy1ij7OQ64B3gc8Lr2B4Bx9MmH6e7TZ7ZYbwfuHyXOK4F96a63rYAfASe3z10CHD7J/CVJmjCLNpKk6XQY8KYkG0/is3+oqpOr6j7gC3RFkCOr6s9VdR7wF2DrVgh4A/DWqrqlqu4APkD34DXkfuDw9tk/0RVVjqyqG6tqOd0D5b6t7b10D4VbVNW9VfX9qhqraPOhqrq9qn4NXAycV1VXVNVtdA/1TwWoqpur6syqurvleBRdEWCoOPJ04D9ajt8DvjaJPuv1vqr6U1sr6Bd0xSmqanFV/biqVlTVlcCnhvIYwauBC6rqjNYXN1fVkjZC5J+Bd1XVHW0/R/O3PgS4qqo+087f5+j69DGTPJZ76c7XvVX1deBOuoIUVbWwqn5VVfdX1S+BM8Y4ngOAk6rq/Nb+2qr67QTyOKKq7mrXEFV1Ujv+PwNHADsk2XD4h5I8hq4Q9Jb2+RuBY3jgNTqR/noxcGW7P1ZU1UXAl4F/6mnz1ar6YTvOeybYT6cCL0yyQXu9L/C/D9U5Yzirqn7a1nA6ja7IAUBVndquqxVVdTSwJu3c9mrX3MuAw1ofXkzXT0NG7ZN0I8BeBxzczvl9VXVhO28jObmqLu+5hy+vqgta/l+i3dMTyV+SpMmyaCNJmjbtweoc4J2T+PgNPT8PPSQP37Ye3QiQdYDF6abw3Ap8o20fsryq7ul5vQlwVc/rq9o26KZ1XQacl25a1kPlPjynkXIkyVptKsWlSZbS9cvc9jC6CfDHoUWbe3JaGb3fenR3Tx7bppuadX2S2+kKXPNG2cdmwOUjbJ8HrMGD+3DTkeJX1d3tx8ku+HrzsEWbe49n5yTfSTdN6zbgX5n48YzX0qEfkqyW5IPppljdzt9G7IwUewtgdWBZzzX6KboRIUMm0l9bADsP7avt79V0I5IelGvLd9z9VFXXAT8EXpZueuOejD2K6KGMeC22vA5JckmbsnQr3YiqkfLamG6drN7j6r3+xuqTecBajP/cj+uenmD+kiRNikUbSdJ0O5xuJEzvA/1QcWKdnm29D5wTcRPdg9T2VTW3/dmwqnofeIePlLmO7iFvyOZtG23kxCFVtSXwEuBtSXabZG69DqGbLrVLVW3W9g0QYBmwUZvi0ZvTkLvo6atW6JnM6CWA44HfAttU1QZ0079Gm7a0lGHrhjQ30Y1+Gd6Hk11c+W4mfy2cDpwNbFZVGwKfZOLHM16919HewF7A7nQP6vPb9pFiLwX+DMzruUY3qKpR18AZI+7Q/r7bs6+5berUG8f4zET6CbpRLPsALwd+VKMvnD382hz3uWvrv7wDeAWwUVXNBW4bJa/ldNPLNuvZ1nuPjNUnN9FNq1qZc7+y+UuSNCkWbSRJ06qqLqOb3vTmnm3L6R7w92kjFl7HJB+oqup+4DPAMUkeDZBk0yQvGONjZwDvTbJxknl007iGFvJ9cZKhaVe3060Bc99kchtmLt1D5z1JHknPmjtVdRXdGkDvS7JGkmfzt6IOwO+AtdItJrs63fo7a04yj/XpjuvOJE8C3jhG29OA3ZO8IsmctiDrjm0KzxeBo5Ksn2QL4G20PpyEJcDe7VrYg9Gn7YxkfeCWqrqnrVmz9xhtTwT2T7Jbkke06+RJk8x5fbpCzM10RYtRv3a9qpYB5wFHJ9mgxd4qyXiP8wa6tYOGnANsm2TfdIsEr57k6T3rFo2W73j7CeArwNPovgHulDHa/QLYPsmObS2XIx5iv8NzWkFXkJmT5DBgg5EatmvuLOCIJOsk2Y4Hrvs0ap+0/0ecBHwkySbtOntG2uLjK2Hc+UuSNFkWbSRJM+FIYN1h295AtyDszcD2wIUrsf930E1p+nGbqnIBY68r8X66IskvgV/RLSL7/vbeNu3zd9ItQPqJqlq4ErkNOYau0LIc+DHdFK5ee9MtRnsL3eikvz4ot7U1DgROoCt23UW3WPJkHNpi3UFX7PrCaA2r6mq6RWgPaXktoa2NA7yp5XEF3UK3p9M9GE/GwXRFqlvpprR8ZQKfPRA4MskddIWwL47WsKp+SrdY8jF0IyK+ywNHC03EKXTTc64FfkN3TsfyGropZb8B/gicSbduzXh8jG5tlj8m+Z+2JtLz6dbEuY5u+tGHGLuQN+5+Amjr9nwZeAJdsWS0dr+ju78vAH5Pdy2M1zfp1oz5HV1f3sOwaV3DHEQ3Nel6ukW9T+7J46H65FC6e/1ndNfyh1j534Mnmr8kSROWGnNtRUmS1A/pvpJ566ra56HaStOhjRzZ1mtQkqT+mdPvBCRJkjRY2hS+A3jgN4JJkqQZ5vQoSZIk/VWSN9BN8zm3uq+flyRJfeL0KEmSJEmSpAHkSBtJkiRJkqQBZNFGkiRJkiRpAE1oIeJ58+bV/PnzpykVSZIkSZKk2Wfx4sU3VdXGw7dPqGgzf/58Fi1aNHVZSZIkSZIkzXJJrhppu9OjJEmSJEmSBpBFG0mSJEmSpAFk0UaSJEmSJGkAWbSRJEmSJEkaQBZtJEmSJEmSBpBFG0mSJEmSpAFk0UaSJEmSJGkAWbSRJEmSJEkaQBZtJEmSJEmSBpBFm+mw667dn5VtM9XtjGnMQYq5qudvTGMa05jGNKYxjWlMYz6cYk51/poSFm0kSZIkSZIGkEUbSZIkSZKkAWTRRpIkSZIkaQBZtJEkSZIkSRpAFm0kSZIkSZIGkEUbSZIkSZKkAWTRRpIkSZIkaQClqsbdeMGCBbVo0aJpTGdm7DrN3yn/0SVLAHjLjjuuVJupbmdMYw5SzFU9f2Ma05jGNKYxjWlMYxrz4RRzqvOfCQsXLux3ClMmyeKqWjB8uyNtJEmSJEmSBtCsHGkz7YZG8oxV9RtPm6luZ0xjDlLMVT1/YxrTmMY0pjGNaUxjGvPhFHOq89eEONJGkiRJkiRpFWLRRpIkSZIkaQBZtJEkSZIkSRpAFm0kSZIkSZIGkEUbSZIkSZKkAWTRRpIkSZIkaQBZtJEkSZIkSRpAFm0kSZIkSZIGUKpq3I0XLFhQixYtmsZ0JEmSJEmSZpcki6tqwfDtjrSRJEmSJEkaQBZtJEmSJEmSBpBFG0mSJEmSpAFk0UaSJEmSJGkAWbSRJEmSJEkaQBZtJEmSJEmSBpBFG0mSJEmSpAFk0UaSJEmSJGkAWbSRJEmSJEkaQBZtJEmSJEmSBlCqavyNk+XAVdOXzsPKPOCmfich9ZH3gGY77wHNdt4DkveB5D0wfltU1cbDN06oaKPxS7Koqhb0Ow+pX7wHNNt5D2i28x6QvA8k74GV5/QoSZIkSZKkAWTRRpIkSZIkaQBZtJk+n+53AlKfeQ9otvMe0GznPSB5H0jeAyvJNW0kSZIkSZIGkCNtJEmSJEmSBpBFmymWZI8klya5LMk7+52PNJOSbJbkO0kuSfLrJAf3OyepH5KsluTnSc7pdy5SPySZm+TMJL9tfyc8o985STMpyVvb70IXJzkjyVr9zkmabklOSnJjkot7tj0yyflJft/+u1E/c1wVWbSZQklWA44D9gS2A16VZLv+ZiXNqBXAIVX1ZGAX4N+8BzRLHQxc0u8kpD76GPCNqnoSsAPeD5pFkmwKvBlYUFVPAVYDXtnfrKQZ8Vlgj2Hb3gl8q6q2Ab7VXmsCLNpMrZ2Ay6rqiqr6C/B5YK8+5yTNmKpaVlUXtZ/voPslfdP+ZiXNrCSPB14EnNDvXKR+SLIB8FzgRICq+ktV3drXpKSZNwdYO8kcYB3guj7nI027qvoecMuwzXsBn2s/fw546Uzm9HBg0WZqbQos7Xl9DT6wapZKMh94KvCTPqcizbSPAm8H7u9zHlK/bAksB05u0wRPSLJuv5OSZkpVXQt8GLgaWAbcVlXn9TcrqW8eU1XLoPsHXuDRfc5nlWPRZmplhG1+PZdmnSTrAV8G3lJVt/c7H2mmJHkxcGNVLe53LlIfzQGeBhxfVU8F7sLh8JpF2podewFPADYB1k2yT3+zkrSqsmgzta4BNut5/XgcCqlZJsnqdAWb06rqrH7nI82wZwH/mORKuimy/5Dk1P6mJM24a4BrqmpopOWZdEUcabbYHfhDVS2vqnuBs4Bn9jknqV9uSPI4gPbfG/uczyrHos3U+hmwTZInJFmDbsGxs/uckzRjkoRuDYNLquoj/c5HmmlV9a6qenxVzaf7O+DbVeW/rmpWqarrgaVJntg27Qb8po8pSTPtamCXJOu03412w8W4NXudDezXft4P+Gofc1klzel3Ag8nVbUiyUHAN+lWiT+pqn7d57SkmfQsYF/gV0mWtG3vrqqv9y8lSVIfvAk4rf0j1hXA/n3OR5oxVfWTJGcCF9F9s+bPgU/3Nytp+iU5A9gVmJfkGuBw4IPAF5McQFfQfHn/Mlw1pcolVyRJkiRJkgaN06MkSZIkSZIGkEUbSZIkSZKkAWTRRpIkSZIkaQBZtJEkSZIkSRpAFm0kSZIkSZIGkEUbSZIkSZKkAWTRRpIkSZIkaQBZtJEkSZIkSRpA/w8q2xeyfvi+jgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x54 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Mostramos los números que se pueden almacenar\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "numeros_maquina = [float(n) for n in S]\n",
    "numeros_maquina.sort()\n",
    "print(numeros_maquina)\n",
    "\n",
    "#Creamos la figura\n",
    "plt.figure(figsize=(20, 0.75))\n",
    "#Dibujamos la recta real\n",
    "plt.hlines(1, -0.25, 10.25, colors='black')\n",
    "#Dibujamos los números máquina\n",
    "plt.eventplot(numeros_maquina, colors='red', linelengths=0.5)\n",
    "#Ocultamos el eje y\n",
    "ax = plt.gca() #get current axis\n",
    "ax.get_yaxis().set_visible(False)\n",
    "plt.title('Números máquina con una cifra entera y una decimal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué ocurrirá si en alguna operación obtenemos un número que no se encuentra en nuestro conjunto finito de números máquina? Una posible solución es aproximar dicho número al número máquina más cercano. Siguiendo con el ejemplo anterior que sólo podemos representar los cien números con una cifra entera y una decimal, si hiciéramos la operación $5.5 + 0.1/4$ cuyo resultado es $5.525$, tendríamos que almacenar el resultado como $5.5$. Fijémonos que aunque en la operación solo hemos utilizado números de nuestro conjunto finito el resultado está fuera del conjunto. Gráficamente el resultado se posicionaría de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x54 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Mostramos el ejemplo anterior gráficamente\n",
    "subconjunto_num_maquina = [n for n in numeros_maquina if n > 5.2 and n < 5.9]\n",
    "\n",
    "#Creamos la figura\n",
    "plt.figure(figsize=(20, 0.75))\n",
    "#Dibujamos la recta real\n",
    "plt.hlines(1, 5.25, 5.85, colors='black')\n",
    "#Dibujamos los números máquina\n",
    "plt.eventplot(subconjunto_num_maquina, colors='red', linelengths=0.5)\n",
    "#Dibujamos el resultado de la operación\n",
    "plt.eventplot([5.525], colors='blue', linelengths=0.5)\n",
    "#Ocultamos el eje y\n",
    "ax = plt.gca() #get current axis\n",
    "ax.get_yaxis().set_visible(False)\n",
    "plt.title('Números máquina con una cifra entera y una decimal entre 5.3 y 5.8')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El gráfico anterior resulta de ampliar el espacio que hay entre 5.3 y 5.8. En rojo se marcan los números máquina que podemos representar en nuestro ordenador primitivo y en azul el resultado obtenido de la operación.\n",
    "\n",
    "En la realidad, en lugar de tener un ordenador primitivo que solo es capaz de almacenar una cifra entera y una decimal, podemos guardar muchísimas más. Sin embargo, da igual la capacidad finita que tengamos que **siempre existirán más números en la recta real que no podemos representar que los que sí podemos**. De hecho, no solo es posible encontrar huecos entre los distintos números máquina, sino también a la derecha y a la izquierda del mayor y menor número máquina respectivamente.\n",
    "\n",
    "### 2.2.- Representación binaria\n",
    "\n",
    "Al problema de la finita capacidad de nuestra memoria, debemos añadirle el inconveniente de que, internamente, nuestro ordenador almacenará los números con la representación binaria (sistema numérico en el que todos los números se representan mediante las cifras 0 y 1 exclusivamente). De hecho, podemos distinguir dos tipos de números decimales en coma flotante (float):\n",
    "- Precisión simple: utilizan 32 bits (cifras que pueden ser ceros o unos) para almacenar el valor.\n",
    "- Doble precisión: utilizan 64 bits para almacenar el valor.\n",
    "\n",
    "En Python existen otras representación (como la que utiliza 16 bits y se denomina *de media precisión*), pero las más comunes en los lenguajes de programación son las dos anteriores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16bit:  0.1235\n",
      "32bit:  0.12345679\n",
      "64bit:  0.12345678912121212\n"
     ]
    }
   ],
   "source": [
    "#Mostramos el mismo número (0.123456789121212121212) con distintas precisiones:\n",
    "import numpy as np\n",
    "\n",
    "a = np.array([0.123456789121212121212], dtype=np.float16)\n",
    "print(\"16bit: \", a[0])\n",
    "\n",
    "a = np.array([0.123456789121212121212], dtype=np.float32)\n",
    "print(\"32bit: \", a[0])\n",
    "\n",
    "a = np.array([0.123456789121212121212], dtype=np.float64)\n",
    "print(\"64bit: \", a[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se puede observar, son más precisos conforme se aumenta el número de bits que se utilizan para almacenarlos. Pero, como hemos dicho, el número no se guarda como se observa en el ejemplo anterior, sino que se guarda con números binarios como vemos a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: bitstring in c:\\users\\cmore\\anaconda3\\lib\\site-packages (3.1.9)\n"
     ]
    }
   ],
   "source": [
    "!pip install bitstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00111101111111001101011011101010\n",
      "10111101111111001101011011101010\n",
      "0011111110111111100110101101110100110111101111101010100110001101\n",
      "1011111110111111100110101101110100110111101111101010100110001101\n"
     ]
    }
   ],
   "source": [
    "#Mostramos el mismo número (en negativo y en positivo) en binario con las distintas precisiones:\n",
    "import bitstring\n",
    "for longitud in [32, 64]:\n",
    "    f1 = bitstring.BitArray(float=0.123456789121212121212, length=longitud)\n",
    "    print(f1.bin)\n",
    "    f1 = bitstring.BitArray(float=-0.123456789121212121212, length=longitud)\n",
    "    print(f1.bin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se observan las representaciones con detenimiento, veremos que cuando cambiamos el signo la representación binaria es la misma y lo único que varía es el primer bit (0 para positivos y 1 para negativos). En efecto, **el primer bit se corresponde con el signo del número**.\n",
    "\n",
    "Tampoco se observa la coma en el número escrito en binario, ¿cómo sabe el ordenador dónde está la coma? Porque se utiliza **el formato estándar de representación** ([IEEE Storage Format](https://standards.ieee.org/ieee/754/6210/)), en el cual se representan los números como potencias: para el exponente se reservan los dígitos después del bit de signo (los 8 siguientes bits para precisión simple o los 11 siguientes para doble precisión) y los últimos para la mantisa o significado (los 23 últimos para precisión simple o los 52 últimos para doble precisión). La mantisa o significado son los dígitos significativos del número en notación científica.\n",
    "\n",
    "Sin embargo, debido a este formato, encontramos que el cero posee dos representaciones binarias posibles: el -0 y el +0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00000000000000000000000000000000\n",
      "10000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "#Vemos que hay dos representaciones binarias para 0\n",
    "f1 = bitstring.BitArray(float=0., length=32)\n",
    "print(f1.bin)\n",
    "f1 = bitstring.BitArray(float=-0., length=32)\n",
    "print(f1.bin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además de la curiosidad de poseer dos representaciones distintas para el 0, la representación binaria genera un problema adicional para almacenar ciertos números: puede ocurrir que **un número con un número finito de cifras decimales posea un número infinito de cifras decimales en su representación binaria**. Por ejemplo, el número decimal 0.1 tiene como representación binaria $0.0\\overline{0011}$, lo cual significa que no se podrá almacenar internamente de manera exacta (es decir, 0.1 no es un número máquina)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Vemos qué ocurre cuando introduzco 0.1 en Python\n",
    "f = 0.1\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entonces, ¿por qué si almacenamos 0.1 en una variable y lo consultamos después me devuelve el valor exacto y no una aproximación? Porque Python, a partir de la versión 3.1, incluyó ciertos [cambios](https://docs.python.org/dev/whatsnew/3.1.html#other-language-changes) entre los que se encuentran la implementación y ejecución de un procesamiento del número almacenado antes de mostrarlo por pantalla, sin embargo, si le obligamos a mostrarnos el número con muchas cifras significativas veremos lo que realmente está almacenando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.1000000000000000055511151231257827021181583404541'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Vemos el verdadero valor que almacena internamente Python\n",
    "#Mostramos 50 cifras significativas\n",
    "format(f, '.50g')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Mostramos 50 cifras significativas de 2 (número que se puede almacenar en binario)\n",
    "format(2., '.50g')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este hecho produce problemas como el que ocurre si comprobamos si 0.1 + 0.2 es igual a 0.3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comprobamos la suma 0.1+0.2\n",
    "0.1 + 0.2 == 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Vemos el resultado\n",
    "0.1 + 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "1.1 + 2.2 =  3.3000000000000003\n",
      "False\n",
      "0.2 + 0.2 + 0.2 =  0.6000000000000001\n",
      "False\n",
      "1.2 + 2.4 + 3.6 =  7.199999999999999\n",
      "False\n",
      "0.1 + 0.2 =  0.30000000000000004\n",
      "True\n",
      "10.4 + 20.8 =  31.200000000000003\n",
      "True\n",
      "0.8 - 0.1 =  0.7000000000000001\n"
     ]
    }
   ],
   "source": [
    "#Podemos encontrar muchos más ejemplos\n",
    "print(1.1 + 2.2 == 3.3)\n",
    "print('1.1 + 2.2 = ', 1.1 + 2.2)\n",
    "print(0.2 + 0.2 + 0.2 == 0.6)\n",
    "print('0.2 + 0.2 + 0.2 = ', 0.2 + 0.2 + 0.2)\n",
    "print(1.2 + 2.4 + 3.6 == 7.2)\n",
    "print('1.2 + 2.4 + 3.6 = ', 1.2 + 2.4 + 3.6)\n",
    "print(0.1 + 0.2 <= 0.3)\n",
    "print('0.1 + 0.2 = ', 0.1 + 0.2)\n",
    "print(10.4 + 20.8 > 31.2)\n",
    "print('10.4 + 20.8 = ', 10.4 + 20.8)\n",
    "print(0.8 - 0.1 > 0.7)\n",
    "print('0.8 - 0.1 = ', 0.8 - 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cabe recordar que el error de representación de los decimales en coma flotante no es específico de Python, es un problema que se debe conocer (por si se necesitara trabajar con cierta precisión) y saber cómo manejar en cada lenguaje de programación. Para ver que es compartido por varios lenguajes, se puede visitar la página que ha creado Erik Wiffin en la que se muestra el resultado de evaluar `0.1 + 0.2` en múltiples lenguajes y que se llama: [0.30000000000000004.com](0.30000000000000004.com).\n",
    "\n",
    "![](./images/panicoffice.gif)\n",
    "\n",
    "### 2.3.- Redondeo\n",
    "Como hemos visto, hay un número finito de números máquina y hay muchísimos \"huecos\" en la recta real de números que no podemos almacenar. Cuando se necesita trabajar con estos números no máquina que se encuentran entre dos números máquina, lo que se hace es aproximarlos por números máquina cercanos. Este proceso se denomina *redondeo*.\n",
    "\n",
    "En coma flotante estándar, para cada número real están definidos cuatro tipos de rendodeo:\n",
    "- Redondeo a la derecha (o por exceso): se toma el número máquina más cercano a la derecha (mayor) del número real.\n",
    "- Redondeo a la izquierda (o por defecto): se toma el número máquina más cercano a la izquierda (menor) del número real.\n",
    "- Redondeo a cero: se toma el número máquina más cercano a la izquierda cuando el número real es positivo y a la derecha cuando es negativo, es decir, se elige entre izquierda y derecha en función del número máquina que se encuentra entre 0 y el número real.\n",
    "- Redondeo al más próximo: se eligen entre el número máquina qu está más cerca del número real, en caso de que estén a igual distancia se toma el que tenga el bit 23 de la mantisa a 0.\n",
    "\n",
    "La opción más común es esta última, de hecho suele ser la opción por defecto en los ordenadores.\n",
    "\n",
    "### 2.4.- Épsilon de la máquina\n",
    "La primera cuestión que se nos plantea entonces es qué error se comete cuando en lugar de trabajar con un número real $x$ se trabaja, como es obligado, con su rendondeo. En términos absolutos, y manteniendo la notación, se tiene la siguiente cota del error de redonde absoluto:\n",
    "\n",
    "Sea $r(x)$ el redondeo que se lleva a cabo del número $x$, $x_d$ el número máquina a la derecha de $x$ y $x_i$ el número máquina a la izquierda de $x$. Supongamos que trabajamos con números de tamaño de la mantisa de 23 bits (precisión simple), entonces el error absoluto es:\n",
    "$$\n",
    "\\lvert r(x)-x\\rvert\\leq\\frac{x_d-x_i}{2}=\\frac{2^{-23}\\cdot2^E}{2}=2^{-24}\\cdot2^E\n",
    "$$\n",
    "Mientras que, en términos relativos, una cota del error de redondeo relativo es:\n",
    "$$\n",
    "\\left\\lvert\\frac{r(x)-x}{x}\\right\\rvert\\leq\\frac{2^{-24}\\cdot2^E}{2^E}=2^{-24}\n",
    "$$\n",
    "\n",
    "El valor de $2^{-24}$ obtenido es, exactamente, la mitad de la distancia entre 1 y el siguiente número máquina. Esta distancia se denomina **precisión o épsilon de la máquina** y se denota por *eps*. Así, pues, trabanjando en coma flotante estándar se verifica que el error de redondeo es menor que $\\text{eps}/2$ utilizando el redondeo al más próximo. En términos de representación decimal quiere decir que el redondeo de $x$ tendrá alrededor de 7 cifras significativas correctas. En doble precisión el épsilon de la máquina es $2^{-52}$ y el redondeo de un número tendrá un mínimo de 15 cifras significativas exactas. Calculemos el épsilon de la máquina en Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.220446049250313e-16"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Podemos calcular el épsilo llevando a cabo la operación 7/3 - 4/3 -1 (ya que la primera resta obtiene\n",
    "# el siguiente número máquina al número 1 debido a las representaciones binarias de ambas fracciones)\n",
    "7./3 - 4./3 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1 ≈ 3602879701896397/36028797018963968 ≈ 0.1000000000000000055511151231257827021181583404541\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Para saber la aproximación de cualquier número real podemos usar la función as_integer_ratio de los float\n",
    "#Esta función sí es específica de Python\n",
    "numerador, denominador = (0.1).as_integer_ratio()\n",
    "print(f'0.1 ≈ {numerador}/{denominador} ≈ {format(numerador/denominador, \".50g\")}')\n",
    "numerador/denominador == 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ≈ 2/1 ≈ 2\n"
     ]
    }
   ],
   "source": [
    "#Hagámoslo con el 2\n",
    "numerador, denominador = (2).as_integer_ratio()\n",
    "print(f'2 ≈ {numerador}/{denominador} ≈ {format(numerador/denominador, \".50g\")}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El siguiente número máquina de 1 es: 1.000000000000000000000000001\n"
     ]
    }
   ],
   "source": [
    "#También podemos hallar épsilon calculando el siguiente número máquina después de uno\n",
    "#Para eso usamos la función next_plus de la biblioteca decimal\n",
    "from decimal import *\n",
    "f = Decimal(1)\n",
    "print(f'El siguiente número máquina de {f} es: {f.next_plus()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('1E-27')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculamos el épsilon\n",
    "f.next_plus() - f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.220446049250313e-16\n",
      "1.1920929e-07\n"
     ]
    }
   ],
   "source": [
    "#numpy también tiene su forma de informarnos del épsilo de la máquina\n",
    "print(np.finfo(float).eps)\n",
    "print(np.finfo(np.float32).eps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero, ¿cuál de todos ellos es realmente el épsilon de la máquina? Obtenemos resultados distintos debido a que utilizamos diferentes librerías que realizan los cálculos de diferentes maneras. Como vemos la librería *decimal* parece tener una precisión mucho mayor. Para conocer el épsilon de la máquina debemos consultar los parámetros del sistema:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.float_info(max=1.7976931348623157e+308\n",
      "max_exp=1024\n",
      "max_10_exp=308\n",
      "min=2.2250738585072014e-308\n",
      "min_exp=-1021\n",
      "min_10_exp=-307\n",
      "dig=15\n",
      "mant_dig=53\n",
      "epsilon=2.220446049250313e-16\n",
      "radix=2\n",
      "rounds=1)\n"
     ]
    }
   ],
   "source": [
    "#Consultamos los valores del sistema\n",
    "import sys\n",
    "print('\\n'.join(str(sys.float_info).split(', ')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entre otros datos, vemos el épsilon de la máquina (utilizando float) y el número de bits de la mantisa (53).\n",
    "\n",
    "### 2.5.- Desbordamiento\n",
    "Como vimos en los ejemplos prácticos en los que solo contábamos con un ordenador capaz de representar 100 números, no solo encontrábamos elementos del conjunto de los reales no representables entre dos números, sino también a la derecha y a la izquierda del mayor y menor número máquina. Es decir, como tenemos un conjunto finito de números máquina, existirá uno que sea mayor que todos los demás y otro que sea el menor de todos, pero hay infinitos reales más grandes y más pequeños, respectivamente. A este fenómeno de tratar un número real mayor que el máximo representable o menor que el mínimo se le conoce como **desbordamiento por exceso**. La representación estándar en coma flotante trata el desbordamiento como algo excepcional asignándole el valor $\\infty$ (o $-\\infty$ para el caso de un número menor que el mínimo) siempre que tengan sentido las operaciones (por ejemplo $1/\\infty=0$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.float_info(max=1.7976931348623157e+308\n",
      "max_exp=1024\n",
      "max_10_exp=308\n",
      "min=2.2250738585072014e-308\n",
      "min_exp=-1021\n",
      "min_10_exp=-307\n",
      "dig=15\n",
      "mant_dig=53\n",
      "epsilon=2.220446049250313e-16\n",
      "radix=2\n",
      "rounds=1)\n"
     ]
    }
   ],
   "source": [
    "#Miramos cuál es el valor máximo y mínimo del sistema\n",
    "print('\\n'.join(str(sys.float_info).split(', ')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Vemos qué valor le asigna si le damos un número mayor:\n",
    "1.797694e308"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-inf"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Probamos en negativo\n",
    "-1.797694e308"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7976931348623157e+308"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Vemos que el valor máximo sí lo muestra\n",
    "1.7976931348623157e+308"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf\n",
      "inf\n",
      "inf\n",
      "inf\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "#Probamos a operar con el infinito:\n",
    "print(1.8e308 + 1)\n",
    "print(1.8e308 * 2)\n",
    "print(1.8e308 / 2)\n",
    "print(1.8e308 - 1.7e308)\n",
    "print(1/1.8e308)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan\n",
      "1.0\n",
      "0.0\n",
      "1.0\n",
      "nan\n",
      "nan\n",
      "nan\n"
     ]
    }
   ],
   "source": [
    "#Generamos indeterminaciones\n",
    "print(1.8e308/-1.8e308) #infinito / infinito\n",
    "print(1**1.8e308) # 1^infinito\n",
    "print(0**1.8e308) # 0^infinito\n",
    "print(1.8e308**0) # infinito^0\n",
    "print(0*1.8e308) # 0 * infinito\n",
    "print(1.8e308*0) # infinito * 0\n",
    "print(1.8e308 - 1.8e308) # infinito - infinito"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6.- Ejemplo de error de redondeo\n",
    "\n",
    "![](./images/horrible-avengers.gif)\n",
    "\n",
    "Como hemos visto, constatemente estaremos generando errores de redondeo debido a la capacidad finita de la memoria y a la representación binaria de los números. Para minimizarla lo máximo posible, conviene tratar de simplificar las expresiones matemáticas todo lo que se pueda evitando también el fenómeno de cancelación (antes observamos que, aunque $7/3 - 4/3 -1 = 0$ no se anulaba por completo). Veamos un ejemplo:\n",
    "\n",
    "Tenemos la siguiente función:\n",
    "$$\n",
    "f_1(x) = \\frac{x^4-x^3-x+1}{(x-1)^2}\n",
    "$$\n",
    "que, con valores distintos a 1, puede simplificarse (obteniendo las raíces del numerador) en la siguiente expresión:\n",
    "$$\n",
    "f_2(x) = \\frac{(x-1)^2(x^2+x+1)}{(x-1)^2}=x^2+x+1\n",
    "$$\n",
    "Veamos qué resultados obtenemos al aplicar las distintas expresiones con valores cercanos a 1 (un poco mayores que 1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1.0000000200000001005   | f1(x) = 3.330669040403849035     | f2(x) = 3.0000000600000005235\n",
      "x = 1.0000000190000000178   | f1(x) = 3.075410034765179379     | f2(x) = 3.0000000570000002753\n",
      "x = 1.0000000180000001571   | f1(x) = 3.4266142137365704912    | f2(x) = 3.0000000540000009153\n",
      "x = 1.0000000170000000743   | f1(x) = 3.0732817021953264813    | f2(x) = 3.000000051000000667\n",
      "x = 1.0000000159999999916   | f1(x) = 3.4694469556059415183    | f2(x) = 3.0000000480000004188\n",
      "x = 1.0000000150000001309   | f1(x) = 2.9605946806683967054    | f2(x) = 3.0000000450000006147\n",
      "x = 1.0000000140000000481   | f1(x) = 2.2657612591625513332    | f2(x) = 3.0000000420000003665\n",
      "x = 1.0000000129999999654   | f1(x) = 3.9416202267502438161    | f2(x) = 3.0000000390000001183\n",
      "x = 1.0000000120000001047   | f1(x) = 3.0839527923629135309    | f2(x) = 3.0000000360000003141\n",
      "x = 1.000000011000000022    | f1(x) = 1.835079372216853022     | f2(x) = 3.0000000330000000659\n",
      "x = 1.0000000099999999392   | f1(x) = 4.4408921524794120472    | f2(x) = 3.0000000299999998177\n",
      "x = 1.0000000090000000785   | f1(x) = 2.7412913709892561265    | f2(x) = 3.0000000270000004576\n",
      "x = 1.0000000079999999958   | f1(x) = 3.4694469556059415183    | f2(x) = 3.0000000240000002094\n",
      "x = 1.0000000070000001351   | f1(x) = 0                        | f2(x) = 3.0000000210000004053\n",
      "x = 1.0000000060000000524   | f1(x) = 6.1679055847258270617    | f2(x) = 3.0000000180000001571\n",
      "x = 1.0000000049999999696   | f1(x) = 8.8817843049588240945    | f2(x) = 3.0000000149999999088\n",
      "x = 1.0000000040000001089   | f1(x) = 0                        | f2(x) = 3.0000000120000001047\n",
      "x = 1.0000000030000000262   | f1(x) = 0                        | f2(x) = 3.0000000089999998565\n",
      "x = 1.0000000019999999434   | f1(x) = 0                        | f2(x) = 3.0000000059999996083\n",
      "x = 1.0000000010000000827   | f1(x) = 0                        | f2(x) = 3.0000000030000002482\n"
     ]
    }
   ],
   "source": [
    "#Implementamos f1\n",
    "def f1(x):\n",
    "    return (x**4-x**3-x+1)/((x-1)**2)\n",
    "\n",
    "#Implementamos f2\n",
    "def f2(x):\n",
    "    return x**2+x+1\n",
    "\n",
    "#Generamos 20 números entre (1, 1.00000002] (sin incluir el 1)\n",
    "nparray = np.linspace(1.00000002, 1., 20, endpoint=False)\n",
    "\n",
    "#Evaluamos las expresiones para cada número\n",
    "for f in nparray:\n",
    "    print(f'x = {format(f, \".20g\").ljust(23)} | f1(x) = {format(f1(f), \".20g\").ljust(23)}  | f2(x) = {format(f2(f), \".20g\")}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vemos, con la función $f_1$ para números cercanos a 1 (recordemos que estos números no producen ninguna indeterminación), no acabamos de aproximar adecuadamente el resultado. Mientras que la función $f_2$ no se encuentra con estos problemas. Esto se debe al fenómeno de cancelación comentado anteriormente que debemos tratar de evitar.\n",
    "\n",
    "### 2.7.- Propagación del error\n",
    "\n",
    "![](./images/worse-tarzan.gif)\n",
    "\n",
    "Como hemos visto, solo para almacenar un número real ya se comete un pequeño error. A continuación, al operar con ellos no solo se producen tantos errores como operandos, sino tras llevar a cabo cada una de las operaciones, se vuelve a cometer un error de redondeo. Si, por ejemplo, evaluamos $a+b+c$ siendo $a$, $b$, y $c$ tres números reales, tendremos los errores de almacenar los tres números, luego el error de redondeo de $a+b$ y, por último, el error de redondeo de $(a+b) + c$ (y no estamos teniendo en cuenta el error en la medición del dato). De esta forma si pensamos en un algoritmo que involucre una gran cantidad de operaciones elementales las perspectivas pueden parecer no muy buenas. Parece claro que debemos estudiar cuánto influye la propagación del error en el resultado final del problema. Dos son los principales conceptos ligados a este estudio:\n",
    "- **Condicionamiento**: mide la influencia que tendría en el resultado eventuales errores en los datos en el caso ideal de que se pudiese trabajar con aritmética exacta. Está ligado, por tanto, al problema en sí y no depende del algoritmo.\n",
    "- **Estabilidad**: está relacionada con la influencia que tiene en los resultados finales la acumulación de los errores que se producen en las sucesivas operaciones elementales que se llevan a cabo para resolver el problema.\n",
    "\n",
    "Ambos conceptos resultan bastante difíciles de analizar. Veamos un ejemplo de condicionamiento diseñado por el matemático R. S. Wilson:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Resolvamos un sistema lineal de la forma Ax = b (profundizaremos en esto más adelante)\n",
    "#Datos del ejemplo:\n",
    "A = [[10, 7, 8, 7],\n",
    "    [7, 5, 6, 5],\n",
    "    [8, 6, 10, 9],\n",
    "    [7, 5, 9, 10]]\n",
    "\n",
    "#La matriz con pequeños cambios la copiamos de la matriz original e introducimos los cambios\n",
    "A_aprox = [[10, 7, 8.1, 7.2],\n",
    "    [7.08, 5.04, 6, 5],\n",
    "    [8, 5.98, 9.89, 9],\n",
    "    [6.99, 4.99, 9, 9.98]]\n",
    "\n",
    "b = [32, 23, 33, 31]\n",
    "\n",
    "b_aprox = [32.1, 22.9, 33.1, 30.9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10x + 7y + 8z + 7t = 32\n",
      "7x + 5y + 6z + 5t = 23\n",
      "8x + 6y + 10z + 9t = 33\n",
      "7x + 5y + 9z + 10t = 31\n",
      "\n",
      "Solución del sistema:\n",
      "x = 1, y = 1, z = 1, t = 1\n",
      "\n",
      "--------------------\n",
      "\n",
      "10x + 7y + 8.1z + 7.2t = 32\n",
      "7.08x + 5.04y + 6z + 5t = 23\n",
      "8x + 5.98y + 9.89z + 9t = 33\n",
      "6.99x + 4.99y + 9z + 9.98t = 31\n",
      "\n",
      "Solución del sistema introduciendo pequeños errores en A:\n",
      "x = -81, y = 137, z = -34, t = 22\n",
      "\n",
      "--------------------\n",
      "\n",
      "10x + 7y + 8z + 7t = 32.1\n",
      "7x + 5y + 6z + 5t = 22.9\n",
      "8x + 6y + 10z + 9t = 33.1\n",
      "7x + 5y + 9z + 10t = 30.9\n",
      "\n",
      "Solución del sistema introduciendo pequeños errores en b:\n",
      "x = 9.2, y = -12.6, z = 4.5, t = -1.1\n"
     ]
    }
   ],
   "source": [
    "#Veamos las soluciones de los sistemas\n",
    "#Mostramos el sistema:\n",
    "def print_sistema(A, b):\n",
    "    ecuaciones = ''\n",
    "    incognitas = ['x', 'y', 'z', 't']\n",
    "    for i in range(4):\n",
    "        for j in range(4):\n",
    "            ecuaciones += f'{A[i][j]}{incognitas[j]} '\n",
    "            if j != 3:\n",
    "                ecuaciones += '+ '\n",
    "            else:\n",
    "                ecuaciones += '= '\n",
    "        ecuaciones += f'{b[i]}\\n'\n",
    "    print(ecuaciones)\n",
    "\n",
    "#Mostramos la solución dada del sistema\n",
    "def print_solucion(sol):\n",
    "    solucion = ''\n",
    "    incognitas = ['x', 'y', 'z', 't']\n",
    "    for i in range(4):\n",
    "        solucion += f'{incognitas[i]} = {format(sol[i], \".7g\")}'\n",
    "        if i != 3:\n",
    "            solucion += ', '\n",
    "    print(solucion)\n",
    "\n",
    "#Ax = b\n",
    "print_sistema(A, b)\n",
    "print('Solución del sistema:')\n",
    "print_solucion(np.linalg.solve(A, b))\n",
    "#A_aprox x = b\n",
    "print('\\n--------------------\\n')\n",
    "print_sistema(A_aprox, b)\n",
    "print('Solución del sistema introduciendo pequeños errores en A:')\n",
    "print_solucion(np.linalg.solve(A_aprox, b))\n",
    "#Ax = b_aprox\n",
    "print('\\n--------------------\\n')\n",
    "print_sistema(A, b_aprox)\n",
    "print('Solución del sistema introduciendo pequeños errores en b:')\n",
    "print_solucion(np.linalg.solve(A, b_aprox))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ante estos resultados, podemos decir que **este problema está mal condicionado**, o lo que es lo mismo, ante pequeñas perturbaciones en los datos, obtendremos resultados radicalmente diferentes.\n",
    "\n",
    "## 3.- Soluciones\n",
    "![](./images/aleluya.gif)\n",
    "\n",
    "En esta sección veremos distintas soluciones a los diferentes problemas que hemos ido viendo. Antes de introducir las distintas formas que hay de minimizar el impacto de las limitaciones de nuestros ordenadores, **es importante pensar si realmente necesitamos una solución y la precisión con la que queremos trabajar**. En muchas ocasiones, no se requiere de tanta precisión o, simplemente, basta con llevar a cabo algún tipo de ajuste en los datos de entrada. Por ejemplo, si estamos trabajando con unidades de medida, en lugar de utilizar medidas como 0.007 m, podemos tratar de cambiar la magnitud de nuestros datos a, por ejemplo, milímetros. Por supuesto, para ello deberemos estudiar cuál es el mayor número que alcanzaremos con nuestro problema y cuál es el menor, así como las necesidades del problema. Quizás, para llevar a cabo un estudio estadístico con el fin de describir un conjunto de datos no necesitamos una gran precisión y podemos asumir el error cometido al evaluar las operaciones. Esto, dependerá del problema y sus necesidades, pero como se ha comentado, es importante valorar qué precisión realmente necesitamos y qué solución se adecúa más a nuestro problema.\n",
    "\n",
    "### 3.1.- Display\n",
    "Es muy común que podamos asumir el pequeño error que se comete en las distintas operaciones y simplemente necesitamos mostrar una solución por pantalla razonble (en lugar de visualizar el número 0.30000000000000004 que se muestra al operar 0.1 + 0.2). Para ello hemos visto diferentes formas de mostrar estos resultados (téngase en cuenta que estas soluciones **solo arreglan el problema de visualización, pero internamente se seguirán arrastrando los errores**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3\n"
     ]
    }
   ],
   "source": [
    "#Utilizando format(float, número de cifras significativas)\n",
    "print(format(0.1 + 0.2, \".5g\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0.30000\n"
     ]
    }
   ],
   "source": [
    "#Utilizando f-strings\n",
    "print(f'{0.1 + 0.2: .5f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0.3\n"
     ]
    }
   ],
   "source": [
    "#Podemos elegir con las f-strings el número de decimales \n",
    "# (el .5 anterior indica el número de decimales que queremos mostrar)\n",
    "print(f'{0.1 + 0.2: .1f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Para obtener la parte entera simplemente basta con transformar el float a int\n",
    "int(4.231234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#¡Cuidado! Hacer cast de tipo float a entero hace un truncamiento, no un redondeo\n",
    "int(4.99923)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.512"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Se puede utilizar la función round indicando el número de decimales\n",
    "round(4.51231, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con la última solución hay que tener cuidado, en el sentido de que todos esperaríamos que si tenemos el número 2.675 se redondee con dos decimales a 2.68, sin embargo, recordemos que cuando un número se encuentra a la misma distancia de sus dos números máquina más cercanos, dependía del valor de un dígito binario. Esto mismo ocurre con la función `round`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "2.67\n",
      "2.67\n"
     ]
    }
   ],
   "source": [
    "print(round(2.5))\n",
    "print(round(3.5))\n",
    "print(round(2.675, 2))\n",
    "print(round(2.665, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `round`, aproxima como se espera excepto si se encuentra en medio camino entre ambos posibles redondeos, en cuyo caso, acudirá a su representación binaria y se redondeará al valor más cercano con un dígito menos significativo par.\n",
    "\n",
    "También existen las soluciones relacionadas con el truncamiento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import trunc\n",
    "#Se elimina la parte decimal, igual que al transformarlo a entero\n",
    "trunc(4.14332)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En caso de que queramos seleccionar el número de decimales a truncar tendríamos que implementar nuestra propia función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.99"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def truncar(real, num_decimales = 0):\n",
    "    factor = 10**num_decimales\n",
    "    real *= factor\n",
    "    real = trunc(real)\n",
    "    return real/factor\n",
    "\n",
    "truncar(4.9999, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas dos últimas soluciones, como las demás, no arreglarían el problema de aproximación del número 0.1, pero sí probablemente resolvería muchos problemas de almacenamiento de números más complicados. Veamos que no sigue sin ayudarnos a la hora de comparar 0.1 + 0.2 con 0.3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(.1, 1) + round(.2, 1) == round(.3, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Sin embargo, podría servirnos si aproximamos los resultaod sd elas operacioness\n",
    "round(.1 + .2, 1) == round(.3, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.- Comparación de números\n",
    "Quizás no nos interesa realmente ser capaces de almacenar y obtener una gran precisión en el tratamiento numérico, sino que simplemente queremos obtener resultados razonables al hacer comparaciones como `0.1 + 0.2 == 0.3` y obtener `True` como resultado. Una opción es utilizar el redondeo o truncamiento vistos en la sección anterior y aplicarlo a cada resultado de la operación. Sin embargo, esto resulta tedioso, ineficiente y hace menos legible el código. Para comparar números utilizaremos la función `isclose()` en lugar de los operadores `==`, `>=` o `<=` con los floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import isclose\n",
    "isclose(0.1 + 0.2, 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué hace realmente la función `isclose`? Comprueba si el segundo argumento se parece, de forma aceptable, al segundo argumento. Pero, ¿qué significa exactamente \"se parece, de forma aceptable\"? La idea se basa en comprobar **la distancia** entre el primer argumento y el segundo (la distancia se calcula como el error absoluto de los valores):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.551115123125783e-17"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "error_absoluto(0.1+0.2, 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si el error absoluto es más pequeño que un valor porcentual de la cantidad del primer argumento y del segundo (o lo que es lo mismo, se encuentra un error relativo bajo), entonces el primer argumento se considera lo suficientemente \"cercano\" al segundo argumento como para afirmar \"que son iguales\". Este porcentaje se denomina **tolerancia relativa** y por defecto tiene el valor de `1e-9` (o lo que es lo mismo, $10^{-9}$). En otras palabras, dos valores $a$ y $b$ se considerarán \"cercanos\" cuando:\n",
    "$$\n",
    "\\lvert a-b\\rvert<\\text{tol}\\cdot\\max\\left(\\lvert a\\rvert, \\lvert b\\rvert\\right)\n",
    "$$\n",
    "siendo $\\text{tol}$ la tolerancia relativa.\n",
    "\n",
    "Cuando la tolerancia relativa posee su valor por defecto, garantiza la igualdad en las primeras 9 cifras decimales, pero podemos cambiar la tolerancia para que sea más preciso o menos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Tolerancia relativa de 1e-20\n",
    "isclose(0.1 + 0.2, 0.3, rel_tol=1e-20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Tolerancia relativa de dos decimales\n",
    "isclose(3.253, 3.259, rel_tol=1e-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay un problema cuando $a$ o $b$ es cero y la tolerancia relativa se corresponde con un número inferior a 1. En este caso, da igual cuán cerca esté el otro número de cero, nunca se cumplirá la condición necesaria. En este caso se debe utilizar una **tolerancia absoluta**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 0\n",
    "b = 1e-10\n",
    "tol = 1e-9\n",
    "#Si usamos la tolerancia relativa fallará siempre independientemente del valor de b\n",
    "error_absoluto(a,b) < tol * max(abs(a), abs(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Si usamos una tolerancia absoluta esto no ocurrirá\n",
    "error_absoluto(a,b) < tol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta comprobación la realiza automáticamente el método `isclose` e incluye el parámetro de tolerancia absoluta que por defecto es 0.0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Probamos con el valor por defecto de tolerancia absoluta\n",
    "isclose(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Cambiamos el valor\n",
    "isclose(a, b, abs_tol=tol)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Y qué ocurre si queremos hacer comparaciones de tipo `<=`, `<`, `>=` o `>`? Entonces usaremos `isclose` y, a continuación, en función del resultado, ejecutaremos la comparación estricta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Definimos funciones menorque y menoroigual\n",
    "def menorque(a, b):\n",
    "    return not(isclose(a,b)) and a < b\n",
    "\n",
    "def menoroigual(a, b):\n",
    "    return isclose(a, b) or a < b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Antes: False | Ahora True\n",
      "Antes: False | Ahora True\n",
      "Antes: False | Ahora True\n",
      "Antes: False | Ahora True\n",
      "Antes: True | Ahora False\n",
      "Antes: True | Ahora False\n"
     ]
    }
   ],
   "source": [
    "#Probemos las comparaciones que antes no conseguíamos realizar correctamente:\n",
    "comparaciones = [(1.1 + 2.2, 3.3, '=='), (0.2 + 0.2 + 0.2, 0.6, '=='), (1.2 + 2.4 + 3.6, 7.2, '=='),\n",
    "                (0.1 + 0.2, 0.3, '<='), (31.2, 10.4 + 20.8, '<'), (0.7, 0.8 - 0.1, '<')]\n",
    "#Comparamos el resultado anterior con el nuevo utilizando las nuevas funciones:\n",
    "for a, b, op in comparaciones:\n",
    "    if op == '==':\n",
    "        print(f'Antes: {a == b} | Ahora {isclose(a,b)}')\n",
    "    elif op == '<=':\n",
    "        print(f'Antes: {a <= b} | Ahora {menoroigual(a,b)}')\n",
    "    else:\n",
    "        print(f'Antes: {a < b} | Ahora {menorque(a,b)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/yay-friends.gif)\n",
    "\n",
    "En `numpy` existen alternativas a la función `isclose` de la librería math:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# El valor por defecto de la tolerancia relativa es de 1e-05  y de la absoluta 1e-08\n",
    "np.allclose([0.1 + 0.2,1e-7], [0.3, 1e-8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose([0.1 + 0.2, 1e-8], [0.3, 1e-9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#También está la función is close\n",
    "np.isclose([0.1 + 0.2,1e-7], [0.3, 1e-8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.- Precisión en el almacenamiento y en las operaciones\n",
    "Antes de comenzar con las soluciones que nos permiten obtener mayor precisión en el almacenamiento de los números y en sus operaciones, debemos reincidir en la necesidad de crítica de cara al problema al que nos estemos enfrentando para saber si realmente necesitamos este tipo de soluciones y si se adaptan adecuadamente a las características de nuestro programa. Hay que tener en cuenta que aumentar la precisión en el almacenamiento conlleva un aumento en el tamaño de las variables para guardar el mismo valor que antes se almacenaba de manera \"más ligera\". Por otro lado, el aumento de la precisión en las operaciones con coma flotante, conlleva un aumento en el tiempo de ejecución del algoritmo. Por ese motivo, conviene recordar que antes de implementarla, es recomendable evaluar si es necesaria una solución de este tipo. Por ejemplo, si estamos gestionando un sistema de almacenamiento Big Data y los valores que guardamos no requieren esta precisión, conviene evitar este tipo de implementaciones, ya que lo único que se conseguirá será aumentar excesivamente los costes de almacenamiento de los datos.\n",
    "\n",
    "Existen dos módulos en Python que ofrecen una precisión casi absoluta para aquellas situaciones en las que usar el tipo `float` no resulta adecuado:\n",
    "\n",
    "#### 3.3.1.- Decimal\n",
    "El tipo `Decimal` puede almacenar valores decimales con anta precisión como necesites. Por defecto, garantiza la exactitud de 28 cifras significativas, pero es completamente editable. Se suele utilizar a la hora de trabajar con dinero o tipos de interés."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.3')"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Evaluamos la suma 0.1 + 0.2\n",
    "from decimal import Decimal\n",
    "\n",
    "Decimal(\"0.1\") + Decimal('0.2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.1428571428571428571428571429')"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculamos 1/7 con 28 cifras significativas exactas:\n",
    "Decimal(1) / Decimal(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.142857')"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Cambiemos la precisión\n",
    "from decimal import getcontext\n",
    "getcontext().prec = 6  # Usa 6 cifras significativas\n",
    "Decimal(1) / Decimal(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.1000000000000000055511151231257827021181583404541015625')"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Es posible también obtener el valor exacto almacenado en un float\n",
    "Decimal.from_float(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.1000000000000000055511151231257827021181583404541015625')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Lo anterior se puede simplificar como\n",
    "Decimal(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('9.25')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Con el tipo Decimal se puede operar igual que con los float:\n",
    "data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))\n",
    "max(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.03')"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Decimal('0.03'),\n",
       " Decimal('1.00'),\n",
       " Decimal('1.34'),\n",
       " Decimal('1.87'),\n",
       " Decimal('2.35'),\n",
       " Decimal('3.45'),\n",
       " Decimal('9.25')]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('19.29')"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('6.70')"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[0] * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('1.414213562373095048801688724')"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#También te permite calcular la raíz cuadrada\n",
    "Decimal(2).sqrt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('2.718281828459045235360287471')"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#La función exponencial\n",
    "Decimal(1).exp()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('2.302585092994045684017991455')"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#El logaritmo neperiano\n",
    "Decimal('10').ln()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('1')"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#El logaritmo en base 10\n",
    "Decimal('10').log10()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0000000000000004\n",
      "1.999999999999999999999999999\n"
     ]
    }
   ],
   "source": [
    "#Calculamos el cuadrado de la raíz de dos\n",
    "print((2 ** 0.5)**2)\n",
    "print((Decimal('2') ** Decimal('0.5')) ** Decimal('2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para continuar profundizando acerca de las funcionalidades y detalles del módulo `Decimal` de Python consúltese la [documentación](https://docs.python.org/3/library/decimal.html).\n",
    "\n",
    "#### 3.3.2.- Fraction\n",
    "El tipo `Fraction` permite almacenar números racionales de manera exacta y supera los problemas de error de representación que presentan los números en coma flotante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(1, 10)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Resolvemos el problema de 0.1 + 0.2 con Fraction\n",
    "from fractions import Fraction\n",
    "Fraction(1, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Fraction(1,10) + Fraction(2,10) == Fraction(3, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(-8, 5)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Simplifica automáticamente las fracciones\n",
    "Fraction(16, -10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(-3, 7)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Interpreta correctamente las cadenas de caracteres\n",
    "Fraction(' -3/7 ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(-1, 8)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Incluso transforma números decimales\n",
    "Fraction('-.125')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(3602879701896397, 36028797018963968)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Al igual que Decimal, también te da el valor exacto de float\n",
    "Fraction(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(55, 63)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Opera correctamente con las fracciones\n",
    "Fraction(3,7) + Fraction(4, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(15, 28)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Fraction(3,7) * Fraction(5, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6546536707079771"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Fraction(3, 7)**Fraction(1,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se quieren conocer más detalles del módulo `Fraction` de Python se puede consultar la [documentación](https://docs.python.org/3/library/fractions.html#module-fractions)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}