blocks|key|27301|text|您永远不应该比较浮点数或双精度数是否相等；因为，您不能真正保证分配给浮点数或双精度数的数字是准确的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|27302|要合理地比较浮点数的相等性，您需要检查值是否“足够接近”相同的值：|27303|if+((first+>=+second+-+error)+%7C%7C+(first+<=+second+%2B+error)|code-block|syntax|javascript|27304|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You shouldn't ever compare floats or doubles for equality; because, you can't really guarantee that the number you assign to the float or double is exact.

To compare floats for equality sanely, you need to check if the value is "close enough" to the same value:

<pre><code>if ((first &gt;= second - error) || (first &lt;= second + error)
</code></pre>

blocks|key|4534802|text|作为一种变通办法，下面是什么呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4534803|public+double+calculation(double+a,+double+b)+{
+++++double+c+=+a+-+b;
+++++if+(c+==+0)
+++++{
+++++++++return+0;
+++++}
+++++else
+++++{
+++++++++return+2+/+c;
+++++}
}|code-block|syntax|javascript|4534804|这样，您就不需要依赖任何语言的IEEE支持。|4534805|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

As a workaround, what about the following?

<pre class="lang-java prettyprint-override"><code>public double calculation(double a, double b) {
 double c = a - b;
 if (c == 0)
 {
 return 0;
 }
 else
 {
 return 2 / c;
 }
}
</code></pre>

That way you don't depend on IEEE support in any language.

blocks|key|27358|text|这里不会出现被零除的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|27359|SMT+Solver+Z3支持精确的IEEE浮点运算。让Z3找出数字a和b，这样a+!=+b+&&+(a+-+b)+==+0就可以|offset|length|style|CODE|27360|(set-info+:status+unknown)
(set-logic+QF_FP)
(declare-fun+b+()+(FloatingPoint+8+24))
(declare-fun+a+()+(FloatingPoint+8+24))
(declare-fun+rm+()+RoundingMode)
(assert
(and+(not+(fp.eq+a+b))+(fp.eq+(fp.sub+rm+a+b)+%2Bzero)+true))
(check-sat)|code-block|syntax|javascript|27361|结果是UNSAT。没有这样的数字。|27362|上面的SMTLIB字符串还允许Z3选择任意舍入模式(rm)。这意味着结果适用于所有可能的舍入模式(其中有五种)。结果还包括其中任何变量可能为NaN或无穷大的可能性。|27363|a+==+b以fp.eq+quality的形式实现，因此%2B0f和-0f的性能相当。与零的比较也是使用fp.eq实现的。由于这个问题的目的是避免被零除，所以这是适当的比较。|27364|如果相等测试是使用位相等实现的，那么%2B0f和-0f将是使a+-+b为零的一种方法。此答案的一个不正确的先前版本包含有关该情况的模式详细信息，供好奇的人使用。|27365|Z3+Online还不支持FPA理论。这个结果是使用最新的不稳定分支得到的。可以使用.NET绑定重现它，如下所示：|27366|var+fpSort+=+context.MkFPSort32();
var+aExpr+=+(FPExpr)context.MkConst("a",+fpSort);
var+bExpr+=+(FPExpr)context.MkConst("b",+fpSort);
var+rmExpr+=+(FPRMExpr)context.MkConst("rm",+context.MkFPRoundingModeSort());
var+fpZero+=+context.MkFP(0f,+fpSort);
var+subExpr+=+context.MkFPSub(rmExpr,+aExpr,+bExpr);
var+constraintExpr+=+context.MkAnd(
++++++++context.MkNot(context.MkFPEq(aExpr,+bExpr)),
++++++++context.MkFPEq(subExpr,+fpZero),
++++++++context.MkTrue()
++++);

var+smtlibString+=+context.BenchmarkToSMTString(null,+"QF_FP",+null,+null,+new+BoolExpr[0],+constraintExpr);

var+solver+=+context.MkSimpleSolver();
solver.Assert(constraintExpr);

var+status+=+solver.Check();
Console.WriteLine(status);|27367|使用Z3回答IEEE浮动问题是很好的，因为它很难忽略案例(例如NaN、-0f、%2B-inf)，并且您可以提出任意问题。不需要解释和引用规范。您甚至可以提出混合浮点数和整数的问题，比如“这个特定的int+log2(float)算法正确吗？”|27368|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories|1|http://z3.codeplex.com/|2|http://rise4fun.com/z3^0|0|Y|1|10|1|14|M|0|A|0|B|2|1|0|0|3|5|0|Q|2|1Y|3|0|0|6|7|5|S|3|W|3|1E|5|0|I|3|M|3|S|5|0|0|9|2|0|0|V|3|Z|3|13|5|2O|F|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]]|9|@$D|1K|E|1L|1|1M]|$D|1N|E|1O|1|1P]]|A|$]]|$1|H|3|I|5|J|7|1Q|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1R|8|@$D|1S|E|1T|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1U|8|@$D|1V|E|1W|F|G]|$D|1X|E|1Y|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1Z|8|@$D|20|E|21|F|G]|$D|22|E|23|F|G]|$D|24|E|25|F|G]|$D|26|E|27|F|G]|$D|28|E|29|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|2A|8|@$D|2B|E|2C|F|G]|$D|2D|E|2E|F|G]|$D|2F|E|2G|F|G]]|9|@]|A|$]]|$1|U|3|V|5|6|7|2H|8|@]|9|@$D|2I|E|2J|1|2K]]|A|$]]|$1|W|3|X|5|J|7|2L|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|2M|8|@$D|2N|E|2O|F|G]|$D|2P|E|2Q|F|G]|$D|2R|E|2S|F|G]|$D|2T|E|2U|F|G]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|2V|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|13|14|15|A|$16|19]]|1A|$5|13|14|15|A|$16|1B]]]]

There is no case where a division by zero can happen here.

The <a href="http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories">SMT Solver</a> <a href="http://z3.codeplex.com/">Z3</a> supports precise IEEE floating point arithmetic. Let's ask Z3 to find numbers <code>a</code> and <code>b</code> such that <code>a != b &amp;&amp; (a - b) == 0</code>:

<pre><code>(set-info :status unknown)
(set-logic QF_FP)
(declare-fun b () (FloatingPoint 8 24))
(declare-fun a () (FloatingPoint 8 24))
(declare-fun rm () RoundingMode)
(assert
(and (not (fp.eq a b)) (fp.eq (fp.sub rm a b) +zero) true))
(check-sat)
</code></pre>

The result is <code>UNSAT</code>. There are no such numbers.

The above SMTLIB string also allows Z3 to pick an arbitrary rounding mode (<code>rm</code>). This means that the result holds for all possible rounding modes (of which there are five). The result also includes the possibility that any of the variables in play might be <code>NaN</code> or infinity.

<code>a == b</code> is implemented as <code>fp.eq</code> quality so that <code>+0f</code> and <code>-0f</code> compare equal. The comparison with zero is implemented using <code>fp.eq</code> as well. Since the question is aimed at avoiding a division by zero this is the appropriate comparison.

If the equality test was implemented using bitwise equality, <code>+0f</code> and <code>-0f</code> would have been a way to make <code>a - b</code> zero. An incorrect previous version of this answer contains mode details about that case for the curious.

<a href="http://rise4fun.com/z3">Z3 Online</a> does not yet support the FPA theory. This result was obtained using the latest unstable branch. It can be reproduced using the .NET bindings as follows:

<pre><code>var fpSort = context.MkFPSort32();
var aExpr = (FPExpr)context.MkConst("a", fpSort);
var bExpr = (FPExpr)context.MkConst("b", fpSort);
var rmExpr = (FPRMExpr)context.MkConst("rm", context.MkFPRoundingModeSort());
var fpZero = context.MkFP(0f, fpSort);
var subExpr = context.MkFPSub(rmExpr, aExpr, bExpr);
var constraintExpr = context.MkAnd(
 context.MkNot(context.MkFPEq(aExpr, bExpr)),
 context.MkFPEq(subExpr, fpZero),
 context.MkTrue()
 );

var smtlibString = context.BenchmarkToSMTString(null, "QF_FP", null, null, new BoolExpr[0], constraintExpr);

var solver = context.MkSimpleSolver();
solver.Assert(constraintExpr);

var status = solver.Check();
Console.WriteLine(status);
</code></pre>

Using Z3 to answer IEEE float questions is nice because it is hard to overlook cases (such as <code>NaN</code>, <code>-0f</code>, <code>+-inf</code>) and you can ask arbitrary questions. No need to interpret and cite specifications. You can even ask mixed float and integer questions such as "is this particular <code>int log2(float)</code> algorithm correct?".

blocks|key|27443|text|所提供的函数确实可以返回无穷大：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|27444|public+class+Test+{
++++public+static+double+calculation(double+a,+double+b)
++++{
+++++++++if+(a+==+b)
+++++++++{
+++++++++++++return+0;
+++++++++}
+++++++++else
+++++++++{
+++++++++++++return+2+/+(a+-+b);
+++++++++}
++++}++++

++++/**
+++++*+@param+args
+++++*/
++++public+static+void+main(String[]+args)+{
++++++++double+d1+=+Double.MIN_VALUE;
++++++++double+d2+=+2.0+*+Double.MIN_VALUE;
++++++++System.out.println("Result:+"+%2B+calculation(d1,+d2));+
++++}
}|code-block|syntax|javascript|27445|输出为Result:+-Infinity。|offset|length|style|CODE|27446|当除法的结果太大而需要存储在双精度数中时，即使分母不为零，也会返回无穷大。|27447|entityMap^0|0|0|3|H|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The supplied function can indeed return infinity:

<pre class="lang-java prettyprint-override"><code>public class Test {
 public static double calculation(double a, double b)
 {
 if (a == b)
 {
 return 0;
 }
 else
 {
 return 2 / (a - b);
 }
 } 

 /**
 * @param args
 */
 public static void main(String[] args) {
 double d1 = Double.MIN_VALUE;
 double d2 = 2.0 * Double.MIN_VALUE;
 System.out.println("Result: " + calculation(d1, d2)); 
 }
}
</code></pre>

The output is <code>Result: -Infinity</code>.

When the result of the division is to big to be stored in a double, infinity is returned even if the denominator is non-zero.

blocks|key|4534988|text|基于@malarres的回复和@Taemyr的评论，这是我的小贡献：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4534989|public+double+calculation(double+a,+double+b)
{
+++++double+c+=+2+/+(a+-+b);

+++++//+Should+not+have+a+big+cost.
+++++if+(isnan(c)+%7C%7C+isinf(c))
+++++{
+++++++++return+0;+//+A+'whatever'+value.
+++++}
+++++else
+++++{
+++++++++return+c;
+++++}
}|code-block|syntax|javascript|4534990|我想说的是:要知道除法的结果是nan还是inf，最简单的方法就是实际执行除法。|4534991|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Based on @malarres response and @Taemyr comment, here is my little contribution:

<pre class="lang-java prettyprint-override"><code>public double calculation(double a, double b)
{
 double c = 2 / (a - b);

 // Should not have a big cost.
 if (isnan(c) || isinf(c))
 {
 return 0; // A 'whatever' value.
 }
 else
 {
 return c;
 }
}
</code></pre>

My point is to says: the easyest way to know if the result of the division is nan or inf is actualy to perform the division.

blocks|key|27603|text|除零是未定义的，因为从正数到无穷大的极限，从负数到负无穷大的极限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|27604|不确定这是C%2B%2B还是Java，因为没有语言标记。|27605|double+calculation(double+a,+double+b)
{
+++++if+(a+==+b)
+++++{
+++++++++return+nan("");+//+C%2B%2B

+++++++++return+Double.NaN;+//+Java
+++++}
+++++else
+++++{
+++++++++return+2+/+(a+-+b);
+++++}
}|code-block|syntax|javascript|27606|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Division by zero is undefined, since the limit from positive numbers tend to infinity, the limited from negative numbers tend to negative infinity.

Not sure if this is C++ or Java since there is no language tag.

<pre><code>double calculation(double a, double b)
{
 if (a == b)
 {
 return nan(""); // C++

 return Double.NaN; // Java
 }
 else
 {
 return 2 / (a - b);
 }
}
</code></pre>

blocks|key|27651|text|核心问题是，当你有“太多”小数时，双精度数(也称为浮点数或数学语言中的实数)的计算机表示是错误的，例如，当你处理不能写成数值(pi或1/3的结果)的双精度数时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|27652|所以a==b不能用a和b的任何双精度值来做，当a=0.333和b=1/3时，你如何处理a==b呢？根据你的操作系统、FPU、数字、语言和0后3的计数，你会得到真或假。|27653|无论如何，如果你在计算机上做“双值计算”，你必须处理精度，所以你必须做a==b，而不是做absolute_value(a-b)<epsilon，epsilon是相对于你当时在算法中建模的。你不能在所有的双重比较中都有一个epsilon值。|offset|length|style|CODE|27654|简而言之，当您输入a==b时，您得到了一个不能在计算机上翻译的数学表达式(对于任何浮点数)。|27655|附言:嗯，我在这里回答的一切或多或少都在别人的回复和评论中。|27656|entityMap^0|0|0|Z|4|18|R|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@$F|S|G|T|H|I]|$F|U|G|V|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|O|$]]

