Floating point comparison functions for C

Question

Can someone point towards  or show  some good general floating point comparison functions in C  for comparing floating point values  I want to implement functions for IsEqual  IsGreater an IsLess  I also only really care about doubles not floats

User · Answer

Continuing from the answers provided by Michael and testing, an important thing to keep in mind when translating the original Java code to C# is that Java and C# define their constants differently. C#, for instance, lacks Java's MIN_NORMAL, and the definitions for MinValue differ greatly.

Java defines MIN_VALUE to be the smallest possible positive value, while C# defines it as the smallest possible representable value overall. The equivalent value in C# is Epsilon.

The lack of MIN_NORMAL is problematic for direct translation of the original algorithm - without it, things start to break down for small values near zero. Java's MIN_NORMAL follows the IEEE specification of the smallest possible number without having the leading bit of the significand as zero, and with that in mind, we can define our own normals for both singles and doubles (which dbc mentioned in the comments to the original answer).

The following C# code for singles passes all of the tests given on The Floating Point Guide, and the double edition passes all of the tests with minor modifications in the test cases to account for the increased precision.

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;
}

The version for doubles is identical save for type changes and that the normal is defined like this instead.

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

User · Answer

Here s how I solved it  with nullable double extension method       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   lt  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

User · Answer

What about  b - delta  lt  a  amp  amp  a  lt  b   delta

User · Answer

I translated the sample from Michael Borgwardt  This is the result   public static bool NearlyEqual float a  float b  float epsilon       float absA   Math Abs  a       float absB   Math Abs  b       float diff   Math Abs  a - b        if  a    b            return true        else if  a    0    b    0    diff  lt  float Epsilon               a or b is zero or both are extremely close to it            relative error is less meaningful here         return diff  lt  epsilon        else      use relative error         return diff    absA   absB   lt  epsilon            Feel free to improve this answer

User · Answer

Writing a useful general-purpose floating point IsEqual is very  very hard  if not outright impossible  Your current code will fail badly for a  0  How the method should behave for such cases is really a matter of definition  and arguably the code would best be tailored for the specific domain use case   For this kind of thing  you really  really need a good test suite  That s how I did it for The Floating-Point Guide  this is what I came up with in the end  Java code  should be easy enough to translate    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  lt  Float MIN NORMAL               a or b is zero or both are extremely close to it            relative error is less meaningful here         return diff  lt   epsilon   Float MIN NORMAL         else      use relative error         return diff    absA   absB   lt  epsilon            You can also find the test suite on the site   Appendix  Same code in c  for doubles  as asked in questions   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  lt  MinNormal                    a or b is zero or both are extremely close to it            relative error is less meaningful here         return diff  lt   epsilon   MinNormal             else          use relative error         return diff    absA   absB   lt  epsilon

User · Answer

I think your second option is the best bet  Generally in floating-point comparison you often only care that one value is within a certain tolerance of another value  controlled by the selection of epsilon

User · Answer

