blocks|key|542383|text|检查这个问题的答案：检查浮点值是否安全，是否等于0？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|542384|真的，检查一下“在.的容忍范围内”|542385|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/485175/c-net-is-it-safe-to-check-floating-point-values-for-equality-to-0^0|A|G|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Check the answers to this question: <a href="https://stackoverflow.com/questions/485175/c-net-is-it-safe-to-check-floating-point-values-for-equality-to-0">Is it safe to check floating point values for equality to 0?</a>

Really, just check for "within tolerance of..."

blocks|key|805506|text|计算机上的浮点算法不是精确科学:)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|805507|如果您想要精确到一个预定义的小数小数，使用十进制代替双或接受一个小间隔。|805508|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Floating point arithmetic on computers are not Exact Science :). 

If you want exact precision to a predefined number of decimals use Decimal instead of double or accept a minor interval.

blocks|key|805552|text|浮动和双倍不能准确地存储所有数字。这是IEEE浮点系统的一个限制。为了获得可靠的精度，您需要使用一个更高级的数学库。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|805553|如果你不需要精度超过某一点，那么小数点也许会更适合你。它的精度比双倍高。|805554|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

floats and doubles cannot accurately store all numbers. This is a limitation with the IEEE floating point system. In order to have faithful precision you need to use a more advanced math library.

If you don't need precision past a certain point, then perhaps decimal will work better for you. It has a higher precision than double.

blocks|key|542621|text|如果省略所有的F后缀(即-12.1而不是-12.1F)，您将得到更多几位数的相等。您的常量(特别是期望值)现在由于F而浮动。如果你是故意这么做的，那么请解释一下。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|542622|但对于其他的答案，我同意其他关于比较双值或浮动值是否相等的答案，这是不可靠的。|542623|entityMap^0|C|5|K|6|1L|1|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

If you omit all the F postfixes (ie <code>-12.1</code> instead of <code>-12.1F</code>) you will get equality to a few digits more. Your constants (and especially the expected values) are now floats because of the <code>F</code>. If you are doing that on purpose then please explain.

But for the rest i concur with the other answers on comparing double or float values for equality, it's just not reliable.

blocks|key|805613|text|问题|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|805614|例如，非可表示性0.1和0.01+(二进制)意味着试图平方0.1的结果既不是0.01，也不是最接近它的可表示数。|blockquote|805615|只使用浮点，如果你想要机器的解释(二进制)的数字系统。你不能代表10美分。|805616|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Floating_point#Accuracy_problems^0|0|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|W|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<a href="http://en.wikipedia.org/wiki/Floating_point#Accuracy_problems" rel="noreferrer">http://en.wikipedia.org/wiki/Floating_point#Accuracy_problems</a>

<blockquote>
 For example, the non-representability of 0.1 and 0.01 (in binary) means that the result of attempting to square 0.1 is neither 0.01 nor the representable number closest to it.
</blockquote>

Only use floating point if you want a machine's interpretation (binary) of number systems. You can't represent 10 cents.

blocks|key|542712|text|如果您想要精确，请使用System.Decimal。如果需要速度，请使用System.Double+(或System.Float)。浮点数不是“无限精度”数字，因此断言相等必须包括公差。只要你的数字有一个合理数量的重要数字，这是可以的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|542713|如果你想对非常大和非常小的数字做数学，不要使用浮点数或双倍。|unordered-list-item|542714|如果您需要无限的精度，不要使用浮动或双倍。|542715|如果您要聚合大量的值，不要使用float或double+(错误会使它们复合)。|542716|如果您需要速度和大小，使用浮动或双倍。|542717|关于精确性如何影响数学运算结果的详细分析，请参见这的答案(也是我的答案)。|offset|length|542718|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/803225/when-should-i-use-double-instead-of-decimal/803260#803260^0|0|0|0|0|0|O|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|Y|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|10|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|11|8|@]|9|@$M|12|N|13|1|14]]|A|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

If you want precision, use System.Decimal. If you want speed, use System.Double (or System.Float). Floating point numbers are not "infinite precision" numbers, and therefore asserting equality must include a tolerance. As long as your numbers have a reasonable number of significant digits, this is ok.

