C# double precision problem

Question

Imagine that a - b < c (a, b, c are C# doubles). Is it guaranteed that a < b + c?

Thanks!

EDIT
Let's say that the arithmetical overflow doesn't occur unlike the following example:

double a = 1L << 53;
double b = 1;
double c = a;
Console.WriteLine(a - b < c); // Prints True
Console.WriteLine(a < b + c); // Prints False

Imagine that Math.Abs(a) < 1.0 && Math.Abs(b) < 1.0 && Math.Abs(c) < 1.0

• Fredrik Mörk: How is this related to C# or any specific data type (or even programming)? Looks like pure math to me.
• jgauffin: @Fredrik Mörk: No, it's all about precision.
• BeRecursive: @Fredrik Mörk: Because it has to do with the languages level of precision on non-integer arithmetic
• Fredrik Mörk: @jgauffin and @BeRecursive: of course! :)
• Tomas Vana: Actually the math is quite trivial and it has something to do with the datatype. Imagine things like 3.0 * (1.0/3.0) == 1.0 etc. Mathematically correct, in C# might not hold exactly depending on the datatype.

Answer 1

No. Suppose a = c, a very large number, and b is a very small number. It's possible that a - b has a representation less than a, but a + b is so close to a (and bigger) that it still ends up being most precisely representable as a.

Here's an example:

double a = 1L << 53;
double b = 1;
double c = a;
Console.WriteLine(a - b < c); // Prints True
Console.WriteLine(a < b + c); // Prints False

EDIT:

Here's another example, which matches your edited question:

double a = 1.0;
double b = 1.0 / (1L << 53);
double c = a;
Console.WriteLine(a - b < c); // Prints True
Console.WriteLine(a < b + c); // Prints False

In other words, when we subtract a very small number from 1, we get a result less than 1. When we add the same number to 1, we just get 1 back due to the limitations of double precision.

• Tomas Vana: or the other way around, I also have the feeling it's like that.
• Vilx-: It gets even weirder when a=c=double.MaxValue. Then both are false.
• levanovd: Great example, sure. But actually we deal with micro-numbers, not with values around double.MaxValue. Please read EDIT for more information.
• Jon Skeet: @levanovd: 1 << 53 is way smaller than double.MaxValue. There's no overflow going on here.
• Jon Skeet: @levanovd: I've provided another example which fits into your limits.

Answer 2

no not always:

 double a = double.MaxValue;
 double b = double.MaxValue;
 double c = 0.1;
 Console.WriteLine(a - b < c); // True
 Console.WriteLine(a < b + c); // False

Answer 3

This link speaks about floating-point arithmetic properties, and could be very interesting:

FLOATING-POINT FALLACIES

In particular, search for Properties of Relations