Here is a much-expanded version of Simon Hewitt s class        lt summary gt      Safely converts a  lt see cref  float   gt  to an  lt see cref  int   gt  for floating-point comparisons       lt  summary gt   StructLayout LayoutKind Explicit   public struct FloatToInt   IEquatable lt FloatToInt gt   IEquatable lt float gt   IEquatable lt int gt   IComparable lt FloatToInt gt   IComparable lt float gt   IComparable lt int gt             lt summary gt          Initializes a new instance of the  lt see cref  FloatToInt   gt  class           lt  summary gt           lt param name  floatValue  gt The  lt see cref  float   gt  value to be converted to an  lt see cref  int   gt   lt  param gt      public FloatToInt float floatValue            this                 FloatValue   floatValue                  lt summary gt          Gets the floating-point value as an integer           lt  summary gt       FieldOffset 0       public readonly int IntValue            lt summary gt          Gets the floating-point value           lt  summary gt       FieldOffset 0       public readonly float FloatValue            lt summary gt          Indicates whether the current object is equal to another object of the same type           lt  summary gt           lt returns gt          true if the current object is equal to the  lt paramref name  other   gt  parameter  otherwise  false           lt  returns gt           lt param name  other  gt An object to compare with this object  lt  param gt      public bool Equals FloatToInt other                return other IntValue    IntValue                  lt summary gt          Indicates whether the current object is equal to another object of the same type           lt  summary gt           lt returns gt          true if the current object is equal to the  lt paramref name  other   gt  parameter  otherwise  false           lt  returns gt           lt param name  other  gt An object to compare with this object  lt  param gt      public bool Equals float other                return IntValue    new FloatToInt other  IntValue                  lt summary gt          Indicates whether the current object is equal to another object of the same type           lt  summary gt           lt returns gt          true if the current object is equal to the  lt paramref name  other   gt  parameter  otherwise  false           lt  returns gt           lt param name  other  gt An object to compare with this object  lt  param gt      public bool Equals int other                return IntValue    other                  lt summary gt          Compares the current object with another object of the same type           lt  summary gt           lt returns gt          A value that indicates the relative order of the objects being compared  The return value has the following meanings  Value Meaning Less than zero This object is less than the  lt paramref name  other   gt  parameter Zero This object is equal to  lt paramref name  other   gt   Greater than zero This object is greater than  lt paramref name  other   gt             lt  returns gt           lt param name  other  gt An object to compare with this object  lt  param gt      public int CompareTo FloatToInt other                return IntValue CompareTo other IntValue                   lt summary gt          Compares the current object with another object of the same type           lt  summary gt           lt returns gt          A value that indicates the relative order of the objects being compared  The return value has the following meanings  Value Meaning Less than zero This object is less than the  lt paramref name  other   gt  parameter Zero This object is equal to  lt paramref name  other   gt   Greater than zero This object is greater than  lt paramref name  other   gt             lt  returns gt           lt param name  other  gt An object to compare with this object  lt  param gt      public int CompareTo float other                return IntValue CompareTo new FloatToInt other  IntValue                   lt summary gt          Compares the current object with another object of the same type           lt  summary gt           lt returns gt          A value that indicates the relative order of the objects being compared  The return value has the following meanings  Value Meaning Less than zero This object is less than the  lt paramref name  other   gt  parameter Zero This object is equal to  lt paramref name  other   gt   Greater than zero This object is greater than  lt paramref name  other   gt             lt  returns gt           lt param name  other  gt An object to compare with this object  lt  param gt      public int CompareTo int other                return IntValue CompareTo other                   lt summary gt          Indicates whether this instance and a specified object are equal           lt  summary gt           lt returns gt          true if  lt paramref name  obj   gt  and this instance are the same type and represent the same value  otherwise  false           lt  returns gt           lt param name  obj  gt Another object to compare to   lt  param gt  lt filterpriority gt 2 lt  filterpriority gt      public override bool Equals object obj                if  ReferenceEquals null  obj                         return false                    if  obj GetType      typeof FloatToInt                         return false                    return Equals  FloatToInt obj                   lt summary gt          Returns the hash code for this instance           lt  summary gt           lt returns gt          A 32-bit signed integer that is the hash code for this instance           lt  returns gt           lt filterpriority gt 2 lt  filterpriority gt      public override int GetHashCode                 return IntValue                  lt summary gt          Implicitly converts from a  lt see cref  FloatToInt   gt  to an  lt see cref  int   gt            lt  summary gt           lt param name  value  gt A  lt see cref  FloatToInt   gt   lt  param gt           lt returns gt An integer representation of the floating-point value  lt  returns gt      public static implicit operator int FloatToInt value                return value IntValue                  lt summary gt          Implicitly converts from a  lt see cref  FloatToInt   gt  to a  lt see cref  float   gt            lt  summary gt           lt param name  value  gt A  lt see cref  FloatToInt   gt   lt  param gt           lt returns gt The floating-point value  lt  returns gt      public static implicit operator float FloatToInt value                return value FloatValue                  lt summary gt          Determines if two  lt see cref  FloatToInt   gt  instances have the same integer representation           lt  summary gt           lt param name  left  gt A  lt see cref  FloatToInt   gt   lt  param gt           lt param name  right  gt A  lt see cref  FloatToInt   gt   lt  param gt           lt returns gt true if the two  lt see cref  FloatToInt   gt  have the same integer representation  otherwise  false  lt  returns gt      public static bool operator    FloatToInt left  FloatToInt right                return left IntValue    right IntValue                  lt summary gt          Determines if two  lt see cref  FloatToInt   gt  instances have different integer representations           lt  summary gt           lt param name  left  gt A  lt see cref  FloatToInt   gt   lt  param gt           lt param name  right  gt A  lt see cref  FloatToInt   gt   lt  param gt           lt returns gt true if the two  lt see cref  FloatToInt   gt  have different integer representations  otherwise  false  lt  returns gt      public static bool operator    FloatToInt left  FloatToInt right                return   left    right

