相关疑难解决方法(0)

http://msdn.microsoft.com/en-us/library/system.double.epsilon.aspx

如果创建一个自定义算法来确定是否可以将两个浮点数视为相等,则必须使用大于Epsilon常量的值来确定两个值相等的可接受的绝对差值.(通常,差异幅度比Epsilon大很多倍.)

那么这不是真正可以用于比较的ε吗？我真的不明白MSDN的措辞.

它可以在这里的示例中用作epsilon吗？- 浮动和双重比较最有效的方法是什么？

最后这看起来非常重要,所以我想确保我有一个可靠的实现平等,大于,小于,小于或等于,大于或等于.

_{这是测试浮点值相等性的后续行动:"精度"常量是否有标准名称？.对于平等,
有一个非常相似的问题Double.Epsilon,大于,小于,小于或等于,大于或等于.}

众所周知,对两个浮点值x和y的相等测试应该看起来更像这样(而不是简单的=):

abs(x - y)< epsilon   ,其中epsilon是一个非常小的值.

如何为epsilon选择一个值？

显然最好选择epsilon尽可能小的值,以获得相等性检查的最高精度.

例如,.NET框架提供一个常量System.Double.Epsilon(= 4.94066×10 ^-324),表示System.Double大于零的最小正值.

但是,事实证明这个特定值不能可靠地用作epsilon,因为:

0 + System.Double.Epsilon≠0

1 + System.Double.Epsilon= 1(!)

也就是说,如果我理解正确,因为该常数小于机器epsilon.

→这是对的吗？

→这是否也意味着我可以可靠地使用epsilon:= machine epsilon进行相等测试？

_{删除了这两个问题,因为它们已经与上面提到的第二个SO问题得到了充分的回答.}

链接到维基百科的文章说,对于64位浮点数(即double许多语言中的类型),机器epsilon等于:

2 ^-53,或约.0.000000000000000111(小数点后15个零的数字)

→是否遵循这一点,所有64位浮点值保证精确到14(如果不是15)数字？

我正在编写一个扩展方法,使用一组小数点(有效数字)来比较两个浮点数,以确定它们是否相等而不是容差或百分比差异.通过关于浮点数比较的其他问题,我看到了复杂的实现.我是否过度简化或是否有效？

/// <summary>
/// Determines if the float value is equal to (==) the float parameter according to the defined precision.
/// </summary>
/// <param name="float1">The float1.</param>
/// <param name="float2">The float2.</param>
/// <param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
/// <returns></returns>
public static bool AlmostEquals(this float float1, float float2, int precision = 2)
{
    return (Math.Round(float1 - float2, precision) == 0);
}

注意:我正在寻找小数位的比较,而不是容差.我不希望1,000,000等于1,000,001.

我想比较 c# 中的两个小数，并有一定的误差。任何人都可以指出以下代码的问题。请注意，我对小数点后 6 位感兴趣，之后我可以忽略这些值。

var valOne = decimal.Round(valueOne, 6);
var valTwo = decimal.Round(valueTwo, 6);
var difference = Math.Abs(valOne - valTwo);
if (difference > 0.0000001m) {
   Console.WriteLine("Values are different");
}
else {
    Console.WriteLine("Values are equal");
}

或者，还有更好的方法。

我有一个floats 列表,并想检查它是否已包含该List.Contains()方法的特定值.我知道,对于float相等测试,你经常不能使用==类似的东西myFloat - value < 0.001.

我的问题是,该Contains方法是否解释了这一点,或者我是否需要使用一种方法来解决float精度错误,以便测试浮点数是否在列表中？

最小的生殖实例

在推动人们投票结束这个问题之前，请您检查一下最小的可复制示例吗？

这个问题已经被问了一千遍了，但是这次确实没有任何意义。

我收到以下异常消息：

