Erro de arredondamento - Round-off error

Um erro de arredondamento , também chamado de erro de arredondamento , é a diferença entre o resultado produzido por um determinado algoritmo usando aritmética exata e o resultado produzido pelo mesmo algoritmo usando aritmética arredondada de precisão finita. Os erros de arredondamento são devidos à inexatidão na representação dos números reais e nas operações aritméticas feitas com eles. Esta é uma forma de erro de quantização . Ao usar equações de aproximação ou algoritmos, especialmente ao usar finitos dígitos para representar números reais (que em teoria têm infinitos dígitos), um dos objetivos da análise numérica é estimar erros de computação. Os erros de computação, também chamados de erros numéricos , incluem erros de truncamento e erros de arredondamento.

Quando uma sequência de cálculos com uma entrada envolvendo qualquer erro de arredondamento é feita, os erros podem se acumular, às vezes dominando o cálculo. Em problemas mal condicionados , erros significativos podem se acumular.

Em suma, existem duas facetas principais de erros de arredondamento envolvidos em cálculos numéricos:

1. Os computadores digitais têm limites de magnitude e precisão em sua capacidade de representar números.
2. Certas manipulações numéricas são altamente sensíveis a erros de arredondamento. Isso pode resultar tanto de considerações matemáticas quanto da maneira como os computadores realizam operações aritméticas.

Erro de representação

O erro introduzido pela tentativa de representar um número usando uma sequência finita de dígitos é uma forma de erro de arredondamento denominado erro de representação . Aqui estão alguns exemplos de erro de representação em representações decimais:

Notação	Representação	Aproximação	Erro
1/7	0. 142 857	0,142 857	0,000 000 142 857
em 2	0,693 147 180 559 945 309 41 ...	0,693 147	0,000 000 180 559 945 309 41 ...
log 10 2	0,301 029 995 663 981 195 21 ...	0,3010	0,000 029 995 663 981 195 21 ...
3 √ 2	1,259 921 049 894 873 164 76 ...	1,25992	0,000 001 049 894 873 164 76 ...
√ 2	1,414 213 562 373 095 048 80 ...	1.41421	0,000 003 562 373 095 048 80 ...
e	2.718 281 828 459 045 235 36 ...	2.718 281 828 459 045	0,000 000 000 000 000 235 36 ...
π	3,141 592 653 589 793 238 46 ...	3,141 592 653 589 793	0,000 000 000 000 000 238 46 ...

Aumentar o número de dígitos permitidos em uma representação reduz a magnitude dos possíveis erros de arredondamento, mas qualquer representação limitada a um número finito de dígitos ainda causará algum grau de erro de arredondamento para incontáveis números reais. Dígitos adicionais usados ​​para etapas intermediárias de um cálculo são conhecidos como dígitos de guarda .

O arredondamento várias vezes pode causar o acúmulo de erros. Por exemplo, se 9,945309 for arredondado para duas casas decimais (9,95) e, em seguida, arredondado novamente para uma casa decimal (10,0), o erro total é 0,054691. O arredondamento de 9,945309 para uma casa decimal (9,9) em uma única etapa introduz menos erro (0,045309). Isso geralmente ocorre ao realizar operações aritméticas (consulte Perda de significância ).

Sistema numérico de ponto flutuante

Comparado com o sistema numérico de ponto fixo , o sistema numérico de ponto flutuante é mais eficiente na representação de números reais, por isso é amplamente utilizado em computadores modernos. Enquanto os números reais são infinitos e contínuos, um sistema numérico de ponto flutuante é finito e discreto. Assim, o erro de representação, que leva ao erro de arredondamento, ocorre no sistema numérico de ponto flutuante. ${\ displaystyle \ mathbb {R}}$${\ displaystyle F}$

Notação do sistema numérico de ponto flutuante

Um sistema numérico de ponto flutuante é caracterizado por inteiros: ${\ displaystyle F}$${\ displaystyle 4}$

${\ displaystyle \ beta}$: base ou radix