<ul>
<li>If you're looking to do math on very large AND very small numbers, don't use float or double.</li>
<li>If you need infinite precision, don't use float or double.</li>
<li>If you are aggregating a very large number of values, don't use float or double (the errors will compound themselves).</li>
<li>If you need speed and size, use float or double.</li>
</ul>

See <a href="https://stackoverflow.com/questions/803225/when-should-i-use-double-instead-of-decimal/803260#803260">this</a> answer (also by me) for a detailed analysis of how precision affects the outcome of your mathematical operations.

blocks|key|542764|text|对于类似的问题，我最终使用了以下实现，它似乎成功了我的大部分测试用例(最高5位精度)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|542765|public+static+double+roundValue(double+rawValue,+double+valueTick)
{
++++if+(valueTick+<=+0.0)+return+0.0;

++++Decimal+val+=+new+Decimal(rawValue);
++++Decimal+step+=+new+Decimal(valueTick);
++++Decimal+modulo+=+Decimal.Round(Decimal.Divide(val,step));

++++return+Decimal.ToDouble(Decimal.Multiply(modulo,+step));
}|code-block|syntax|javascript|542766|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For the similar issue, I end up using the following implementation which seems to success most of my test case (up to 5 digit precision):

<pre><code>public static double roundValue(double rawValue, double valueTick)
{
 if (valueTick &lt;= 0.0) return 0.0;

 Decimal val = new Decimal(rawValue);
 Decimal step = new Decimal(valueTick);
 Decimal modulo = Decimal.Round(Decimal.Divide(val,step));

 return Decimal.ToDouble(Decimal.Multiply(modulo, step));
}
</code></pre>

blocks|key|2072697|text|实际上，我希望他们没有为浮点数和双行实现==操作符。询问一个双值或浮点数是否等于任何其他值几乎都是错误的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2072698|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I actually sort of wish they hadn't implemented the == operator for floats and doubles. It's almost always the wrong thing to do to ever ask if a double or a float is equal to any other value.

blocks|key|2072811|text|有时，结果比您所期望的更精确:FP+754。这是因为HW在计算中使用了更多的位。见C#规范和这篇文章|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2072812|Java有strictfp关键字，C%2B%2B有编译器开关。我想念.NET中的那个选项|2072813|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/aa691146%2528VS.71%2529.aspx|1|http://blogs.msdn.com/davidnotario/archive/2005/08/08/449092.aspx^0|15|4|0|1A|4|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

Sometimes the result is more precise than you would expect from strict:FP IEEE 754.
That's because HW uses more bits for the computation.
See <a href="http://msdn.microsoft.com/en-us/library/aa691146%28VS.71%29.aspx" rel="nofollow noreferrer">C# specification</a> and <a href="http://blogs.msdn.com/davidnotario/archive/2005/08/08/449092.aspx" rel="nofollow noreferrer">this article</a>

Java has strictfp keyword and C++ have compiler switches. I miss that option in .NET

I have a simple C# function:

<pre><code>public static double Floor(double value, double step)
{
 return Math.Floor(value / step) * step;
}
</code></pre>

That calculates the higher number, lower than or equal to "value", that is multiple of "step". But it lacks precision, as seen in the following tests:

<pre><code>[TestMethod()]
public void FloorTest()
{
 int decimals = 6;
 double value = 5F;
 double step = 2F;
 double expected = 4F;
 double actual = Class.Floor(value, step);
 Assert.AreEqual(expected, actual);
 value = -11.5F;
 step = 1.1F;
 expected = -12.1F;
 actual = Class.Floor(value, step);
 Assert.AreEqual(Math.Round(expected, decimals),Math.Round(actual, decimals));
 Assert.AreEqual(expected, actual);
}
</code></pre>

The first and second asserts are ok, but the third fails, because the result is only equal until the 6th decimal place. Why is that? Is there any way to correct this?

Update If I debug the test I see that the values are equal until the 8th decimal place instead of the 6th, maybe because Math.Round introduces some imprecision.

Note In my test code I wrote the "F" suffix (explicit float constant) where I meant "D" (double), so if I change that I can have more precision.

Double precision problems on .NET

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个简单的C#函数：public static double Floor(double value, double step){    return Math.Floor(value / step) * step;}它计算低于或等于“值”的较高数字，即“步骤”的倍数。但它缺乏精确性，如以下测试所示：[TestMet...

问.NET上的双精度问题
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET上的双精度问题EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET上的双精度问题
EN