众所周知,NaNs在算术中传播,但我找不到任何演示,所以我写了一个小测试:
#include <limits>
#include <cstdio>
int main(int argc, char* argv[]) {
float qNaN = std::numeric_limits<float>::quiet_NaN();
float neg = -qNaN;
float sub1 = 6.0f - qNaN;
float sub2 = qNaN - 6.0f;
float sub3 = qNaN - qNaN;
float add1 = 6.0f + qNaN;
float add2 = qNaN + qNaN;
float div1 = 6.0f / qNaN;
float div2 = qNaN / 6.0f;
float div3 = qNaN / qNaN;
float mul1 = 6.0f * qNaN;
float mul2 = qNaN * qNaN;
printf( …为什么NaN值的比较与所有其他值的行为不同？也就是说,与运算符==,<=,> =,<,>的所有比较(其中一个或两个值为NaN)返回false,这与所有其他值的行为相反.
我想这可以通过某种方式简化数值计算,但我找不到明确说明的理由,甚至在Kahan 的IEEE 754状态讲义中也没有详细讨论其他设计决策.
这种异常行为在进行简单数据处理时会造成麻烦.例如,当在C程序中对某些实值字段的记录列表进行排序时,我需要编写额外的代码来处理NaN作为最大元素,否则排序算法可能会变得混乱.
编辑: 迄今为止的答案都认为比较NaNs毫无意义.
我同意,但这并不意味着正确的答案是错误的,而是一个非布尔值(NaB),幸运的是它不存在.
因此,在我看来,选择返回真或假的比较是任意的,对于一般数据处理,如果它遵循通常的定律(==的反射性,<= =,>的三分法),那将是有利的,以免数据结构依赖这些法律变得困惑.
因此,我要求打破这些法律的一些具体优势,而不仅仅是哲学推理.
编辑2: 我想我现在理解为什么使NaN最大化是一个坏主意,它会搞砸上限的计算.
可能需要NaN!= NaN以避免检测环路中的收敛,例如
while (x != oldX) {
oldX = x;
x = better_approximation(x);
}
然而,最好通过比较绝对差异与小限制来编写.所以恕我直言,这是打破NaN反身性的一个相对弱的论据.
浮点数据类型是单精度32位IEEE 754浮点数,双数据类型是双精度64位IEEE 754浮点数.
这是什么意思？什么时候应该使用float而不是double,反之亦然？
什么是最大的"非浮动"整数,可以存储在IEEE 754 double类型而不会丢失精度？
我知道大多数小数都没有精确的浮点表示(浮点数学是否被破坏？).
但我不明白为什么4*0.1打印得很好0.4,但3*0.1不是,当两个值实际上都有丑陋的十进制表示时:
>>> 3*0.1
0.30000000000000004
>>> 4*0.1
0.4
>>> from decimal import Decimal
>>> Decimal(3*0.1)
Decimal('0.3000000000000000444089209850062616169452667236328125')
>>> Decimal(4*0.1)
Decimal('0.40000000000000002220446049250313080847263336181640625')
为清楚起见,如果我使用的是实现IEE 754浮点数的语言,我声明:
float f0 = 0.f;
float f1 = 1.f;
...然后将它们打印出来,我会得到0.0000和1.0000 - 完全正确.
但IEEE 754无法表示实线上的所有数字.接近于零,"差距"很小; 当你越走越远时,差距越来越大.
所以,我的问题是:对于一个IEEE 754浮点数,这是第一个(最接近零)整数,无法准确表示？我现在只关心32位浮点数,虽然如果有人给出它我会有兴趣听到64位的答案!
我认为这就像计算2 bits_of_mantissa并添加1 一样简单,其中bits_of_mantissa是标准公开的位数.我在我的机器(MSVC++,Win64)上为32位浮点数做了这个,但它看起来很好.
不,这不是另一个"为什么是(1/3.0)*3!= 1"的问题.
我最近一直在读关于漂浮点的事情; 具体而言,相同的计算如何在不同的体系结构或优化设置上给出不同的结果.
对于存储重放的视频游戏来说,这是一个问题,或者是对等网络(而不是服务器 - 客户端),它依赖于每次运行程序时产生完全相同结果的所有客户端 - 一个小的差异浮点计算可能导致不同机器(甚至是同一台机器上)的游戏状态截然不同!
甚至在"跟随" IEEE-754的处理器中也会发生这种情况,这主要是因为某些处理器(即x86)使用双倍扩展精度.也就是说,它们使用80位寄存器进行所有计算,然后截断为64位或32位,导致与使用64位或32位进行计算的机器不同的舍入结果.
我在网上看到过这个问题的几种解决方案,但都是针对C++,而不是C#:
double使用_controlfp_s(Windows),_FPU_SETCW(Linux？)或fpsetprec(BSD)禁用双扩展精度模式(以便所有计算使用IEEE-754 64位).float和double完全.decimal可以用于此目的,但会慢得多,并且没有任何System.Math库函数支持它.那么,这在C#中是否也是一个问题？ 如果我只打算支持Windows(而不是Mono)怎么办？
如果是,有没有办法强制我的程序以正常的双精度运行？
如果没有,是否有任何库可以帮助保持浮点计算的一致性？
在以下示例中是否可以将除以0(或无穷大)？
public double calculation(double a, double b)
{
if (a == b)
{
return 0;
}
else
{
return 2 / (a - b);
}
}
在正常情况下,它当然不会.但是,如果a并且b非常接近,可能会(a-b)导致0计算的精确性？
请注意,这个问题适用于Java,但我认为它适用于大多数编程语言.
相关的IEEE标准定义了一个数字常量NaN(不是数字),并规定NaN应该比较为不等于它自己.这是为什么？
我熟悉的所有语言都实现了这个规则.但它经常会导致严重的问题,例如当NaN存储在容器中时,NaN存在于正在排序的数据中等时的意外行为等.更不用说,绝大多数程序员都希望任何对象都等于自身(在他们了解NaN之前,令人惊讶的是他们增加了错误和混乱.
IEEE标准经过深思熟虑,因此我确信NaN的比较与其本身相同是很糟糕的.我只是想不通它是什么.
PHP以其类型杂耍而闻名.我必须承认这让我很困惑,而且我很难在比较中找出基本的逻辑/基本事物.
例如:如果$a > $b是真实的,$b > $c是真实的,必须将它意味着$a > $c是永远真实的吗？
遵循基本逻辑,我会说是的,但是我很困惑,我真的不相信PHP.也许某人可以提供一个不是这样的例子？
另外,我想知道严格的小于和严格的大于运算符(因为它们的含义被严格描述,我过去只从等式比较中知道)如果左右操作数交换时有任何区别严格不平等的价值观:
# Precondition:
if ($a === $b) {
throw new Exception(
'Both are strictly equal - can not compare strictly for greater or smaller'
);
}
($a > $b) !== ($b > $a)
对于大多数类型比较组合,这些更大/更小的比较运算符没有记录,因此在这种情况下阅读手册并不是真正有用.