13

If you reflect over WindowsBase.dll > MS.Internal.DoubleUtil.AreClose(...) you'll get the following code:

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

I'm trying to understand two different things:

  1. Where did they come up with the formula for num2? I guess I just don't understand the significance of first adding the value of 10.0 and secondly multiplying all the results by this the number 2.2204460492503131E-16. Anyone know why this is the formula used?

  2. What is the point of the return statement there? It seems that by default if num2 greater than num than the negated value of num2 should be less than num. Maybe I'm missing something here, but it seems redundant. To me it's like checking if 5 is larger than 3 and if -5 is less than 3 (as an example).

Bradley Grainger
  • 27,458
  • 4
  • 91
  • 108
myermian
  • 31,823
  • 24
  • 123
  • 215

4 Answers4

13

  1. This appears to be a "tolerance" value that's based on the magnitude of the numbers being compared. Note that due to how floating point numbers are represented, the smallest representable difference between numbers with an exponent of 0 is 2-53 or approximately 1.11022 × 10-16. (See unit in the last place and floating point on Wikipedia.) The constant here is exactly two times that value, so it allows for small rounding errors that have accumulated during computations.

  2. If you reorder the parameters in the conditionals, and then rename num2 to tolerance and num to diff, it should become clear.

Viz.:

return ((-num2 < num) && (num2 > num));
return ((num > -num2) && (num < num2));
return ((diff > -tolerance) && (diff < tolerance));
Bradley Grainger
  • 27,458
  • 4
  • 91
  • 108
  • It still seems a bit redundant to check for diff being greater than the negated tolerance and if it's less than the tolerance. I can't fathom a situation where one part of that return value evaluates to true, while the other evaluates to false. – myermian Apr 22 '11 at 19:29
  • @myermian The difference between the two values can be negative (because the absolute value is not taken); in fact, it could be a very large negative number. Say the tolerance works out to be 0.01, and the delta between the two values is -50.0. `-50.0 < 0.01` is true, but clearly the two values are not close; you also need to check if `-50.0 > -0.01` (which is false). – Bradley Grainger Apr 22 '11 at 22:08
4

The comments should help understanding this method :)

/// <summary>
/// AreClose - Returns whether or not two doubles are "close".  That is, whether or 
/// not they are within epsilon of each other.  Note that this epsilon is proportional
/// to the numbers themselves to that AreClose survives scalar multiplication.
/// There are plenty of ways for this to return false even for numbers which
/// are theoretically identical, so no code calling this should fail to work if this 
/// returns false.  This is important enough to repeat:
/// NB: NO CODE CALLING THIS FUNCTION SHOULD DEPEND ON ACCURATE RESULTS - this should be
/// used for optimizations *only*.
/// </summary>
/// <returns>
/// bool - the result of the AreClose comparision.
/// </returns>
/// <param name="value1"> The first double to compare. </param>
/// <param name="value2"> The second double to compare. </param>
public static bool AreClose(double value1, double value2)
{
    // in case they are Infinities (then epsilon check does not work)
    if (value1 == value2)
    {
        return true;
    }

    // This computes (|value1-value2| / (|value1| + |value2| + 10.0)) &lt; DBL_EPSILON
    double eps = (Math.Abs(value1) + Math.Abs(value2) + 10.0) * DBL_EPSILON;
    double delta = value1 - value2;
    return (-eps < delta) && (eps > delta);
}

Update

And here the "mystic" value DBL_EPSILON 

    // Const values come from sdk\inc\crt\float.h
    internal const double DBL_EPSILON = 2.2204460492503131e-016; /* smallest such that 1.0+DBL_EPSILON != 1.0 */

src

Bradley Grainger
  • 27,458
  • 4
  • 91
  • 108
Andreas
  • 21,535
  • 7
  • 47
  • 56
  • What tool are you using to get the actual comments? Red Gate's .NET Reflector (old version - non-pro) seems to not get me the comments. – myermian Apr 22 '11 at 19:21
  • @myermian: I've used google for a quick search on codeplex (see the src-link at the bottom of my answer) – Andreas Apr 22 '11 at 19:29
  • Also, I wonder why this wasn't made into an extension method and exposed by Microsoft. It seems to be a useful function. – myermian Apr 22 '11 at 19:30
  • Ah, this is the source code for the WPF Toolkit, which probably has the same commenting that it does for the .NET 4 dll. I always wished there was a way to actually see .NET 4's commenting and not just the code being reflected over. – myermian Apr 22 '11 at 19:32
2

Searching on google for that number lead me to this page http://en.m.wikipedia.org/wiki/Machine_epsilon

In graphics, calculating geometry can result in little two points which may be very close from pixel point of view. Since floating point numbers may give little different result due to rounding done at bitwise calculation. So this method checks if number is close to another number within range of machine epsilon.

Akash Kava
  • 39,066
  • 20
  • 121
  • 167
0

I don't know why but the closer are the numbers to 0 the difference must be smaller to pass the check.

And for small numbers the return makes sense, take values 0 and 1 for example. Without the first part it would pass but 0 and 1 are not close enough :)

Marino Šimić
  • 7,318
  • 1
  • 31
  • 61