${\ displaystyle p}$: precisão

${\ displaystyle [L, U]}$: intervalo de expoentes, onde é o limite inferior e é o limite superior${\ displaystyle L}$${\ displaystyle U}$

• Qualquer tem o seguinte formato:${\ displaystyle x \ in F}$

${\ displaystyle x = \ pm (\ underbrace {d_ {0} .d_ {1} d_ {2} \ ldots d_ {p-1}} _ {\ text {mantissa}}) _ {\ beta} \ times \ beta ^ {\ overbrace {E} ^ {\ text {expoente}}} = \ pm d_ {0} \ times \ beta ^ {E} + d_ {1} \ times \ beta ^ {E-1} + \ ldots + d_ {p-1} \ vezes \ beta ^ {E- (p-1)}}$

onde é um inteiro tal que para , e é um inteiro tal que .${\ displaystyle d_ {i}}$${\ displaystyle 0 \ leq d_ {i} \ leq \ beta -1}$${\ displaystyle i = 0,1, \ ldots, p-1}$${\ displaystyle E}$${\ displaystyle L \ leq E \ leq U}$

Sistema de número flutuante normalizado

• Um sistema numérico de ponto flutuante é normalizado se o dígito inicial for sempre diferente de zero, a menos que o número seja zero. Como a mantissa é , a mantissa de um número diferente de zero em um sistema normalizado é satisfatória . Assim, a forma normalizada de um número de ponto flutuante IEEE diferente de zero é onde . Em binário, o dígito inicial é sempre assim não é escrito e é chamado de bit implícito. Isso fornece um pouco de precisão extra para que o erro de arredondamento causado pelo erro de representação seja reduzido.${\ displaystyle d_ {0}}$${\ displaystyle d_ {0} .d_ {1} d_ {2} \ ldots d_ {p-1}}$${\ displaystyle 1 \ leq {\ text {mantissa}} <\ beta}$${\ displaystyle \ pm 1.bb \ ldots b \ times 2 ^ {E}}$${\ displaystyle b \ in {0,1}}$${\ displaystyle 1}$
• Como o sistema numérico de ponto flutuante é finito e discreto, ele não pode representar todos os números reais, o que significa que os números reais infinitos só podem ser aproximados por alguns números finitos por meio de regras de arredondamento . A aproximação de ponto flutuante de um determinado número real por pode ser denotada. ${\ displaystyle F}$${\ displaystyle x}$${\ displaystyle fl (x)}$
  • O número total de números de ponto flutuante normalizados é

${\ displaystyle 2 (\ beta -1) \ beta ^ {p-1} (U-L + 1) +1}$, Onde

${\ displaystyle 2}$ conta a escolha do sinal, sendo positivo ou negativo

${\ displaystyle (\ beta -1)}$ conta a escolha do dígito principal

${\ displaystyle \ beta ^ {p-1}}$ conta mantissa restante

${\ displaystyle U-L + 1}$ conta a escolha de expoentes

${\ displaystyle 1}$conta o caso quando o número é .${\ displaystyle 0}$

Padrão IEEE

No padrão IEEE a base é binária, ou seja , e a normalização é usada. O padrão IEEE armazena o sinal, o expoente e a mantissa em campos separados de uma palavra de ponto flutuante, cada um com uma largura fixa (número de bits). Os dois níveis de precisão mais comumente usados ​​para números de ponto flutuante são precisão simples e precisão dupla. ${\ displaystyle \ beta = 2}$

Precisão	Sinal (bits)	Expoente (bits)	Mantissa (bits)
solteiro	1	8	23
Dobro	1	11	52

Epsilon de máquina

O épsilon da máquina pode ser usado para medir o nível de erro de arredondamento no sistema numérico de ponto flutuante. Aqui estão duas definições diferentes.

• O épsilon da máquina, denotado , é o erro relativo absoluto máximo possível na representação de um número real diferente de zero em um sistema numérico de ponto flutuante.${\ displaystyle \ epsilon _ {mach}}$${\ displaystyle x}$