User · Answer

Further to Andrew Wang s answer  if the BitConverter method is too slow but you cannot use unsafe code in your project  this struct is  6x quicker than BitConverter    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       Incidentally  I tried using the accepted solution but it  well my conversion at least  failed some of the unit tests also mentioned in the answer  e g  assertTrue nearlyEqual Float MIN VALUE  -Float MIN VALUE

User · Answer

Although the second option is more general  the first option is better when you have an absolute tolerance  and when you have to execute many of these comparisons  If this comparison is say for every pixel in an image  the multiplication in the second options might slow your execution to unacceptable levels of performance

User · Answer

Be careful with some answers        UPDATE 2019-0829  I also included Microsoft decompiled code which should be far better than mine    1 - You could easily represent any number with 15 significatives digits in memory with a double  See Wikipedia   2 - The problem come from calculation of floating numbers where you could loose some precision  I mean that a number like  1 could become something like  1000000000000001     after calculation  When you do some calculation  results could be truncated in order to be represented in a double  That truncation brings the error you could get   3 - To prevent the problem when comparing double values  people introduce an error margin often called epsilon  If 2 floating numbers only have a contextual epsilon as difference  then they are considered equals  double Epsilon is the smallest number between a double value and its neigbor  next or previous  value   4 - The difference betwen 2 double values could be more than double epsilon  The difference between the real double value and the one computed depends on how many calculation you have done and which ones  Many peoples think that it is always double Epsilon but they are really wrong  To have a great answer please see  Hans Passant answer  The epsilon is based on your context where it depends on the biggest number you reach during your calculation and on the number of calculation you are doing  truncation error accumulate    5 - This is the code that I use  Be careful that I use my epsilon only for few calculations  Otherwise I multiply my epsilon by 10 or 100   6 - As noted by SvenL  it is possible that my epsilon is not big enough  I suggest to read SvenL comment  Also  perhaps  decimal  could do the job for your case   Microsoft decompiled code      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  lt  num2          return num1  gt  num2        return false             public static bool LessThan double value1  double value2              if  value1  lt  value2          return  DoubleUtil AreClose value1  value2         return false             public static bool GreaterThan double value1  double value2              if  value1  gt  value2          return  DoubleUtil AreClose value1  value2         return false             public static bool LessThanOrClose double value1  double value2              if  value1  gt   value2          return DoubleUtil AreClose value1  value2         return true             public static bool GreaterThanOrClose double value1  double value2              if  value1  lt   value2          return DoubleUtil AreClose value1  value2         return true             public static bool IsOne double value              return Math Abs value - 1 0   lt  2 22044604925031E-15             public static bool IsZero double value              return Math Abs value   lt  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  amp  amp  DoubleUtil AreClose rect1 X  rect2 X   amp  amp   DoubleUtil AreClose rect1 Y  rect2 Y   amp  amp  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  gt   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  amp  18442240474082181120UL        ulong num2   nanUnion UintValue  amp  4503599627370495UL        if  num1    9218868437227405312UL    num1    18442240474082181120UL          return num2  gt  0UL        return false              StructLayout LayoutKind Explicit       private struct NanUnion              FieldOffset 0         internal double DoubleValue         FieldOffset 0         internal ulong UintValue                My code   public static class DoubleExtension                                                                                                Base on Hans Passant Answer on             https   stackoverflow com questions 2411392 double-epsilon-for-equality-greater-than-less-than-less-than-or-equal-to-gre               lt summary gt              Compare two double taking in account the double precision potential error              Take care  truncation errors accumulate on calculation  More you do  more you should increase the epsilon          public static bool AboutEquals this double value1  double value2                        double epsilon   Math Max Math Abs value1   Math Abs value2     1E-15              return Math Abs value1 - value2   lt   epsilon                                                                                                      Base on Hans Passant Answer on             https   stackoverflow com questions 2411392 double-epsilon-for-equality-greater-than-less-than-less-than-or-equal-to-gre               lt summary gt              Compare two double taking in account the double precision potential error              Take care  truncation errors accumulate on calculation  More you do  more you should increase the epsilon              You get really better performance when you can determine the contextual epsilon first               lt  summary gt               lt param name  value1  gt  lt  param gt               lt param name  value2  gt  lt  param gt               lt param name  precalculatedContextualEpsilon  gt  lt  param gt               lt returns gt  lt  returns gt          public static bool AboutEquals this double value1  double value2  double precalculatedContextualEpsilon                        return Math Abs value1 - value2   lt   precalculatedContextualEpsilon                                                                                                   public static double GetContextualEpsilon this double biggestPossibleContextualValue                        return biggestPossibleContextualValue   1E-15                                                                                                        lt summary gt              Mathlab equivalent              lt  summary gt               lt param name  dividend  gt  lt  param gt               lt param name  divisor  gt  lt  param gt               lt returns gt  lt  returns gt          public static double Mod this double dividend  double divisor                        return dividend - System Math Floor dividend   divisor    divisor

