我从计算机系统:程序员的观点中了解到,IEEE标准要求使用以下64位二进制格式表示双精度浮点数:
+无穷大表示为具有以下模式的特殊值:
我认为double的完整64位应按以下顺序排列:
(一个或多个)(EXP)(FRAC)
所以我编写以下C代码来验证它:
//Check the infinity
double x1 = (double)0x7ff0000000000000; // This should be the +infinity
double x2 = (double)0x7ff0000000000001; // Note the extra ending 1, x2 should be NaN
printf("\nx1 = %f, x2 = %f sizeof(double) = %d", x1,x2, sizeof(x2));
if (x1 == x2)
printf("\nx1 == x2");
else
printf("\nx1 != x2");
但结果是:
x1 = 9218868437227405300.000000, x2 = 9218868437227405300.000000 sizeof(double) = 8
x1 == x2
为什么数字是有效数字而不是无穷大错误？
为什么x1 == x2？
(我正在使用MinGW GCC编译器.)
我修改了下面的代码,并成功验证了Infinity和NaN.
//Check the infinity and NaN
unsigned long long x1 = 0x7ff0000000000000ULL; // +infinity as double
unsigned long long x2 = 0xfff0000000000000ULL; // -infinity as double
unsigned long long x3 = 0x7ff0000000000001ULL; // NaN as double
double y1 =* ((double *)(&x1));
double y2 =* ((double *)(&x2));
double y3 =* ((double *)(&x3));
printf("\nsizeof(long long) = %d", sizeof(x1));
printf("\nx1 = %f, x2 = %f, x3 = %f", x1, x2, x3); // %f is good enough for output
printf("\ny1 = %f, y2 = %f, y3 = %f", y1, y2, y3);
结果是:
sizeof(long long) = 8
x1 = 1.#INF00, x2 = -1.#INF00, x3 = 1.#SNAN0
y1 = 1.#INF00, y2 = -1.#INF00, y3 = 1.#QNAN0
详细输出看起来有点奇怪,但我认为这一点很清楚.
PS.:似乎没有必要转换指针.只是%f用来告诉printf函数以格式解释unsigned long long变量double.
出于好奇,我用以下代码检查了变量的位表示.
typedef unsigned char *byte_pointer;
void show_bytes(byte_pointer start, int len)
{
int i;
for (i = len-1; i>=0; i--)
{
printf("%.2x", start[i]);
}
printf("\n");
}
我尝试了下面的代码:
//check the infinity and NaN
unsigned long long x1 = 0x7ff0000000000000ULL; // +infinity as double
unsigned long long x2 = 0xfff0000000000000ULL; // -infinity as double
unsigned long long x3 = 0x7ff0000000000001ULL; // NaN as double
double y1 =* ((double *)(&x1));
double y2 =* ((double *)(&x2));
double y3 = *((double *)(&x3));
unsigned long long x4 = x1 + x2; // I want to check (+infinity)+(-infinity)
double y4 = y1 + y2; // I want to check (+infinity)+(-infinity)
printf("\nx1: ");
show_bytes((byte_pointer)&x1, sizeof(x1));
printf("\nx2: ");
show_bytes((byte_pointer)&x2, sizeof(x2));
printf("\nx3: ");
show_bytes((byte_pointer)&x3, sizeof(x3));
printf("\nx4: ");
show_bytes((byte_pointer)&x4, sizeof(x4));
printf("\ny1: ");
show_bytes((byte_pointer)&y1, sizeof(y1));
printf("\ny2: ");
show_bytes((byte_pointer)&y2, sizeof(y2));
printf("\ny3: ");
show_bytes((byte_pointer)&y3, sizeof(y3));
printf("\ny4: ");
show_bytes((byte_pointer)&y4, sizeof(y4));
输出是:
x1: 7ff0000000000000
x2: fff0000000000000
x3: 7ff0000000000001
x4: 7fe0000000000000
y1: 7ff0000000000000
y2: fff0000000000000
y3: 7ff8000000000001
y4: fff8000000000000 // <== Different with x4
奇怪的是,虽然x1和x2具有与y1和y2相同的位模式,但是和x4与y4不同.
和
printf("\ny4=%f", y4);
给出这个:
y4=-1.#IND00 // What does it mean???
他们为什么不同？y4是如何获得的？
cma*_*ter 20
首先,0x7ff0000000000000确实是双无穷大的位表示.但是强制转换不设置位表示,它将0x7ff0000000000000解释的逻辑值转换为64位整数.因此,您需要使用其他一些方法来设置位模式.
设置位模式的直接方法是
uint64_t bits = 0x7ff0000000000000;
double infinity = *(double*)&bits;
但是,这是未定义的行为.C标准禁止读取已存储为一个基本类型(uint64_t)的值作为另一个基本类型(double).这称为严格别名规则,并允许编译器生成更好的代码,因为它可以假定一种类型的读取顺序和另一种类型的写入无关紧要.
此规则的唯一例外是char类型:您明确允许将任何指针强制转换为a char*和back.所以你可以尝试使用这段代码:
char bits[] = {0x7f, 0xf0, 0, 0, 0, 0, 0, 0};
double infinity = *(double*)bits;
即使这不再是未定义的行为,它仍然是实现定义的行为:a中字节的顺序double取决于您的机器.给定的代码适用于ARM和Power系列等大端机器,但不适用于X86.对于X86,您需要以下版本:
char bits[] = {0, 0, 0, 0, 0, 0, 0xf0, 0x7f};
double infinity = *(double*)bits;
实际上没有办法解决此实现定义的行为,因为无法保证计算机将以与整数值相同的顺序存储浮点值.甚至有机器使用像这样的字节顺序:<1,0,3,2>我甚至不想知道是谁提出了这个好主意,但它存在并且我们必须忍受它.
对于你的上一个问题:浮点运算与整数运算本质上是不同的.这些位具有特殊含义,浮点单元将其考虑在内.特别是像无穷大,NAN和非规范化数字这样的特殊值以特殊方式处理.由于+inf + -inf定义为产生NAN,因此浮点单元会发出NAN的位模式.整数单元不知道无穷大或NAN,所以它只是将位模式解释为一个巨大的整数,并愉快地执行整数加法(在这种情况下恰好溢出).得到的位模式不是NAN的模式.它恰好是一个非常巨大的正浮点数的位模式(2^1023确切地说),但这没有任何意义.
实际上,有一种方法可以以可移植的方式设置除NAN之外的所有值的位模式:给定三个包含符号,指数和尾数位的变量,您可以这样做:
uint64_t sign = ..., exponent = ..., mantissa = ...;
double result;
assert(!(exponent == 0x7ff && mantissa)); //Can't set the bits of a NAN in this way.
if(exponent) {
//This code does not work for denormalized numbers. And it won't honor the value of mantissa when the exponent signals NAN or infinity.
result = mantissa + (1ull << 52); //Add the implicit bit.
result /= (1ull << 52); //This makes sure that the exponent is logically zero (equals the bias), so that the next operation will work as expected.
result *= pow(2, (double)((signed)exponent - 0x3ff)); //This sets the exponent.
} else {
//This code works for denormalized numbers.
result = mantissa; //No implicit bit.
result /= (1ull << 51); //This ensures that the next operation works as expected.
result *= pow(2, -0x3ff); //Scale down to the denormalized range.
}
result *= (sign ? -1.0 : 1.0); //This sets the sign.
这使用浮点单元本身将位移动到正确的位置.由于无法使用浮点运算与NAN的尾数位进行交互,因此无法在此代码中包含NAN的生成.好吧,你可以生成一个NAN,但你无法控制它的尾数位模式.
初始化
double x1=(double)0x7ff0000000000000;
正在将整数转换为a double.您可能希望共享按位表示.这是特定于实现的(可能是未指定的行为),但您可以使用union:
union { double x; long long n; } u;
u.n = 0x7ff0000000000000LL;
然后使用u.x; 我假设long long,并double在你的机器上都为64位.并且endianess和浮点表示也很重要.
另见http://floating-point-gui.de/
请注意,并非所有处理器都是x86,并非所有浮点实现都是IEEE754(即使在2014年大多数都是).您的代码在ARM处理器上可能不会起作用,例如在平板电脑中.
您将值转换为double,并且不会像预期的那样工作.
double x1=(double)0x7ff0000000000000; // Not setting the value directly
为了避免这个问题,您可以将该值解释为双指针并取消引用它(尽管这是非常不推荐的,并且只适用于无符号long long == double size约束):
unsigned long long x1n = 0x7ff0000000000000ULL; // Inf
double x1 = *((double*)&x1n);
unsigned long long x2n = 0x7ff0000000000001ULL; // Signaling NaN
double x2 = *((double*)&x2n);
printf("\nx1=%f, x2=%f sizeof(double) = %d", x1, x2, sizeof(x2));
if (x1 == x2)
printf("\nx1==x2");
else
printf("\nx1!=x2"); // x1 != x2
你已经转换恒0x7ff00...成double.这与获取该值的位表示并将其解释为a完全相同double.
这也解释了原因x1==x2.当你转换为double时,你会失去精确度; 所以有时对于大整数,double你最终得到的结果与两种情况相同.这给你一些奇怪的效果,对于一个大的浮点值,加1使它保持不变.