${\ displaystyle \ epsilon _ {mach} = \ max _ {x} {\ frac {| x-fl (x) |} {| x |}}}$

• O épsilon da máquina, denotado , é o menor número desse tipo . Assim, sempre .${\ displaystyle \ epsilon _ {mach}}$${\ displaystyle \ epsilon}$${\ displaystyle fl (1+ \ epsilon)> 1}$${\ displaystyle fl (1+ \ delta) = fl (1) = 1}$${\ displaystyle | \ delta | <\ epsilon _ {mach}}$

Erro de arredondamento sob diferentes regras de arredondamento

Existem duas regras de arredondamento comuns, rodada a divisão e rodada para o mais próximo. O padrão IEEE usa arredondamento para o mais próximo.

• Rodada a corte : A expansão de base de é truncada após o dígito. ${\ displaystyle \ beta}$${\ displaystyle x}$${\ displaystyle (p-1) ^ {th}}$
  • Essa regra de arredondamento é tendenciosa porque sempre move o resultado para zero.
• Arredondar para o mais próximo : é definido para o número de ponto flutuante mais próximo para . Quando há um empate, o número de ponto flutuante cujo último dígito armazenado é par é usado. ${\ displaystyle fl (x)}$${\ displaystyle x}$
  • Para o padrão IEEE onde a base está , isso significa que quando houver empate, ela é arredondada para que o último dígito seja igual a .${\ displaystyle \ beta}$${\ displaystyle 2}$${\ displaystyle 0}$
  • Essa regra de arredondamento é mais precisa, mas mais cara do ponto de vista computacional.
  • O arredondamento para que o último dígito armazenado seja igual quando houver um empate garante que ele não seja arredondado para cima ou para baixo sistematicamente. Isso é para tentar evitar a possibilidade de um desvio lento indesejado em cálculos longos devido simplesmente a um arredondamento enviesado.
• O exemplo a seguir ilustra o nível de erro de arredondamento nas duas regras de arredondamento. A regra de arredondamento, arredondar para o mais próximo, leva a menos erros de arredondamento em geral.

x	Rodada por tacada	Erro de arredondamento	Arredondar para o mais próximo	Erro de arredondamento
1.649	1,6	0,049	1,6	0,049
1.650	1,6	0,050	1,7	0,050
1.651	1,6	0,051	1,7	-0,049
1.699	1,6	0,099	1,7	-0,001
1,749	1,7	0,049	1,7	0,049
1.750	1,7	0,050	1,8	-0,050

Calculando o erro de arredondamento no padrão IEEE

Suponha o uso de precisão dupla arredondada e IEEE.

• Exemplo: o número decimal pode ser reorganizado em${\ displaystyle (9.4) _ {10} = (1001. {\ overline {0110}}) _ {2}}$

${\ displaystyle +1. \ underbrace {0010110011001100110011001100110011001100110011001100} _ {\ text {52 bits}} 110 \ ldots \ times 2 ^ {3}}$

Como o bit à direita do ponto binário é a e é seguido por outros bits diferentes de zero, a regra de arredondamento para o mais próximo requer o arredondamento para cima, ou seja, adicionar o bit ao bit. Assim, a representação de ponto flutuante normalizado no padrão IEEE de é ${\ displaystyle 53 ^ {rd}}$${\ displaystyle 1}$${\ displaystyle 1}$${\ displaystyle 52 ^ {nd}}$${\ displaystyle 9.4}$

${\ displaystyle fl (9.4) = 1.0010110011001100110011001100110011001100110011001101 \ times 2 ^ {3}}$.

• Agora, o erro de arredondamento pode ser calculado ao representar com .${\ displaystyle 9.4}$${\ displaystyle fl (9.4)}$

Esta representação é derivada descartando a cauda infinita

