浮点数和双精度数有什么区别?

巨大的差异。

顾名思义, double 精度是 float ^〔1〕 . 一般来说A 双重的 精度为15位小数,而 浮动 有7个。

以下是计算位数的方法:

双重的 有52个尾数位+1个隐藏位:对数(2 ^五十三 )·对数(10)=15.95位

浮动 有23个尾数位+1个隐藏位:log(2 ^二十四 )·对数(10)=7.22位

这种精度损失可能导致截断错误更容易上浮,例如

float a = 1.f / 81;
float b = 0;
for (int i = 0; i < 729; ++ i)
    b += a;
printf("%.7g\n", b); // prints 9.000023

虽然

double a = 1.0 / 81;
double b = 0;
for (int i = 0; i < 729; ++ i)
    b += a;
printf("%.15g\n", b); // prints 8.99999999999996

另外,浮动的最大值大约是 3e38 但双份约 1.7e308 ,所以使用 浮动 可以更容易地达到“无穷大”(即一个特殊的浮点数字)比 双重的 对于一些简单的事情,例如计算60的阶乘。

在测试过程中,可能有一些测试用例包含这些巨大的数字,如果使用float,可能会导致程序失败。

当然,有时,甚至 双重的 不够准确,所以我们有时 long double ^〔1〕 (上面的示例在Mac上给出了9.00000000000000066),但是所有浮点类型都会受到 舍入误差 ,因此,如果精度非常重要(例如,货币处理),则应使用 int 或者分数班。

此外,不要使用 += 当错误快速累积时,求和许多浮点数。如果您使用的是python,请使用 fsum . 否则,尝试实现 Kahan summation algorithm .

^{〔1〕:C和C++标准没有指定 浮动 , 双重的 和 长双精度 . 这三个都有可能实现为IEEE双精度。然而,对于大多数架构(gcc、msvc;x86、x64、arm) 浮动 是 实际上是一个IEEE单精度浮点数(binary32),以及 双重的 是 一个IEEE双精度浮点数(binary64)。}

以下是标准C99(ISO-IEC 9899,2.2.5×10)或C++ 2003(ISO-IEC 1488—2003—3.1.9×8)标准:

有三种浮点类型: float , double 和 long double . 类型 双重的 提供的精度至少与 浮动 和类型 长双精度 提供的精度至少与 双重的 . 类型的值集 浮动 是类型值集的子集 双重的 ;类型的值集 双重的 是类型值集的子集 长双精度 .

C++标准增加了:

浮点类型的值表示是实现定义的。

我建议你看看 What Every Computer Scientist Should Know About Floating-Point Arithmetic 它深入介绍了IEEE浮点标准。您将了解表示细节,并认识到大小和精度之间存在权衡。浮点数表示的精度随着大小的减小而增加,因此-1和1之间的浮点数是精度最高的浮点数。

给出二次方程: X ^二 -4.0000000美元 X +3.999999=0,10个有效数字的确切根是, R _一 =2.000316228和 R _二 =1.999683772。

使用 float 和 double ,我们可以编写一个测试程序:

#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

请注意,这些数字并不大,但您仍然可以使用 浮动 .

(事实上,上述方法不是使用单精度或双精度浮点数求解二次方程的最佳方法,但即使使用 more stable method )

• 双精度是64,单精度是 (float)是32位。
• 双精度数有一个更大的尾数(实数的整数位)。
• 任何不准确的地方都会减少。

浮点数计算中涉及的数字大小不是最相关的。正在执行的计算是相关的。

实际上,如果您正在执行一个计算,结果是一个无理数或循环小数,那么当该数被压缩到您所使用的有限大小的数据结构中时,就会出现舍入错误。因为double的大小是float的两倍,所以舍入误差会小很多。

测试可能特别使用会导致此类错误的数字,因此测试您是否在代码中使用了适当的类型。

浮点数的精度比双精度小。尽管你已经知道了,读 What WE Should Know About Floating-Point Arithmetic 为了更好的理解。

类型float,32位长,精度为7位。虽然它可以存储范围非常大或非常小的值(+/-3.4*10^38或*10^-38),但它只有7个有效数字。

类型double,64位长,具有更大的范围(*10^+/-308)和15位精度。

类型long double名义上是80位,但是给定的编译器/OS对可能会将其存储为12-16字节,以便于对齐。长双精度数的指数非常大,应该有19位数的精度。微软以其无穷的智慧,将长双字节限制为8字节,与普通双字节相同。

一般来说,只需在需要浮点值/变量时使用类型double。默认情况下,表达式中使用的文本浮点值将被视为双精度浮点值,并且大多数返回浮点值的数学函数都返回双精度浮点值。如果你只使用double,你会省去很多头痛和打字。

我刚刚遇到了一个错误,我花了很长时间才弄明白,可能会给你一个很好的浮动精度的例子。

#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;
  }
}

输出为

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

正如您在0.83之后看到的,精度显著下降。

但是,如果我设置 t 作为双重身份,这样的问题不会发生。

我花了五个小时才意识到这个小错误,它毁了我的程序。

当使用浮点数时,您不能相信您的本地测试将与在服务器端完成的测试完全相同。在本地系统和运行最终测试的地方,环境和编译器可能是不同的。我以前在一些Topcoder竞赛中见过很多次这个问题,特别是当你试图比较两个浮点数字时。

内置比较操作的不同之处在于,当您将两个数字与浮点进行比较时,数据类型(即float或double)的差异可能会导致不同的结果。

float和double的区别在于double比float变量具有更高的精度值。 当您将变量声明为float时,它只允许在输入小数点后6位小数。 也就是说,对于一个浮点变量 float f= 2.3333333; //7位小数。 是可以存储的最大值

即使您存储的值在小数点后超过六位,它也不会存储整个数字,而是只存储到小数点后的前六位。 此外,如果尝试在该变量的小数点后存储超过7位,则会出现错误。在这种情况下,您需要如下初始化它- float f= 2.3333334443f; //那么编译器会将其解释为2.3333334

如果是双精度,它将在小数点后最多存储15位数字。 前任: double d=1.222222345675423; //小数点后15位

不同于 int (整数),a float 有小数点,所以 double . 但两者的区别在于 双重的 详细程度是 浮动 也就是说,小数点后的数字量可以增加一倍。