System.ArgumentException
  HResult=0x80070057
  Message=Unable to sort because the IComparer.Compare() method returns inconsistent results. Either a value does not compare equal to itself, or one value repeatedly compared to another value yields different results. IComparer: 'Minotaur.GeneticAlgorithms.LexicographicalFitnessComparer'.
  Source=System.Private.CoreLib
  StackTrace:
   at System.Collections.Generic.IntrospectiveSortUtilities.ThrowOrIgnoreBadComparer(Object comparer)
   at System.Collections.Generic.ArraySortHelper`2.Sort(TKey[] keys, TValue[] values, Int32 index, Int32 length, IComparer`1 comparer)
   at System.Array.Sort[TKey,TValue](TKey[] keys, TValue[] items, IComparer`1 comparer)
   at Minotaur.FitnessReportMaker.MakeReport(Array`1 fitnesses) in C:\Source\minotaur\Minotaur\Minotaur\FitnessReportMaker.cs:line 18
   at Minotaur.Theseus.EvolutionEngine.Run(IEnumerable`1 initialPopulation) in C:\Source\minotaur\Minotaur\Minotaur\Theseus\EvolutionEngine.cs:line 63
   at Minotaur.Program.Run(ProgramSettings settings) in C:\Source\minotaur\Minotaur\Minotaur\Program.cs:line 148
   at …

刚开始学习C#.我计划将它用于繁重的数学模拟,包括数值求解.问题是我在添加和减去double时以及比较时都会出现精度损失.代码及其返回的内容(在评论中)如下:

namespace ex3
{
    class Program
    {
        static void Main(string[] args)
        {

            double x = 1e-20, foo = 4.0;

            Console.WriteLine((x + foo)); // prints 4
            Console.WriteLine((x - foo)); // prints -4
            Console.WriteLine((x + foo)==foo); // prints True BUT THIS IS FALSE!!!
        }
    }
}

非常感谢任何帮助和澄清!

令我困惑的是(x + foo)==foo回报True.

我想将浮点值转换为字符串.

以下是我用于转换的代码.

static void Main(string[] args)
        {
            string s =string.Format("{0:G}", value);                
            Console.Write(s);
            Console.ReadLine();
        }

它输出为 2.5

但我的问题是我想获得价值,2.50因为我想在我的项目中稍后将其与原始值进行比较.

如果有办法,请建议我吗？

我刚刚注意到以下代码返回true：

Mathf.Approximately(0.0f, float.Epsilon); // true

我已阅读Mathf.aboutly文档，其中指出：

roximately（）比较两个浮点数，如果两个浮点数彼此之间的距离较小（Epsilon），则返回true。

而Mathf.Epsilon文件指出：

• anyValue + Epsilon = anyValue
• anyValue-Epsilon = anyValue
• 0 + Epsilon = Epsilon
• 0-Epsilon = -Epsilon

结果，我运行了以下代码，期望它是false，但它也会返回true。

Mathf.Approximately(0.0f, 2.0f * float.Epsilon); // true

顺便说说：

Mathf.Approximately(0.0f, 2.0f * float.Epsilon); // true
Mathf.Approximately(0.0f, 3.0f * float.Epsilon); // true
Mathf.Approximately(0.0f, 4.0f * float.Epsilon); // true
Mathf.Approximately(0.0f, 5.0f * float.Epsilon); // true
Mathf.Approximately(0.0f, 6.0f * float.Epsilon); // true
Mathf.Approximately(0.0f, 7.0f * float.Epsilon); // true

Mathf.Approximately(0.0f, 8.0f * float.Epsilon); …

我正在开发一个程序来进行一些浮点计算,我在.NET中偶然发现了一个有趣的舍入问题,根据哪个表达式:

0.1 + 0.2 == 0.3

评估为false,因为:

0.1 + 0.2

评估0.30000000000000004,而不是0.3.这严重影响了单元测试.

我确实理解为什么会发生这种情况,但我有兴趣知道的是:在处理双重算术时我应该遵循哪些最佳实践以避免在可能的情况下出现这些问题？

编辑:使用decimal类型没有帮助

摘要:感谢所有评论.不幸的是,有些人认为这个问题是如何使0.1 + 0.2等于0.3,这不是我要求的.我接受浮点运算可以返回带有变化的值.我在问什么共同策略是最佳实践,以便这种变化不会引起问题.我认为这个问题已经准备好了.

我知道，为了检查两个双精度数之间的相等性，您必须使用数字之间的绝对差，并将此差值与小于 1 且大于零的数字进行比较。这是最简单的方法，因为还有更复杂的方法。我的一位同事说，例如，如果您使用 Math.Round 表示 2 个小数位，则可以使用精确相等，而无需使用上述方法。例如，如果你有号码double x;和号码，double y;你可以写

double x1=Math.Round(x,2);
double y1=Math.Round(y,2);
if(x1 == y1)
 {
    //do something
 }

我认为这不是真的。但你能告诉我为什么这是对还是错？