${\ displaystyle 0. {\ overline {1100}} \ times 2 ^ {- 52} \ times 2 ^ {3} = 0. {\ overline {0110}} \ times 2 ^ {- 51} \ times 2 ^ { 3} = 0,4 \ vezes 2 ^ {- 48}}$

da cauda direita e, em seguida, adicionado na etapa de arredondamento. ${\ displaystyle 1 \ times 2 ^ {- 52} \ times 2 ^ {3} = 2 ^ {- 49}}$

Então .${\ displaystyle fl (9,4) = 9,4-0,4 \ times 2 ^ {- 48} +2 ^ {- 49} = 9,4 + (0,2) _ {10} \ times 2 ^ {- 49}}$

Portanto, o erro de arredondamento é .${\ displaystyle (0,2 \ vezes 2 ^ {- 49}) _ {10}}$

Medindo o erro de arredondamento usando o epsilon da máquina

O épsilon da máquina pode ser usado para medir o nível de erro de arredondamento ao usar as duas regras de arredondamento acima. Abaixo estão as fórmulas e as provas correspondentes. A primeira definição de épsilon de máquina é usada aqui. ${\ displaystyle \ epsilon _ {mach}}$

Teorema

1. Rodada a golpe: ${\ displaystyle \ epsilon _ {mach} = \ beta ^ {1-p}}$
2. Arredondar para o mais próximo: ${\ displaystyle \ epsilon _ {mach} = {\ frac {1} {2}} \ beta ^ {1-p}}$

Prova

Deixe onde , e seja a representação de ponto flutuante de . Uma vez que está sendo usado round-by-chop, é * Para determinar o máximo desta quantidade, é necessário encontrar o máximo do numerador e o mínimo do denominador. Já que (sistema normalizado), o valor mínimo do denominador é . O numerador é delimitado acima por . Assim ,. Portanto, para uma rodada a outra. A prova do arredondamento para o mais próximo é semelhante. ${\ displaystyle x = d_ {0} .d_ {1} d_ {2} \ ldots d_ {p-1} d_ {p} \ ldots \ times \ beta ^ {n} \ in \ mathbb {R}}$${\ displaystyle n \ in [L, U]}$${\ displaystyle fl (x)}$${\ displaystyle x}$${\ displaystyle {\ begin {align} {\ frac {| x-fl (x) |} {| x |}} & = {\ frac {| d_ {0} .d_ {1} d_ {2} \ ldots d_ {p-1} d_ {p} d_ {p + 1} \ ldots \ times \ beta ^ {n} -d_ {0} .d_ {1} d_ {2} \ ldots d_ {p-1} \ times \ beta ^ {n} |} {| d_ {0} .d_ {1} d_ {2} \ ldots \ times \ beta ^ {n} |}} \\ & = {\ frac {| d_ {p}. d_ {p + 1} \ ldots \ times \ beta ^ {np} |} {| d_ {0} .d_ {1} d_ {2} \ ldots \ times \ beta ^ {n} |}} \\ & = {\ frac {| d_ {p} .d_ {p + 1} d_ {p + 2} \ ldots |} {| d_ {0} .d_ {1} d_ {2} \ ldots |}} \ times \ beta ^ {- p} \ end {alinhado}}}$${\ displaystyle d_ {0} \ neq 0}$${\ displaystyle 1}$${\ displaystyle (\ beta -1). (\ beta -1) {\ overline {(\ beta -1)}} = \ beta}$${\ displaystyle {\ frac {| x-fl (x) |} {| x |}} \ leq {\ frac {\ beta} {1}} \ times \ beta ^ {- p} = \ beta ^ {1 -p}}$${\ displaystyle \ epsilon = \ beta ^ {1-p}}$

• Observe que a primeira definição de épsilon de máquina não é totalmente equivalente à segunda definição ao usar a regra de arredondamento para o mais próximo, mas é equivalente para rodada a divisão.

Erro de arredondamento causado por aritmética de ponto flutuante

Mesmo que alguns números possam ser representados exatamente por números de ponto flutuante e esses números sejam chamados de números de máquina , a execução da aritmética de ponto flutuante pode levar a um erro de arredondamento no resultado final.

