C#的浮点比较函数

Question

有人可以在C#中指向(或显示)一些好的通用浮点比较函数来比较浮点值吗？我想实现的功能IsEqual,IsGreater一个IsLess.我也只关心双打不漂浮.

Answer 1

编写一个有用的通用浮点IsEqual是非常非常困难的,如果不是完全不可能的话.您当前的代码将严重失败a==0.该方法应该如何处理这种情况实际上是一个定义的问题,并且可以说代码最适合特定的域用例.

对于这种事情,你真的需要一个好的测试套件.这就是我为浮点指南做的,这就是我最终提出的(Java代码,应该很容易翻译):

public static boolean nearlyEqual(float a, float b, float epsilon) {
    final float absA = Math.abs(a);
    final float absB = Math.abs(b);
    final float diff = Math.abs(a - b);

    if (a == b) { // shortcut, handles infinities
        return true;
    } else if (a == 0 || b == 0 || absA + absB < Float.MIN_NORMAL) {
        // a or b is zero or both are extremely close to it
        // relative error is less meaningful here
        return diff < (epsilon * Float.MIN_NORMAL);
    } else { // use relative error
        return diff / (absA + absB) < epsilon;
    }
}

您还可以在网站上找到测试套件.

附录: c#中的相同代码用于双打(在问题中提到)

public static bool NearlyEqual(double a, double b, double epsilon)
{
    const double MinNormal = 2.2250738585072014E-308d;
    double absA = Math.Abs(a);
    double absB = Math.Abs(b);
    double diff = Math.Abs(a - b);

    if (a.Equals(b))
    { // shortcut, handles infinities
        return true;
    } 
    else if (a == 0 || b == 0 || absA + absB < MinNormal) 
    {
        // a or b is zero or both are extremely close to it
        // relative error is less meaningful here
        return diff < (epsilon * MinNormal);
    }
    else
    { // use relative error
        return diff / (absA + absB) < epsilon;
    }
}

Answer 2

从Bruce Dawson关于比较浮点数的论文中,您还可以将浮点数作为整数进行比较.接近度由最低有效位确定.

public static bool AlmostEqual2sComplement( float a, float b, int maxDeltaBits ) 
{
    int aInt = BitConverter.ToInt32( BitConverter.GetBytes( a ), 0 );
    if ( aInt <  0 )
        aInt = Int32.MinValue - aInt;  // Int32.MinValue = 0x80000000

    int bInt = BitConverter.ToInt32( BitConverter.GetBytes( b ), 0 );
    if ( bInt < 0 )
        bInt = Int32.MinValue - bInt;

    int intDiff = Math.Abs( aInt - bInt );
    return intDiff <= ( 1 << maxDeltaBits );
}

编辑:BitConverter相对较慢.如果您愿意使用不安全的代码,那么这是一个非常快的版本:

    public static unsafe int FloatToInt32Bits( float f )
    {
        return *( (int*)&f );
    }

    public static bool AlmostEqual2sComplement( float a, float b, int maxDeltaBits )
    {
        int aInt = FloatToInt32Bits( a );
        if ( aInt < 0 )
            aInt = Int32.MinValue - aInt;

        int bInt = FloatToInt32Bits( b );
        if ( bInt < 0 )
            bInt = Int32.MinValue - bInt;

        int intDiff = Math.Abs( aInt - bInt );
        return intDiff <= ( 1 << maxDeltaBits );
    }

Answer 3

继Andrew Wang的回答:如果BitConverter方法太慢但你不能在你的项目中使用不安全的代码,这个结构比BitConverter快6倍:

[StructLayout(LayoutKind.Explicit)]
public struct FloatToIntSafeBitConverter
{
    public static int Convert(float value)
    {
        return new FloatToIntSafeBitConverter(value).IntValue;
    }

    public FloatToIntSafeBitConverter(float floatValue): this()
    {
        FloatValue = floatValue;
    }

    [FieldOffset(0)]
    public readonly int IntValue;

    [FieldOffset(0)]
    public readonly float FloatValue;
}

(顺便说一句,我尝试使用已接受的解决方案,但它(至少我的转换)失败了一些在答案中也提到的单元测试.例如assertTrue(nearlyEqual(Float.MIN_VALUE, -Float.MIN_VALUE));)

Answer 4

对于来这里观看UNITY 3D 特定内容的人

有Mathf.Approximately这么写

if(Mathf.Approximately(a, b))

基本上等于写作

if(Mathf.Abs(a - b) <= Mathf.Epsilon)

