Qual é a diferença entre flutuar e dobrar?

Eis o que a norma C99 (ISO-IEC 9899 6.2.5 §10) ou C++2003 (ISO-IEC 14882-2003 3.1.9 §8) diz:

Existem três tipos de vírgula flutuante: float, double, e long double O tipo double fornece pelo menos tanta precisão como float, e o tipo long double fornece pelo menos tanta precisão como double. O conjunto de valores do tipo float é um subconjunto do conjunto de valores do tipo double; o conjunto de valores do tipo double é um subconjunto do conjunto de valores de o tipo long double.

A norma c++ adiciona:

A representação dos valores dos tipos de vírgula flutuante é definida pela aplicação.

Dada uma equação quadrática: x² - 4.0000000 x + 3.9999999 = 0, a exata raízes para 10 dígitos significativos são, r₁ = 2.000316228 e r₂ = 1.999683772.

Usando float e double, podemos escrever um programa de teste:

#include <stdio.h>
#include <math.h>

void dbl_solve(double a, double b, double c)
{
    double d = b*b - 4.0*a*c;
    double sd = sqrt(d);
    double r1 = (-b + sd) / (2.0*a);
    double r2 = (-b - sd) / (2.0*a);
    printf("%.5f\t%.5f\n", r1, r2);
}

void flt_solve(float a, float b, float c)
{
    float d = b*b - 4.0f*a*c;
    float sd = sqrtf(d);
    float r1 = (-b + sd) / (2.0f*a);
    float r2 = (-b - sd) / (2.0f*a);
    printf("%.5f\t%.5f\n", r1, r2);
}   

int main(void)
{
    float fa = 1.0f;
    float fb = -4.0000000f;
    float fc = 3.9999999f;
    double da = 1.0;
    double db = -4.0000000;
    double dc = 3.9999999;
    flt_solve(fa, fb, fc);
    dbl_solve(da, db, dc);
    return 0;
}  

2.00000 2.00000
2.00032 1.99968

Note que os números não são grandes, mas ainda assim você tem efeitos de cancelamento usando float.

(Na verdade, o acima não é o a melhor maneira de resolver equações quadráticas usando números de ponto flutuante de precisão simples ou dupla, mas a resposta permanece inalterada mesmo que se utilize um método mais estável.)

• um duplo é 64 e uma única precisão (float) é de 32 bits.
• o duplo tem um mantissa maior (os bits inteiros do número real).
• qualquer imprecisão será menor no duplo.

O tamanho dos números envolvidos nos cálculos do ponto flutuante não é a coisa mais relevante. É o cálculo que está sendo realizado que é relevante.

Em essência, se você está realizando um cálculo e o resultado é um número irracional ou recorrente decimal, então haverá erros de arredondamento quando esse número é esmagado na estrutura de dados de tamanho finito que você está usando. Uma vez que o dobro é o dobro do tamanho do flutuador, então o erro de arredondamento será muito inferior.

Os testes podem usar números específicos que causariam este tipo de erro e, portanto, testaram que tinha usado o tipo apropriado no seu código.

O tipo flutuante, com 32 bits de comprimento, tem uma precisão de 7 dígitos. Embora possa armazenar valores com uma gama muito grande ou muito pequena (+/- 3.4 * 10^38 ou * 10^-38), tem apenas 7 dígitos significativos.

O tipo duplo, com 64 bits de comprimento, tem uma gama maior (*10^+/-308) e uma precisão de 15 dígitos.

O tipo duplo longo é nominalmente de 80 bits, embora um dado compilador / os emparelhamento possa armazená-lo como 12-16 bytes para fins de alinhamento. O duplo longo tem um expoente que apenas ridiculamente enorme e deve tem 19 dígitos de precisão. A Microsoft, na Sua infinita sabedoria, limita o dobro a 8 bytes, o mesmo que o duplo simples.

De um modo geral, basta usar o tipo duplo quando precisar de um valor/variável de vírgula flutuante. Valores literais de vírgula flutuante usados em expressões serão tratados como duplos por padrão, e a maioria das funções matemáticas que retornam valores de vírgula flutuante retornam duplos. Poupas muitas dores de cabeça e digestões se usares o dobro.

#include <iostream>
#include <iomanip>

int main(){
  for(float t=0;t<1;t+=0.01){
     std::cout << std::fixed << std::setprecision(6) << t << std::endl;
  }
}

A saída é

0.000000
0.010000
0.020000
0.030000
0.040000
0.050000
0.060000
0.070000
0.080000
0.090000
0.100000
0.110000
0.120000
0.130000
0.140000
0.150000
0.160000
0.170000
0.180000
0.190000
0.200000
0.210000
0.220000
0.230000
0.240000
0.250000
0.260000
0.270000
0.280000
0.290000
0.300000
0.310000
0.320000
0.330000
0.340000
0.350000
0.360000
0.370000
0.380000
0.390000
0.400000
0.410000
0.420000
0.430000
0.440000
0.450000
0.460000
0.470000
0.480000
0.490000
0.500000
0.510000
0.520000
0.530000
0.540000
0.550000
0.560000
0.570000
0.580000
0.590000
0.600000
0.610000
0.620000
0.630000
0.640000
0.650000
0.660000
0.670000
0.680000
0.690000
0.700000
0.710000
0.720000
0.730000
0.740000
0.750000
0.760000
0.770000
0.780000
0.790000
0.800000
0.810000
0.820000
0.830000
0.839999
0.849999
0.859999
0.869999
0.879999
0.889999
0.899999
0.909999
0.919999
0.929999
0.939999
0.949999
0.959999
0.969999
0.979999
0.989999
0.999999

Como pode ver depois de 0, 83, a precisão diminui significativamente.

Ao usar números de vírgula flutuante, não pode confiar que os seus testes locais serão exactamente os mesmos que os testes que são feitos do lado do servidor. O ambiente e o compilador são provavelmente diferentes em você Sistema local e onde os testes finais são executados. Já vi este problema muitas vezes em algumas competições de Topcoders, especialmente se você tentar comparar dois números de ponto flutuante.

As operações de comparação incorporadas diferem como quando se compara 2 números com vírgula flutuante, a diferença no tipo de dados (isto é, vírgula flutuante ou duplo) pode resultar em resultados diferentes.

Ao contrário de um int (Número Inteiro), um float tem um ponto decimal, e assim pode um double. Mas a diferença entre os dois é que um double é duas vezes mais detalhado que um float, o que significa que pode ter o dobro da quantidade de números após o ponto decimal.