Adição

A adição de máquina consiste em alinhar as casas decimais dos dois números a serem somados, adicioná-los e, em seguida, armazenar o resultado novamente como um número de ponto flutuante. A adição em si pode ser feita com maior precisão, mas o resultado deve ser arredondado para a precisão especificada, o que pode levar a um erro de arredondamento.

Por exemplo, adicionando ao IEEE precisão dupla da seguinte forma, ${\ displaystyle 1}$${\ displaystyle 2 ^ {- 53}}$

${\ displaystyle {\ begin {alinhados} 1,00 \ ldots 0 \ times 2 ^ {0} +1,00 \ ldots 0 \ times 2 ^ {- 53} & = 1. \ underbrace {00 \ ldots 0} _ {\ text { 52 bits}} \ times 2 ^ {0} +0. \ Underbrace {00 \ ldots 0} _ {\ text {52 bits}} 1 \ times 2 ^ {0} \\ & = 1. \ underbrace {00 \ ldots 0} _ {\ text {52 bits}} 1 \ vezes 2 ^ {0} \ end {alinhado}}}$

• Isso é salvo porque o arredondamento para o mais próximo é usado no padrão IEEE. Portanto, é igual a em precisão dupla IEEE e o erro de arredondamento é .${\ displaystyle 1. \ underbrace {00 \ ldots 0} _ {\ text {52 bits}} \ times 2 ^ {0}}$${\ displaystyle 1 + 2 ^ {- 53}}$${\ displaystyle 1}$${\ displaystyle 2 ^ {- 53}}$

A partir deste exemplo, pode ser visto que o erro de arredondamento pode ser introduzido ao fazer a adição de um número grande e um número pequeno, pois o deslocamento das casas decimais nas mantissas para fazer os expoentes coincidirem pode causar a perda de alguns dígitos.

Multiplicação

Em geral, o produto de mantissas -digit contém até dígitos, então o resultado pode não caber na mantissa. Assim, o erro de arredondamento estará envolvido no resultado. ${\ displaystyle 2}$ ${\ displaystyle p}$${\ displaystyle 2p}$

• Por exemplo, considere um sistema numérico de ponto flutuante normalizado com a base e os dígitos da mantissa no máximo . Então e . Observe que, mas uma vez que há no máximo dígitos de mantissa. O erro de arredondamento seria .${\ displaystyle \ beta = 10}$${\ displaystyle 2}$${\ displaystyle fl (77) = 7,7 \ vezes 10}$${\ displaystyle fl (88) = 8,8 \ vezes 10}$${\ displaystyle 77 \ times 88 = 6776}$${\ displaystyle fl (6776) = 6,7 \ vezes 10 ^ {3}}$${\ displaystyle 2}$${\ displaystyle 6776-fl (6776) = 6776-6,7 \ vezes 10 ^ {3} = 76}$

Divisão

Em geral, o quociente de mantissas -digito pode conter mais do que -digitos. Assim, o erro de arredondamento estará envolvido no resultado. ${\ displaystyle 2}$ ${\ displaystyle p}$${\ displaystyle p}$

• Por exemplo, se o sistema numérico de ponto flutuante normalizado acima ainda estiver sendo usado, mas . Então, a cauda é cortada.${\ displaystyle 1/3 = 0,333 \ ldots}$${\ displaystyle fl (1/3) = fl (0,333 \ ldots) = 3,3 \ vezes 10 ^ {- 1}}$${\ displaystyle 0,333 \ ldots -3,3 \ times 10 ^ {- 1} = 0,00333 \ ldots}$

Cancelamento subtrativo

A subtração de dois números quase iguais é chamada de cancelamento subtrativo .

