aula-01-ponto-flutuante.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conversão numérica e ponto flutuante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sistema binário\n",
    "\n",
    "Simples exercícios de conversão numérica para introduzi-lo à computação numérica com Python.\n",
    "\n",
    "### Exercícios de conversão numérica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n",
      "0b100\n"
     ]
    }
   ],
   "source": [
    "# (100)_2 -> base 10\n",
    "c = int('100',base=2)\n",
    "print(c)\n",
    "\n",
    "# representação  \n",
    "print(1*2**2 + 0*2**1 + 0*2**0)\n",
    "\n",
    "# (4)_10 -> base 2\n",
    "# obs: note que '0b' indica que o número é binário\n",
    "c = bin(4)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "146\n",
      "146\n",
      "0o222\n"
     ]
    }
   ],
   "source": [
    "# (222)_8\n",
    "c = int('222',base=8)\n",
    "print(c)\n",
    "\n",
    "# representação  \n",
    "print(2*8**2 + 2*8**1 + 2*8**0)\n",
    "\n",
    "# (146)_10 -> base 8\n",
    "\n",
    "c = oct(146)\n",
    "# obs: note que '0o' indica que o número é octal\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10980\n",
      "10980\n",
      "0o222\n"
     ]
    }
   ],
   "source": [
    "# (2AE4)_16\n",
    "c = int('2ae4',base=16)\n",
    "print(c)\n",
    "\n",
    "# representação  \n",
    "# obs: A = 10; E = 14\n",
    "print(2*16**3 + 10*16**2 + 14*16**1 + 4*166**0)\n",
    "\n",
    "# (146)_10 -> base 8\n",
    "\n",
    "c = oct(146)\n",
    "# obs: note que '0o' indica que o número é octal\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esquema de divisões sucessivas:\n",
      "\n",
      "4 | 2\n",
      "   –––\n",
      "0   2 | 2\n",
      "       –––\n",
      "    0   1\n"
     ]
    }
   ],
   "source": [
    "\"Brincando com Python e divisões sucessivas\"\n",
    "\n",
    "print('Esquema de divisões sucessivas:\\n')\n",
    "\n",
    "print(str(4) + ' | 2')\n",
    "print( str( len(str(4))*' ') + '  –––')\n",
    "print( str( 4 % 2) + '   ' + str(4 // 2) + ' | 2' )\n",
    "print( str( 5*len(str(4))*' ') + '  –––')\n",
    "print( str( 4*len(str(4))*' ') + str(4 % 2 % 2) + '   ' + str(4 // 2 // 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício:** estude a codificação do esquema acima. O que os operadores `//` e `%` estão fazendo?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Máquina binária \n",
    "\n",
    "O código abaixo é um protótipo para implementação de uma máquina binária. Uma versão muito mais robusta e melhor implementada pode ser vista aqui: https://vnicius.github.io/numbiosis/conversor/index.html."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** MÁQUINA BINÁRIA ***\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Converte inteiro para binário\n",
    "por divisões sucessivas.\n",
    "! Confronte com a função residente 'bin()'\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def int2bin(N):\n",
    "\n",
    "    b = [] # lista auxiliar\n",
    "\n",
    "    # divisões sucessivas\n",
    "    while N >= 2:\n",
    "        b.append(N % 2)\n",
    "        N = N//2\n",
    "\n",
    "    b.append(N)\n",
    "    b.reverse()\n",
    "    b = [str(i) for i in b] # converte para string\n",
    "    s = ''\n",
    "    s = s.join(b)\n",
    "\n",
    "    return s # retorna string\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Converte parte fracionária para binário\n",
    "por multiplicações sucessivas.\n",
    "\"\"\"\n",
    "def frac2bin(Q):\n",
    "\n",
    "    count = 0 # contador (limite manual posto em 10!)\n",
    "    b = []  # lista auxiliar\n",
    "\n",
    "    # multiplicações sucessivas\n",
    "    Q *= 2\n",
    "    while Q > 0 and count <= 10:\n",
    "        if Q > 1:\n",
    "            Q = Q-1\n",
    "            b.append(1)\n",
    "        else:\n",
    "            b.append(0)\n",
    "        Q *= 2\n",
    "        count += 1\n",
    "\n",
    "    b = [str(i) for i in b] # converte para string\n",
    "    s = ''\n",
    "    s = s.join(b)\n",
    "\n",
    "    return s # retorna string\n",
    "\n",
    "\n",
    "def convert(app,btn):\n",
    "    print(btn)\n",
    "\n",
    "\n",
    "\n",
    "# Função principal\n",
    "def main():\n",
    "\n",
    "    # Pré-criação da interface com usuário\n",
    "\n",
    "    # todo: tratamento de exceção no tipo de entrada\n",
    "    #       contagem de casas decimais no caso de dízimas\n",
    "         print('*** MÁQUINA BINÁRIA ***')\n",
    "    #     N = input('Selecione a parte inteira:\\n')\n",
    "    #     Q = input('Selecione a parte fracionária:\\n')\n",
    "    #     print('Seu número é: ' + int2bin( int(N) ) + '.' + frac2bin( float(Q) )  + '.')\n",
    "    #     print('*** ***')\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sistema de ponto flutuante \n",
    "\n",
    "### A reta \"perfurada\" \n",
    "\n",
    "Como temos estudado, a matemática computacional opera no domínio $\\mathbb{F}$, de pontos flutuantes, ao invés de trabalhar com números reais (conjunto $\\mathbb{R}$). Vejamos um exemplo: \n",
    "\n",
    "**Exemplo**: Considere o sistema de ponto flutuante $\\mathbb{F}(2,3,-1,2)$. Determinemos todos os seus números representáveis:\n",
    "\n",
    "Como a base é $2$, os dígitos possíveis são $0$ e $1$ com mantissas: \n",
    "\n",
    "- $0.100$\n",
    "- $0.101$\n",
    "- $0.110$\n",
    "- $0.111$\n",
    "\n",
    "Para cada expoente no conjunto $e=\\{-1,0,1,2\\}$, obteremos 16 números positivos, a saber: \n",
    "\n",
    "- $(0.100 \\times 2^{-1})_{2} = (0.01)_2 = 0.2^0 + 0.2^{-1} + 1.2^{-2} = 1/4$\n",
    "- $(0.100 \\times 2^{0})_{2} = (0.1)_2 = 0.2^0 + 1.2^{-1} = 1/2$\n",
    "- $(0.100 \\times 2^{1})_{2} = (1.0)_2 = 1.2^0 + 0.2^{-1} = 1$\n",
    "- $(0.100 \\times 2^{2})_{2} = (10.0)_2 = 1.2^1 + 0.2^{1} + 0.2^{-1} = 2$\n",
    "\n",
    "\n",
    "- $(0.101 \\times 2^{-1})_{2} = (0.0101)_2 = 0.2^0 + 0.2^{-1} + 1.2^{-2} + 0.2^{-3} + 1.2^{-4}= 5/16$\n",
    "- $(0.101 \\times 2^{0})_{2} = (0.101)_2 = 0.2^0 + 1.2^{-1} + 0.2^{-2} + 1.2^{-3} = 5/8$\n",
    "- $(0.101 \\times 2^{1})_{2} = (1.01)_2 = 1.2^0 + 0.2^{-1} + 1.2^{-2} = 1$\n",
    "- $(0.101 \\times 2^{2})_{2} = (10.1)_2 = 1.2^1 + 0.2^{1} + 0.2^{-1} = 2$\n",
    "\n",
    "(...)\n",
    "\n",
    "Fazendo as contas para os números restantes, obtemos a seguinte tabela: \n",
    "\n",
    "|     | m  | 0.100 | 0.101 | 0.110 | 0.111 |\n",
    "|-----|----|------ |-------|-------|-------|\n",
    "|**e**|    |       |       |       |       |\n",
    "| -1  |    | 1/4   | 5/16  | 3/8   | 7/16  |\n",
    "| 0   |    | 1/2   | 5/8   | 3/4   | 7/8   |\n",
    "| 1   |    | 1     | 5/4   | 3/2   | 7/4   |\n",
    "| 2   |    | 2     | 5/2   | 3     | 7/2   |\n",
    "\n",
    "Na reta real, esses valores ficariam dispostos da seguinte forma: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.pyplot import plot\n",
    "x = [1/4,1/2,1,2,5/16,5/8,5/4,5/2,3/8,3/4,3/2,3,7/16,7/8,7/4,7/2]\n",
    "x = sorted(x)\n",
    "\n",
    "plot(x,16*[0],':')\n",
    "plot(x,16*[0],'o');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isto é, $\\mathbb{F}$ é uma reta \"perfurada\", para a qual apenas 16 números positivos, 16 simétricos destes e mais o 0 são representáveis. Logo, o conjunto contém apenas 33 elementos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulador de $\\mathbb{F}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "def simulacao_F(b,t,L,U):\n",
    "    x = []\n",
    "    epsm = b**(1-t) # epsilon de máquina\n",
    "    M = np.arange(1.,b-epsm,epsm)\n",
    "    print(M)\n",
    "\n",
    "    E = 1\n",
    "    for e in range(0,U+1):\n",
    "        x = np.concatenate([x,M*E])\n",
    "        E *= b    \n",
    "    E = b**(-1)\n",
    "    \n",
    "    y = []\n",
    "    for e in range(-1,L-1,-1):\n",
    "        y = np.concatenate([y,M*E])\n",
    "        E /= b    \n",
    "    yy = np.asarray(y)\n",
    "    xx = np.asarray(x)    \n",
    "    x = np.concatenate([yy,np.array([0.]),xx])\n",
    "    return x\n",
    "\n",
    "Y = simulacao_F(2,2,-3,2)\n",
    "X = np.zeros(Y.shape)\n",
    "\n",
    "plt.scatter(Y,X,c='r',marker='+');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limites de máquina para ponto flutuante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsilon de máquina do numpy - 64 bits\n",
      "2.220446049250313e-16\n",
      "número máximo representável\n",
      "1.7976931348623157e+308\n",
      "número mínimo representável\n",
      "-1.7976931348623157e+308\n",
      "número de bits no expoente\n",
      "11\n",
      "número de bits na mantissa\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.pyplot import plot\n",
    "\n",
    "x = np.linspace(1e-15,1e-20,num=100)\n",
    "f = ((1+x)-1)/x\n",
    "plot(x,f);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ipub": {
     "ignore": true
    }
   },
   "outputs": [],
   "source": [
    "from IPython.core.display import HTML\n",
    "\n",
    "def css_styling():\n",
    "    styles = open(\"styles/custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling();"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}