The core problem is that computer representation of a double (aka float, or real number in mathematical language) is wrong when you have "too much" decimal, for instance when you deal with double that can't be written as a numerical value (pi or the result of 1/3). 

So a==b can't be done with any double value of a and b, how to you deal with a==b when a=0.333 and b=1/3 ? Depending of your OS vs FPU vs number vs language versus count of 3 after 0, you will have true or false. 

Anyway if you do "double value calculation" on a computer, you have to deal with accuracy, so instead of doing <code>a==b</code>, you have to do <code>absolute_value(a-b)&lt;epsilon</code>, and epsilon is relative to what you are modeling at that time in your algorithm. You can't have an epsilon value for all of your double comparison.

In brief, when you type a==b, you have a mathemical expression that can't be translated on a computer (for any floating point number).

PS: hum, everything I answer here is yet more or less in others responses and comments.

Is it possible to get division by 0 (or infinity) in the following example? 

<pre class="lang-java prettyprint-override"><code>public double calculation(double a, double b)
{
 if (a == b)
 {
 return 0;
 }
 else
 {
 return 2 / (a - b);
 }
}
</code></pre>

In normal cases it will not, of course. But what if <code>a</code> and <code>b</code> are very close, can <code>(a-b)</code> result in being <code>0</code> due to precision of the calculation?

Note that this question is for Java, but I think it will apply to most programming languages.

Is it possible to get 0 by subtracting two unequal floating point numbers?

Java

在下面的例子中，是否可以除以0(或无穷大)？public double calculation(double a, double b){     if (a == b)     {         return 0;     }     else     {         return 2 / (a - b);   ...

问是否可以通过减去两个不相等的浮点数得到0？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否可以通过减去两个不相等的浮点数得到0？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否可以通过减去两个不相等的浮点数得到0？
EN