• Quando os dígitos iniciais são cancelados, o resultado pode ser muito pequeno para ser representado exatamente e será apenas representado como . ${\ displaystyle 0}$
  • Por exemplo, deixe e a segunda definição de épsilon de máquina é usada aqui. Qual é a solução para ? Sabe-se que e são quase iguais em números, e . No entanto, no sistema numérico de ponto flutuante ,. Embora seja facilmente grande o suficiente para ser representado, ambas as instâncias de doações foram arredondadas .${\ displaystyle | \ epsilon | <\ epsilon _ {mach}}$${\ displaystyle (1+ \ epsilon) - (1- \ epsilon)}$
    ${\ displaystyle 1+ \ epsilon}$${\ displaystyle 1- \ epsilon}$${\ displaystyle (1+ \ epsilon) - (1- \ epsilon) = 1 + \ epsilon -1+ \ epsilon = 2 \ epsilon}$${\ displaystyle fl ((1+ \ epsilon) - (1- \ epsilon)) = fl (1+ \ epsilon) -fl (1- \ epsilon) = 1-1 = 0}$${\ displaystyle 2 \ epsilon}$${\ displaystyle \ epsilon}$${\ displaystyle 0}$
• Mesmo com um tamanho um pouco maior , o resultado ainda é significativamente não confiável em casos típicos. Não há muita fé na precisão do valor porque a maior incerteza em qualquer número de ponto flutuante são os dígitos na extrema direita. ${\ displaystyle \ epsilon}$
  • Por exemplo ,. O resultado é claramente representável, mas não há muita fé nele.${\ displaystyle 1,99999 \ times 10 ^ {2} -1,99998 \ times 10 ^ {2} = 0,00001 \ times 10 ^ {2} = 1 \ times 10 ^ {- 5} \ times 10 ^ {2} = 1 \ times 10 ^ {- 3}}$${\ displaystyle 1 \ times 10 ^ {- 3}}$

Acúmulo de erro de arredondamento

Os erros podem ser aumentados ou acumulados quando uma sequência de cálculos é aplicada em uma entrada inicial com erro de arredondamento devido à representação inexata.

Algoritmos instáveis

Um algoritmo ou processo numérico é chamado de estável se pequenas mudanças na entrada produzem apenas pequenas mudanças na saída e é chamado de instável se grandes mudanças na saída são produzidas.

Uma sequência de cálculos normalmente ocorre ao executar algum algoritmo. A quantidade de erro no resultado depende da estabilidade do algoritmo . O erro de arredondamento será ampliado por algoritmos instáveis.

Por exemplo, para com dado. É fácil mostrar isso . Suponha que seja nosso valor inicial e tenha um pequeno erro de representação , o que significa que a entrada inicial para este algoritmo é em vez de . Em seguida, o algoritmo faz a seguinte sequência de cálculos. ${\ displaystyle y_ {n} = \ int _ {0} ^ {1} \, {\ frac {x ^ {n}} {x + 5}} dx}$${\ displaystyle n = 1,2, \ ldots, 8}$${\ displaystyle y_ {0}}$${\ displaystyle y_ {n} = {\ frac {1} {n}} - 5y_ {n-1}}$${\ displaystyle y_ {0}}$${\ displaystyle \ epsilon}$${\ displaystyle y_ {0} + \ epsilon}$${\ displaystyle y_ {0}}$

${\ displaystyle {\ begin {align} y_ {1} & = 1-5 (y_ {0} + \ epsilon) = 1-5y_ {0} -5 \ epsilon \\ y_ {2} & = {\ frac { 1} {2}} - 5 (1-5y_ {0} -5 \ epsilon) = {\ frac {1} {2}} - 5 + 25y_ {0} + 5 ^ {2} \ epsilon \\\ vdots \\ y_ {n} & = \ ldots + 5 ^ {n} \ epsilon \ end {alinhado}}}$

O erro de arredondamento é amplificado nos cálculos subsequentes, de modo que o algoritmo é instável.

Problemas mal condicionados

Mesmo se um algoritmo estável for usado, a solução para um problema ainda pode ser imprecisa devido ao acúmulo de erro de arredondamento quando o próprio problema está mal condicionado .