在哪里Mathf.Epsilon

浮点数可以具有的不为零的最小值。

在幕后这进一步意味着（来自源代码）

  // A tiny floating point value (RO).
  public static readonly float Epsilon =
      UnityEngineInternal.MathfInternal.IsFlushToZeroEnabled ? UnityEngineInternal.MathfInternal.FloatMinNormal
      : UnityEngineInternal.MathfInternal.FloatMinDenormal;
 
...
 
  [Unity.IL2CPP.CompilerServices.Il2CppEagerStaticClassConstruction]
public partial struct MathfInternal
{
    public static volatile float FloatMinNormal = 1.17549435E-38f;
    public static volatile float FloatMinDenormal = Single.Epsilon;

    public static bool IsFlushToZeroEnabled = (FloatMinDenormal == 0);
}

Answer 5

继续迈克尔提供的答案和测试,在将原始Java代码翻译成C#时要记住的一件重要事情是Java和C#以不同的方式定义它们的常量.例如,C#缺少Java的MIN_NORMAL,MinValue的定义差别很大.

Java将MIN_VALUE定义为可能的最小正值,而C#将其定义为总体上可能的最小可表示值.C#中的等价值是Epsilon.

缺少MIN_NORMAL对于原始算法的直接转换是有问题的 - 没有它,对于接近零的小值,事情开始分解.Java的MIN_NORMAL遵循最小可能数的IEEE规范,而没有有效数字的前导位为零,考虑到这一点,我们可以为单个和双精度定义我们自己的法线(dbc在原始答案的注释中提到).

以下单个C#代码通过了"浮点指南"中给出的所有测试,并且双版本通过了所有测试,并在测试用例中进行了少量修改,以说明提高的精度.

public static bool ApproximatelyEqualEpsilon(float a, float b, float epsilon)
{
    const float floatNormal = (1 << 23) * float.Epsilon;
    float absA = Math.Abs(a);
    float absB = Math.Abs(b);
    float diff = Math.Abs(a - b);

    if (a == b)
    {
        // Shortcut, handles infinities
        return true;
    }

    if (a == 0.0f || b == 0.0f || diff < floatNormal)
    {    
        // a or b is zero, or both are extremely close to it.
        // relative error is less meaningful here
        return diff < (epsilon * floatNormal);
    }

    // use relative error
    return diff / Math.Min((absA + absB), float.MaxValue) < epsilon;
}

除了类型更改之外,双精度版本是相同的,而正常的定义是这样的.

const double doubleNormal = (1L << 52) * double.Epsilon;

Answer 6

一些答案要小心......

1 - 您可以轻松地在内存中用双精度表示任何带有15个有效数字的数字.见维基百科.

2 - 问题来自浮点数的计算,你可能会失去一些精度.我的意思是在计算之后,像.1这样的数字可能变成.1000000000000001 ==>.进行某些计算时,结果可能会被截断,以便以双精度表示.截断会带来你可能得到的错误.

3 - 为了防止在比较双值时出现问题,人们会引入一个通常称为epsilon的误差范围.如果2个浮动数字仅具有上下文epsilon ha差异,则它们被视为等于.Epsilon永远不会加倍.Epsilon.

4 - epsilon永远不会是double.epsilon.它总是比那更重要.许多人认为它是双重的.Epsilon但他们确实是错的.要得到一个很好的答案,请参阅:汉斯帕斯特回答.epsilon基于您的上下文,它取决于您在计算过程中达到的最大数量以及您正在进行的计算次数(截断误差累积).Epsilon是您在15个数字中表示的最小数字.

5 - 这是我使用的代码.小心我只使用我的epsilon进行少量计算.否则我将我的epsilon乘以10或100.

6 - 正如SvenL所指出的那样,我的epsilon可能不够大.我建议阅读SvenL评论.另外,或许"十进制"可以为你的案件做好工作？

// Decompiled with JetBrains decompiler
// Type: MS.Internal.DoubleUtil
// Assembly: WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35
// MVID: 33C590FB-77D1-4FFD-B11B-3D104CA038E5
// Assembly location: C:\Windows\Microsoft.NET\assembly\GAC_MSIL\WindowsBase\v4.0_4.0.0.0__31bf3856ad364e35\WindowsBase.dll

using MS.Internal.WindowsBase;
using System;
using System.Runtime.InteropServices;
using System.Windows;

