Os limites da variável dupla em c ++

variáveis ​​de ponto flutuante em C ++ vêm com suas próprias limitações. Eles não podem ser usados ​​para contar coisas, eles levam mais tempo para processar, eles consomem mais memória, e eles também sofrem de erro de arredondamento (embora não tão ruim quanto int

). Agora, para considerar cada um desses problemas, por sua vez.

Contando com o dobro

Você não pode usar uma variável de ponto flutuante em um aplicativo, onde a contagem é importante. Em C ++, você não pode dizer que há 7,0 personagens de meu primeiro nome. Operadores envolvidos na contagem não funcionam em variáveis ​​de ponto flutuante. Em particular, o auto-incremento (++) e auto-redução (- -) operadores são estritamente verboten em Duplo.

velocidade de cálculo da dupla

Os computadores podem realizar operações aritméticas inteiro mais rápido do que eles podem fazer aritmética de ponto flutuante. Felizmente, os processadores de ponto flutuante ter sido construído em CPUs por muitos anos agora, para a diferença de desempenho não é tão significativa como era antes. O ciclo seguinte foi escrito apenas como um exemplo simples, primeiro usando aritmética inteira:

int nValue1 = 1, nValue2 = 2, nValue3 = 2-para (int i = 0- i lt; 1000000000- i ++) {int nAverage = (+ nValue1 nValue2 + nValue3) / 3-}

Este ciclo demorou cerca de 5 segundos para executar. Executar o mesmo ciclo em ponto flutuante aritmética:

duplo dValue1 = 1, dValue2 = 2, dValue3 = 2-para (int i = 0- i lt; 1000000000- i ++) {double DAVERAGE = (+ dValue1 dValue2 + dValue3) / 3.0-}

Este olhar levou cerca de 21 segundos para executar. Calculando uma média de 1 bilhão de vezes em pouco mais de 20 segundos não é gasto, mas ainda é quatro vezes mais lento do que o tempo de processamento para o seu valor inteiro equivalente.

A variável dupla consome mais memória

Em um PC ou Macintosh, um int consome 4 bytes, enquanto que um Duplo leva-se 8 bytes. Isso não soa como muito - e, de fato, não é - mas se você tivesse alguns milhões dessas coisas para manter na memória. . . Bem, ainda não seria muito. Mas se você tivesse um pouco cem milhões, então a diferença seria considerável.

Video: Me Salva! ITD06 - Integral Dupla iterada - Invertendo os limites de integração exemplo 3

Esta é outra maneira de dizer que a menos que você precisa para armazenar um pedaço de um monte de objetos, não se preocupe com a diferença de memória ocupada por um tipo em relação a outro. Em vez disso, escolher o tipo de variável que atenda às suas necessidades.

Se você só acontecerá a estar programando um aplicativo que precisa (por exemplo) para manipular a idade de cada ser humano no planeta, ao mesmo tempo, então você pode querer inclinar-se para o menor int porque consome menos memória. (Você faz esse tipo de coisa muitas vezes?)

Perda de precisão com dupla

Uma variável dupla tem cerca de 16 dígitos significativos de precisão. Considere que um matemático expressaria o número 1/3 como 0,333. . ., Onde as elipses indicam que os trios continuar para sempre. O conceito de uma série infinita faz sentido em matemática, mas não em computação.

Um computador só tem uma quantidade finita de memória e uma quantidade finita de precisão. Por isso, tem que terminar, o que resulta em uma pequena (mas real) erro.

C ++ pode corrigir erro de arredondamento em uma série de casos. Por exemplo, na saída, se uma variável é ,99999999999999, C ++ só vai assumir que é realmente 1.0 e exibi-lo em conformidade. No entanto, C ++ pode não correta para todos os erros de arredondamento de ponto flutuante, por isso você precisa ter cuidado. Por exemplo, você não pode ter certeza que 1/3 + 1/3 + 1/3 é igual a 1,0:

duplo d1 = 23,0 duplo-D2 = D1 / 7,0-se (d1 == (d2 * 7.0)) {cout lt; lt; "Nós chegamos aqui?" lt; lt; endl-}

Você pode pensar que este trecho de código seria sempre exibir o “Chegamos aqui?” corda, mas surpreendentemente não. O problema é que 23 dividido por 7 não podem ser expressos exatamente em um número de ponto flutuante. Algo está perdido. portanto d2 * 7 está muito perto de 23, mas não é exatamente igual.

Em vez de procurar a igualdade exata entre dois números de ponto flutuante, você deve estar se perguntando: “Será d2 * 7 vanishingly perto de d1 em valor?” Você pode fazer isso da seguinte forma:

double d2 d1 = 23.0-double = d1 / 7.0 - // É d2 * 7.0 dentro delta de d1 dupla diferença = (d2 * 7.0) -? d1-double delta = 0,00001-se (diferença lt; delta && diferença gt; -delta) {cout lt; lt; "Nós chegamos aqui?" lt; lt; endl-}

Este trecho de código calcula a diferença entre d1 e d2 * 7.0. Se esta diferença é inferior a alguns pequena delta, o código chama-lo um dia e diz que d1 e d2 * 7 são essencialmente iguais.

Video: Me Salva! ITD04 - Integral Dupla iterada - Invertendo os limites de integração exemplo 1

faixa não tão limitada da dupla

O maior número que uma loja dupla lata é aproximadamente 10 elevado à potência 38. Isso é um 1 com 38 zeros depois ele- que come a 2 bilhões tamanho máximo insignificante para um int para o pequeno almoço. Isso é ainda mais do que a dívida nacional (pelo menos, no momento da redação deste texto). Há provavelmente aplicações onde 38 zeros não são suficientes.

Lembre-se que apenas os primeiros 16 dígitos são significativos. Os restantes 22 dígitos são ruído, tendo já sucumbiu ao erro de arredondamento de ponto flutuante padrão.