Question

given the following code:

long l = 1234567890123;
double d = (double) l;

is the following expression guaranteed to be true?

l == (long) d

I should think no, because as numbers get larger, the gaps between two doubles grow beyond 1 and therefore the conversion back yields a different long value. In case the conversion does not take the value that’s greater than the long value, this might also happen earlier.

Is there a definitive answer to that?

Answer 1

Nope, absolutely not. There are plenty of long values which aren’t exactly representable by double. In fact, that has to be the case, given that both types are represented in 64 bits, and there are obviously plenty of double values which aren’t representable in long (e.g. 0.5)

Simple example (Java and then C#):

// Java
class Test {
    public static void main(String[] args) {
        long x = Long.MAX_VALUE - 1;
        double d = x;
        long y = (long) d;
        System.out.println(x == y);
    }
}

// C#
using System;

class Test
{
    static void Main()
    {
        long x = long.MaxValue;
        double d = x;
        long y = (long) d;
        Console.WriteLine(x == y);
    }
}

I observed something really strange when doing this though… in C#, long.MaxValue “worked” in terms of printing False… whereas in Java, I had to use Long.MAX_VALUE - 1. My guess is that this is due to some inlining and 80-bit floating point operations in some cases… but it’s still odd 🙂