namespace MS.Internal
{
  [FriendAccessAllowed]
  internal static class DoubleUtil
  {
    internal const double DBL_EPSILON = 2.22044604925031E-16;
    internal const float FLT_MIN = 1.175494E-38f;

    public static bool AreClose(double value1, double value2)
    {
      if (value1 == value2)
        return true;
      double num1 = (Math.Abs(value1) + Math.Abs(value2) + 10.0) * 2.22044604925031E-16;
      double num2 = value1 - value2;
      if (-num1 < num2)
        return num1 > num2;
      return false;
    }

    public static bool LessThan(double value1, double value2)
    {
      if (value1 < value2)
        return !DoubleUtil.AreClose(value1, value2);
      return false;
    }

    public static bool GreaterThan(double value1, double value2)
    {
      if (value1 > value2)
        return !DoubleUtil.AreClose(value1, value2);
      return false;
    }

    public static bool LessThanOrClose(double value1, double value2)
    {
      if (value1 >= value2)
        return DoubleUtil.AreClose(value1, value2);
      return true;
    }

    public static bool GreaterThanOrClose(double value1, double value2)
    {
      if (value1 <= value2)
        return DoubleUtil.AreClose(value1, value2);
      return true;
    }

    public static bool IsOne(double value)
    {
      return Math.Abs(value - 1.0) < 2.22044604925031E-15;
    }

    public static bool IsZero(double value)
    {
      return Math.Abs(value) < 2.22044604925031E-15;
    }

    public static bool AreClose(Point point1, Point point2)
    {
      if (DoubleUtil.AreClose(point1.X, point2.X))
        return DoubleUtil.AreClose(point1.Y, point2.Y);
      return false;
    }

    public static bool AreClose(Size size1, Size size2)
    {
      if (DoubleUtil.AreClose(size1.Width, size2.Width))
        return DoubleUtil.AreClose(size1.Height, size2.Height);
      return false;
    }

    public static bool AreClose(Vector vector1, Vector vector2)
    {
      if (DoubleUtil.AreClose(vector1.X, vector2.X))
        return DoubleUtil.AreClose(vector1.Y, vector2.Y);
      return false;
    }

    public static bool AreClose(Rect rect1, Rect rect2)
    {
      if (rect1.IsEmpty)
        return rect2.IsEmpty;
      if (!rect2.IsEmpty && DoubleUtil.AreClose(rect1.X, rect2.X) && (DoubleUtil.AreClose(rect1.Y, rect2.Y) && DoubleUtil.AreClose(rect1.Height, rect2.Height)))
        return DoubleUtil.AreClose(rect1.Width, rect2.Width);
      return false;
    }

    public static bool IsBetweenZeroAndOne(double val)
    {
      if (DoubleUtil.GreaterThanOrClose(val, 0.0))
        return DoubleUtil.LessThanOrClose(val, 1.0);
      return false;
    }

    public static int DoubleToInt(double val)
    {
      if (0.0 >= val)
        return (int) (val - 0.5);
      return (int) (val + 0.5);
    }

    public static bool RectHasNaN(Rect r)
    {
      return DoubleUtil.IsNaN(r.X) || DoubleUtil.IsNaN(r.Y) || (DoubleUtil.IsNaN(r.Height) || DoubleUtil.IsNaN(r.Width));
    }

    public static bool IsNaN(double value)
    {
      DoubleUtil.NanUnion nanUnion = new DoubleUtil.NanUnion();
      nanUnion.DoubleValue = value;
      ulong num1 = nanUnion.UintValue & 18442240474082181120UL;
      ulong num2 = nanUnion.UintValue & 4503599627370495UL;
      if (num1 == 9218868437227405312UL || num1 == 18442240474082181120UL)
        return num2 > 0UL;
      return false;
    }

    [StructLayout(LayoutKind.Explicit)]
    private struct NanUnion
    {
      [FieldOffset(0)]
      internal double DoubleValue;
      [FieldOffset(0)]
      internal ulong UintValue;
    }
  }
}

Answer 7

这是我使用可为空的双重扩展方法解决的方法。

    public static bool NearlyEquals(this double? value1, double? value2, double unimportantDifference = 0.0001)
    {
        if (value1 != value2)
        {
            if(value1 == null || value2 == null)
                return false;

            return Math.Abs(value1.Value - value2.Value) < unimportantDifference;
        }

        return true;
    }

...

        double? value1 = 100;
        value1.NearlyEquals(100.01); // will return false
        value1.NearlyEquals(100.000001); // will return true
        value1.NearlyEquals(100.01, 0.1); // will return true