Update documentation

_sources/aula-01-ponto-flutuante.ipynb

@@ -6,11 +6,11 @@
    "source": [
     "# Aritmética computacional\n",
     "\n",
-    "Computadores representam números inteiros de maneira exata. Entretanto, números reais possuem apenas representações aproximadas e em quantidades finitas. A aritmética computacional comumente opera com números inteiros e com os chamados _números em ponto flutuante._\n",
+    "Computadores representam números inteiros de maneira exata [{ref}`clipping-decimal`]. Entretanto, números reais possuem apenas representações aproximadas e em quantidades finitas. A aritmética computacional comumente opera com números inteiros e com os chamados _números em ponto flutuante._\n",
     "\n",
     "O interesse da aritmética computacional resume-se em dois pontos principais: i) a representação de números no formato de máquina (binário) e ii) a construção de algoritmos que realizam as operações fundamentais (adição, subtração, multiplicação e divisão). Em linhas gerais, métodos numéricos resultam de algoritmos sofisticados que utilizam essas quatro operações. \n",
     "\n",
-    "Atualmente, o padrão IEEE 754 é o mais amplamente seguido pelos fabricantes de processadores modernos. O documento orienta sobre como números em ponto flutuante devem ser representados, operados e comportar-se em qualquer arquitetura, seja de 16, 32, 64 ou mesmo 128 bits. A última atualização do padrão, cujo ano de origem é 1985, ocorreu em 2019 e está documentada neste [artigo](https://ieeexplore.ieee.org/document/8766229)."
+    "Atualmente, o padrão IEEE 754 [{ref}`clipping-ieee754`] é o mais amplamente seguido pelos fabricantes de processadores modernos. O documento orienta sobre como números em ponto flutuante devem ser representados, operados e comportar-se em qualquer arquitetura, seja de 16, 32, 64 ou mesmo 128 bits. A última atualização do padrão, cujo ano de origem é 1985, ocorreu em 2019 [[IEEE 754-2019]](https://ieeexplore.ieee.org/document/8766229)."
    ]
   },
   {
@@ -19,9 +19,17 @@
    "source": [
     "## Unidade Lógica e Aritmética\n",
     "\n",
-    "A _Unidade Lógica e Aritmética_ (ULA) é a parte do hardware computacional conectada à unidade central de processamento (CPU) que realiza as operações aritméticas e lógicas sobre os dados processados. A ULA é um componente eletrônico que funciona segundo a lógica dos cicuitos digitais, ou seja, interpretando operações em lógica Booleana (`and`, `or`, `not`).\n",
+    "A _Unidade Lógica e Aritmética_ (ULA) é a parte do hardware computacional conectada à unidade central de processamento (CPU) que realiza as operações aritméticas e lógicas sobre os dados processados ({numref}`fig-ula`). A ULA é um componente eletrônico que funciona segundo a lógica dos cicuitos digitais, ou seja, interpretando operações em lógica Booleana (`and`, `or`, `not`).\n",
     "\n",
-    "Há muito mais por trás das operações fundamentais executadas pelos computadores. Em Python, por exemplo, há casos de aproximações que chegam a ser curiosos. Isto ocorre devido ao erro inerente da representação numérica, principalmente quando os números são fracionários."
+    "Há muito mais por trás das operações fundamentais executadas pelos computadores. Em Python, por exemplo, há casos de aproximações que chegam a ser curiosos. Isto ocorre devido ao erro inerente da representação numérica, principalmente quando os números são fracionários.\n",
+    "\n",
+    "```{figure} figs/ula-ai.png\n",
+    "---\n",
+    "width: 400px\n",
+    "name: fig-ula\n",
+    "---\n",
+    "Ilustração de um chip de computador destacando as interconexões responsáveis por operações lógicas, aritméticas e troca de informação com a unidade de controle.\n",
+    "```"
    ]
   },
   {
@@ -30,7 +38,7 @@
    "source": [
     "## Casos curiosos\n",
     "\n",
-    "A aritmética de ponto flutuante possui situações inusitadas e respostas estranhas que podem levar-nos a duvidar se estamos realizando operações corretamente. Abaixo, mostramos alguns casos curiosos que ocorrem devido à representação finita de números pelo computador.\n",
+    "A aritmética de ponto flutuante possui situações inusitadas e respostas estranhas que podem levar-nos a duvidar se estamos realizando operações corretamente. Abaixo, mostramos alguns casos curiosos que ocorrem devido à representação finita de números pelo computador. Outras indagações sobre ponto flutuante são respondidas em [{ref}`extra-float`].\n",
     "\n",
     "\n",
     "- A fração $1/3 \\approx 0.3333\\ldots$ é uma dízima. O seu triplo é?"
@@ -673,64 +681,167 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Os seguintes parâmetros ajudam-nos a entender os limites de máquina am Python."
+    "Em Python, podemos utilizar diferentes sistemas de ponto flutuante. Cada um possui suas particularidades. Os mais comuns são:\n",
+    "\n",
+    "- `float16` (meia precisão): ideal para aplicações onde a velocidade e o uso de memória são críticos, como em inferências de aprendizado profundo em dispositivos com recursos limitados.\n",
+    "- `float32` (precisão simples): comumente usado em jogos, gráficos, e muitas aplicações de aprendizado de máquina devido ao bom equilíbrio entre precisão e eficiência.\n",
+    "- `float64` (precisão dupla; _alias_ para `float`): essencial para simulações científicas, finanças e outras áreas onde a precisão é crucial e a memória não é preocupação.\n",
+    "\n",
+    "O `numpy` suporta todos os três na maioria dos computadores de hoje ({numref}`Tabela %s <tbl-float>`). "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```{table} Comparativo entre sistemas de ponto flutuante\n",
+    ":name: tbl-float\n",
+    "\n",
+    "| Atributo              | `float16`                  | `float32`                  | `float64`                  |\n",
+    "|:-----------------------|:----------------------------|:----------------------------|:----------------------------|\n",
+    "| **Tamanho**           | 16 bits (2 bytes)          | 32 bits (4 bytes)          | 64 bits (8 bytes)          |\n",
+    "| **Precisão**          | Baixa                      | Moderada                   | Alta                       |\n",
+    "| **Intervalo de Valores** | $\\approx 5.96 \\times 10^{-8}$ a $6.55 \\times 10^{4} $ | $\\approx 1.18 \\times 10^{-38} $ a $3.4 \\times 10^{38} $ | $\\approx 2.23 \\times 10^{-308} $ a $1.8 \\times 10^{308} $ |\n",
+    "| **Bits de Sinal**     | 1                          | 1                          | 1                          |\n",
+    "| **Bits de Expoente**  | 5                          | 8                          | 11                         |\n",
+    "| **Bits de Mantissa**  | 10                         | 23                         | 52                         |\n",
+    "| **Uso de Memória**    | Muito baixo                | Moderado                   | Alto                       |\n",
+    "| **Aplicações**        | Aprendizado profundo em dispositivos de recursos limitados | Gráficos de computador, simulações científicas, aprendizado de máquina | Cálculos científicos, engenharia, finanças de alta precisão |\n",
+    "| **Exemplo de Valores** | $3.140625$ para representar aproximadamente $\\pi$ | $3.1415927$ para representar aproximadamente $\\pi$ | $3.141592653589793$ para representar aproximadamente $\\pi$ |\n",
+    "| **Vantagens**         | Usa menos memória e é mais rápido em termos de computação. Ideal para aplicações onde a memória é restrita e a precisão pode ser sacrificada. | Oferece um bom equilíbrio entre precisão e uso de memória. Amplamente utilizado em gráficos e aprendizado de máquina. | Alta precisão e amplo intervalo dinâmico. Ideal para cálculos científicos e de engenharia onde a precisão é crucial. |\n",
+    "| **Desvantagens**      | Precisão muito limitada, o que pode levar a erros significativos em cálculos complexos. | Pode não ser suficientemente preciso para cálculos científicos muito precisos. | Usa mais memória e pode ser mais lento em termos de computação comparado com float16 e float32. |\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A seguinte função imprime os valores dos principais atributos de `numpy.finfo` que nos ajudam a entender melhor os limites de máquina em Python para esses sistemas de ponto flutuante."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 152,
+   "execution_count": 36,
+   "metadata": {
+    "tags": [
+     "hide-input"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np \n",
+    "\n",
+    "def print_attribute(dtype: str, attrib: str) -> None:\n",
+    "    \"\"\"\n",
+    "    Imprime informações de atributo para os sistemas de ponto flutuante \\\n",
+    "        de 16, 32 e 64 bits operados pelo numpy\n",
+    "        \n",
+    "    Atributos relevantes: \n",
+    "    \n",
+    "        - eps: menor valor x, tal que 1.0 + x > 1.0 (epsilon de máquina)\n",
+    "        - max: maior número finito que pode ser representado pelo tipo de dado de ponto flutuante.\n",
+    "        - min: menor número finito negativo que pode ser representado pelo tipo de dado de ponto flutuante.\n",
+    "        - tiny: menor número positivo normalizado que pode ser representado.\n",
+    "        - nexp: número de bits no expoente       \n",
+    "        - nmant: número de bits na mantissa\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # checagem de sistema permitido\n",
+    "    assert dtype in ['float16', 'float32', 'float64'], 'Sistema não permitido!'\n",
+    "    \n",
+    "    # impressão    \n",
+    "    print(f'{attrib}:')\n",
+    "    exec(f'print(np.finfo(np.{dtype}).{attrib})')\n",
+    "\n",
+    "# # função para calculo do epsilon: erro relativo\n",
+    "# def eps_mach(func=float):\n",
+    "#     eps = func(1)\n",
+    "#     while func(1) + func(eps) != func(1):\n",
+    "#         epsf = eps\n",
+    "#         eps = func(eps) / func(2)\n",
+    "#     return epsf"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {},
+   "source": [
+    "A partir daí, podemos verificar os valores para cada sistema individualmente:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {
+    "tags": [
+     "hide-output"
+    ]
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epsilon de máquina do numpy - 64 bits\n",
+      "--- float16 \n",
+      "\n",
+      "eps:\n",
+      "0.000977\n",
+      "max:\n",
+      "65500.0\n",
+      "min:\n",
+      "-65500.0\n",
+      "tiny:\n",
+      "6.104e-05\n",
+      "nexp:\n",
+      "5\n",
+      "nmant:\n",
+      "10\n",
+      "\n",
+      "--- float32 \n",
+      "\n",
+      "eps:\n",
+      "1.1920929e-07\n",
+      "max:\n",
+      "3.4028235e+38\n",
+      "min:\n",
+      "-3.4028235e+38\n",
+      "tiny:\n",
+      "1.1754944e-38\n",
+      "nexp:\n",
+      "8\n",
+      "nmant:\n",
+      "23\n",
+      "\n",
+      "--- float64 (float) \n",
+      "\n",
+      "eps:\n",
       "2.220446049250313e-16\n",
-      "número máximo representável\n",
+      "max:\n",
       "1.7976931348623157e+308\n",
-      "número mínimo representável\n",
+      "min:\n",
       "-1.7976931348623157e+308\n",
-      "número de bits no expoente\n",
+      "tiny:\n",
+      "2.2250738585072014e-308\n",
+      "nexp:\n",
       "11\n",
-      "número de bits na mantissa\n",
+      "nmant:\n",
       "52\n"
      ]
     }
    ],
    "source": [
-    "import numpy as np \n",
-    "\n",
-    "# limites de máquina para ponto flutuante\n",
-    "#help(np.finfo)\n",
-    "\n",
-    "# epsilon de máquina para tipo float (64 bits)\n",
-    "print('Epsilon de máquina do numpy - 64 bits')\n",
-    "print(np.finfo(float).eps)\n",
-    "\n",
-    "# função para calculo do epsilon: erro relativo\n",
-    "def eps_mach(func=float):\n",
-    "    eps = func(1)\n",
-    "    while func(1) + func(eps) != func(1):\n",
-    "        epsf = eps\n",
-    "        eps = func(eps) / func(2)\n",
-    "    return epsf\n",
-    "\n",
-    "# número máximo representável \n",
-    "print('número máximo representável')\n",
-    "print(np.finfo(float).max)\n",
-    "\n",
-    "# número mínimo representável \n",
-    "print('número mínimo representável') \n",
-    "print(np.finfo(float).min)\n",
-    "\n",
-    "# número de bits no expoente \n",
-    "print('número de bits no expoente') \n",
-    "print(np.finfo(float).nexp)\n",
-    "\n",
-    "# número de bits na mantissa\n",
-    "print('número de bits na mantissa')\n",
-    "print(np.finfo(float).nmant)"
+    "print('--- float16 \\n')\n",
+    "for attrib in ['eps', 'max', 'min', 'tiny', 'nexp', 'nmant']:\n",
+    "    print_attribute('float16', attrib)\n",
+    "    \n",
+    "print('\\n--- float32 \\n')\n",
+    "for attrib in ['eps', 'max', 'min', 'tiny', 'nexp', 'nmant']:\n",
+    "    print_attribute('float32', attrib)\n",
+    "    \n",
+    "print('\\n--- float64 (float) \\n')\n",
+    "for attrib in ['eps', 'max', 'min', 'tiny', 'nexp', 'nmant']:\n",
+    "    print_attribute('float64', attrib)"
    ]
   },
   {