User · Answer

static class FloatUtil        static bool IsEqual float a  float b  float tolerance   0 001f          return Math Abs a - b   lt  tolerance             static bool IsGreater float a  float b          return a  gt  b             static bool IsLess float a  float b          return a  lt  b           The value of tolerance that is passed into IsEqual is something that the client could decide  IsEqual 1 002  1 001            -- gt    False IsEqual 1 002  1 001  0 01      -- gt    True

User · Answer

From Bruce Dawson s paper on comparing floats  you can also compare floats as integers   Closeness is determined by least significant bits   public static bool AlmostEqual2sComplement  float a  float b  int maxDeltaBits          int aInt   BitConverter ToInt32  BitConverter GetBytes  a    0        if   aInt  lt   0           aInt   Int32 MinValue - aInt      Int32 MinValue   0x80000000      int bInt   BitConverter ToInt32  BitConverter GetBytes  b    0        if   bInt  lt  0           bInt   Int32 MinValue - bInt       int intDiff   Math Abs  aInt - bInt        return intDiff  lt     1  lt  lt  maxDeltaBits        EDIT  BitConverter is relatively slow   If you re willing to use unsafe code  then here is a very fast version       public static unsafe int FloatToInt32Bits  float f                 return     int   amp f               public static bool AlmostEqual2sComplement  float a  float b  int maxDeltaBits                 int aInt   FloatToInt32Bits  a            if   aInt  lt  0               aInt   Int32 MinValue - aInt           int bInt   FloatToInt32Bits  b            if   bInt  lt  0               bInt   Int32 MinValue - bInt           int intDiff   Math Abs  aInt - bInt            return intDiff  lt     1  lt  lt  maxDeltaBits

[c#] Floating point comparison functions for C#

Examples related to c#

Examples related to .net

Examples related to floating-point