O número da condição de um problema é a razão entre a mudança relativa na solução e a mudança relativa na entrada. Um problema é bem condicionado se pequenas mudanças relativas na entrada resultam em pequenas mudanças relativas na solução. Caso contrário, o problema está mal condicionado . Em outras palavras, um problema é mal condicionado se seu número de condição for "muito maior" do que . ${\ displaystyle 1}$

O número da condição é introduzido como uma medida dos erros de arredondamento que podem resultar na solução de problemas mal condicionados.

Exemplo do mundo real: falha do míssil Patriot devido à ampliação do erro de arredondamento

Em 25 de fevereiro de 1991, durante a Guerra do Golfo, uma bateria de mísseis American Patriot em Dharan, Arábia Saudita, não conseguiu interceptar um míssil Scud iraquiano. O Scud atingiu um quartel do exército americano e matou 28 soldados. Um relatório do então Escritório de Contabilidade Geral intitulado "Defesa contra mísseis Patriot: Problema de software que levou à falha do sistema em Dhahran, Arábia Saudita" relatou a causa da falha: um cálculo impreciso do tempo desde a inicialização devido a erros aritméticos do computador. Especificamente, o tempo em décimos de segundo, medido pelo relógio interno do sistema, foi multiplicado por 10 para produzir o tempo em segundos. Este cálculo foi executado usando um registrador de ponto fixo de 24 bits. Em particular, o valor 1/10, que tem uma expansão binária não terminal, foi cortado em 24 bits após o ponto raiz. O pequeno erro de corte, quando multiplicado pelo grande número que dá o tempo em décimos de segundo, levou a um erro significativo. Na verdade, a bateria do Patriot estava funcionando por cerca de 100 horas, e um cálculo fácil mostra que o erro de tempo resultante devido ao erro de corte ampliado foi de cerca de 0,34 segundos. (O número 1/10 é igual . Em outras palavras, a expansão binária de 1/10 é . Agora, o registrador de 24 bits no Patriot armazenado em vez de introduzir um erro de binário, ou aproximadamente decimal. Multiplicando pelo número de décimos de segundo em horas dá ). Um Scud viaja por volta de${\ displaystyle 1/2 ^ {4} + 1/2 ^ {5} + 1/2 ^ {8} + 1/2 ^ {9} + 1/2 ^ {12} + 1/2 ^ {13} + \ ldots}$${\ displaystyle 0,0001100110011001100110011001100 \ ldots}$${\ displaystyle 0,00011001100110011001100}$${\ displaystyle 0,0000000000000000000000011001100 \ ldots}$${\ displaystyle 0,000000095}$${\ displaystyle 100}$${\ displaystyle 0,000000095 \ times 100 \ times 60 \ times 60 \ times 10 = 0,34}$1676 metros por segundo e, portanto, viaja mais de meio quilômetro neste tempo. Isso era longe o suficiente para que o Scud que estava entrando ficasse fora do "portão de alcance" que o Patriot rastreou. Ironicamente, o fato de o cálculo do tempo incorreto ter sido aprimorado em algumas partes do código, mas não em todas, contribuiu para o problema, já que significava que as imprecisões não eram canceladas.

Veja também

• Precisão (aritmética)
• Truncamento
• Arredondamento
• Perda de significância
• Ponto flutuante
• Algoritmo de soma Kahan
• Epsilon de máquina
• Polinômio de Wilkinson

Referências

Leitura adicional

• Matt Parker (2021). Humble Pi: Quando a matemática dá errado no mundo real . Riverhead Books. ISBN 978-0593084694.

links externos

• Erro de arredondamento em MathWorld.
• Goldberg, David (março de 1991). "O que todo cientista da computação deve saber sobre aritmética de ponto flutuante" (PDF) . Pesquisas de computação ACM . 23 (1): 5–48. doi : 10.1145 / 103162.103163 . Recuperado 2016-01-20 .( [1] , [2] )
• 20 famosos desastres de software