Supondo que x é representado num computador por \bar{x}, onde \bar{x} é obtido por arredondamento, obtenha os limites superiores para os erros relativos de u=2 x e w=x+x. Qual das operações é mais precisa?
9. Mostre que 0,1 não possui representação finita em base 2 e explique as consequências desse fato em computação numérica.
Passo 1
O que o enunciado pede e o que nos foi dado.
Pede-se estimar limites superiores para os erros relativos ao computar:
u=2x quando x é representado por \bar{x} obtido por arredondamento;
w=x+x quando x é representado por \bar{x} obtido por arredondamento.
Comparar qual das duas operações (multiplicar por 2 ou somar x+x) é mais precisa.
Pede-se também mostrar que 0,1 (decimal) não tem representação finita em base 2 e explicar as consequências disso na computação numérica.
Informações relevantes implícitas no enunciado:
\bar{x} é o valor armazenado em máquina após arredondamento de x.
Usaremos o modelo usual de arredondamento em ponto flutuante: cada arredondamento introduz um erro relativo limitado pela chamada “unidade de arredondamento” (vou chamar essa unidade de \varepsilon). Em termos práticos, isso significa que qualquer resultado arredondado pode ser escrito como o valor exato multiplicado por 1+\delta, com |\delta|\le\varepsilon.
Não há mais informações (por ex. formato exato da base, número de bits do mantissa), então vamos dar bounds gerais e discutir casos especiais (como base binária).
Passo 2
Modelo de arredondamento e o que \varepsilon representa (aula rápida e importante).
Modelo padrão: se um número real y é arredondado para a representação em máquina, escrevemos
\mathrm{fl}(y)=y(1+\delta),
onde \delta é um número (o erro relativo do arredondamento) com
|\delta|\le\varepsilon.
Aqui \varepsilon é a unidade de arredondamento (às vezes chamada de «unit roundoff»). É um número pequeno que depende da base e do número de dígitos significativos (por ex. em ponto flutuante IEEE double \varepsilon\approx 2^{-53} se definido adequadamente). Não preciso do valor numérico para obter limites relativos em termos de \varepsilon.
Para qualquer operação aritmética elementar (soma, multiplicação, etc.) o resultado arredondado satisfaz o mesmo tipo de modelo: se z é o resultado exato de uma operação, o que a máquina produz é \mathrm{fl}(z)=z(1+\delta') com |\delta'|\le\varepsilon.
Observação importante (usar na prova): quando formos usar esse modelo teremos vários \delta's (um para o arredondamento inicial de x, outro para o arredondamento do resultado da operação). Vou nomeá-los para ficar claro o que cada um significa.
Passo 3
Análise de u=2x passo a passo (derivação do limite superior do erro relativo).
Primeiro expresso a armazenagem de x: por definição
\bar{x}=\mathrm{fl}(x)=x(1+\delta),
com |\delta|\le\varepsilon. Aqui \delta é o erro relativo devido ao arredondamento de x.
Agora suponho que a operação que a máquina faz para obter u é multiplicar a representação armazenada por 2 e então arredondar o produto. Escrevo o resultado computado como
Observação (caso especial útil): se a multiplicação por 2 não causar arredondamento (por exemplo, em aritmética binária multiplicar por 2 frequentemente só ajusta o expoente e pode ser exato), então \delta_1=0 e ficamos com
Observação crucial (propriedade da base 2 que melhora muito a precisão): se a máquina usa base 2 (o caso usual em ponto flutuante binário), a soma de duas cópias idênticas de um número normalizado é frequentemente exata. Para ver isso, represente \bar{x} na forma normalizada:
Como m\in[1,2) temos 2m\in[2,4). Ao normalizar 2m obtemos um mantissa \tilde m com a mesma precisão (os bits deslocam mas se mantêm), e portanto a soma resulta exatamente na representação normalizada de 2\bar{x} — ou seja, não há arredondamento adicional e \delta_2=0. Em palavras: duplicar um número binário normalizado é, tipicamente, uma operação exata (apenas incrementa o expoente); não acontece perda de bits significantes.
Consequência: em aritmética binária normal, ao computar w=x+x obtemos normalmente apenas o erro da representação inicial \delta, portanto
Isto acontece porque há dois arredondamentos possíveis: um ao armazenar x e outro na operação aritmética.
Contudo, ao considerar a implementação real em base 2 (caso mais comum), há uma diferença prática:
A soma x+x tende a ser mais precisa porque somar duas cópias idênticas tipicamente produz exatamente 2\bar{x} sem arredondamento adicional (a operação é representável exatamente apenas ajustando o expoente). Assim o único erro é o erro inicial da representação de x, e portanto o erro relativo final é \le\varepsilon.
A multiplicação 2\cdot \bar{x} pode também ser exata se a multiplicação por 2 for tratada internamente como ajuste de expoente; em muitos hardware/formatos binários isso ocorre, de modo que a multiplicação por um poder da base (como 2 em base 2) também pode ser exata. Mas em geral, a multiplicação é uma operação que pode envolver arredondamento, então no pior caso a multiplicação introduz um erro extra e o bound é do tipo 2\varepsilon+\varepsilon^2.
Conclusão prática: em termos de garantia teórica do pior caso, ambas têm o mesmo bound 2\varepsilon+\varepsilon^2. Em termos prático/afirmativo (especialmente em aritmética binária normal), w=x+x costuma ser mais preciso (erro \le\varepsilon) porque a soma de duas cópias idênticas é geralmente exata; portanto, se for necessário escolher por segurança, preferir x+x dá, na prática, precisão igual ou melhor que multiplicar por 2.
Passo 6
Mostre que 0,1 não tem representação finita em base 2: prova curta e direta.
Escrevendo em fração:
0{,}1_{\text{decimal}}=\frac{1}{10}.
Um número racional \dfrac{p}{q} tem representação finita na base 2 se, depois de simplificar a fração, o denominador q for uma potência de 2 (ou seja, q=2^k para algum k). Isso vem do fato que a expansão finita em base 2 equivale a uma soma finita de termos 2^{-k}, logo o denominador comum é uma potência de 2.
Para \dfrac{1}{10} temos 10=2\cdot 5. Após simplificar não há como eliminar o fator primo 5; portanto o denominador não é uma potência de 2. Logo \dfrac{1}{10} não tem representação finita em base 2.
Alternativa construtiva (mostrando repetição): multiplicando a parte fracionária por 2 repetidamente obtemos a sequência de dígitos binários que entra em ciclo. Procedimento rápido:
0{,}1\cdot 2=0{,}2 → dígito 0, resto 0{,}2.
0{,}2\cdot 2=0{,}4 → dígito 0, resto 0{,}4.
0{,}4\cdot 2=0{,}8 → dígito 0, resto 0{,}8.
0{,}8\cdot 2=1{,}6 → dígito 1, resto 0{,}6.
0{,}6\cdot 2=1{,}2 → dígito 1, resto 0{,}2.
O resto 0{,}2 já apareceu, de modo que os dígitos repetem ciclicamente. Portanto a expansão binária é infinita periódica (por exemplo 0{,}000110011\ldots_2).
Assim fica provado que 0{,}1 não tem expansão finita em base 2.
Passo 7
Consequências desse fato em computação numérica (o que você precisa saber e como agir na prova e em código).
Como 0{,}1 não pode ser representado exatamente em binário, a maioria das linguagens e hardware que usam ponto flutuante binário armazenam uma aproximação \overline{0{,}1} tal que
Comparações de igualdade direta falham frequentemente: por exemplo, em muitos ambientes(0{,}1 + 0{,}2) \neq 0{,}3devido aos erros de representação e arredondamento (cada constante decimal é aproximada por um binário diferente).
Impressão/formatção: números parecem “estranhos” (por exemplo 0.10000000000000001) se o formato imprimir muitos dígitos — isso vem da representação binária aproximada.
Acúmulo de erros: operações repetidas com números decimais não-exatos podem acumular erros e causar perda de precisão ou cancelamento numérico em subtrações.
Algoritmos que dependem de igualdade exata entre números racionais em ponto flutuante são frágeis; convém usar tolerâncias:\text{comparar }|a-b|\le\tau\\ (\text{tolerância}),\\ \text{não }a==b.âã
Como mitigar:
Usar aritmética decimal (algumas bibliotecas/linguagens oferecem decimal em que 0{,}1 é representável exatamente).
Usar tipos racionais ou inteiros escalados (por ex. representar dinheiro em centavos inteiros).
Usar tolerâncias/epsilons adequadas nas comparações.
Para somas acumuladas, usar somadores compensados (por ex. soma de Kahan) para reduzir erros de arredondamento.
Moral da história: o fato de 0{,}1 não ser finito em base 2 é a razão técnica por trás de vários comportamentos surpreendentes da aritmética de ponto flutuante. Saber disso evita surpresas e orienta boas práticas (usar tolerâncias, tipos adequados, algoritmos numericamente estáveis).
Resposta
Para ambos os cálculos, usando o modelo \bar{x}=x(1+\delta) com |\delta|\le\varepsilon e assumindo um arredondamento adicional da operação, o erro relativo satisfaz
Entretanto, em aritmética binária, a soma w=x+x normalmente é exata na etapa aritmética (somar duas cópias idênticas apenas ajusta o expoente), logo o erro final de w costuma ser apenas o erro inicial da representação de x, isto é
enquanto u=2x pode, no pior caso, atingir o bound 2\varepsilon+\varepsilon^2. Portanto x+x é, na prática, a operação mais precisa.
Além disso, 0{,}1=\tfrac{1}{10} não tem representação finita em base 2 (denominador contém fator primo 5), o que implica que constantes decimais como 0{,}1 são armazenadas apenas aproximadamente em ponto flutuante binário; consequência prática: erros de arredondamento visíveis, falhas em comparações de igualdade direta (por ex. 0{,}1+0{,}2\neq 0{,}3 na aritmética binária) e necessidade de usar tolerâncias, aritmética decimal ou técnicas numéricas estáveis.