Are all integer values perfectly represented as doubles?

My question is whether all integer values are guaranteed to have a perfect double representation.

Consider the following code sample that prints "Same":

// Example program
#include <iostream>
#include <string>

int main()
{
  int a = 3;
  int b = 4;
  double d_a(a);
  double d_b(b);
  
  double int_sum = a + b;
  double d_sum = d_a + d_b;
  
  if (double(int_sum) == d_sum)
  {
      std::cout << "Same" << std::endl;
  }
}

Is this guaranteed to be true for any architecture, any compiler, any values of a and b? Will any integer i converted to double, always be represented as i.0000000000000 and not, for example, as i.000000000001?

I tried it for some other numbers and it always was true, but was unable to find anything about whether this is coincidence or by design.

Note: This is different from this question (aside from the language) since I am adding the two integers.

Disclaimer (as suggested by Toby Speight): Although IEEE 754 representations are quite common, an implementation is permitted to use any other representation that satisfies the requirements of the language.

---

The doubles are represented in the form mantissa * 2^exponent, i.e. some of the bits are used for the non-integer part of the double number.

             bits        range                       precision
  float        32        1.5E-45   .. 3.4E38          7- 8 digits
  double       64        5.0E-324  .. 1.7E308        15-16 digits
  long double  80        1.9E-4951 .. 1.1E4932       19-20 digits

The part in the fraction can also used to represent an integer by using an exponent which removes all the digits after the dot.

E.g. 2,9979 · 10^4 = 29979.

Since a common int is usually 32 bit you can represent all ints as double, but for 64 bit integers of course this is no longer true. To be more precise (as LThode noted in a comment): IEEE 754 double-precision can guarantee this for up to 53 bits (52 bits of significand + the implicit leading 1 bit).

Answer: yes for 32 bit ints, no for 64 bit ints.

(This is correct for server/desktop general-purpose CPU environments, but other architectures may behave differently.)

Practical Answer as Malcom McLean puts it: 64 bit doubles are an adequate integer type for almost all integers that are likely to count things in real life.

---

For the empirically inclined, try this:

#include <iostream>
#include <limits>
using namespace std;

int main() {
	double test;
	volatile int test_int;
	for(int i=0; i< std::numeric_limits<int>::max(); i++) {
		test = i;
		test_int = test;

        // compare int with int:
		if (test_int != i)
			std::cout<<"found integer i="<<i<<", test="<<test<<std::endl;
	}
	return 0;
}

> Success time: 0.85 memory: 15240 signal:0

---

Subquestion: Regarding the question for fractional differences. Is it possible to have a integer which converts to a double which is just off the correct value by a fraction, but which converts back to the same integer due to rounding?

The answer is no, because any integer which converts back and forth to the same value, actually represents the same integer value in double. For me the simplemost explanation (suggested by ilkkachu) for this is that using the exponent 2^exponent the step width must always be a power of two. Therefore, beyond the largest 52(+1 sign) bit integer, there are never two double values with a distance smaller than 2, which solves the rounding issue.

No. Suppose you have a 64-bit integer type and a 64-bit floating-point type (which is typical for a double). There are 2^64 possible values for that integer type and there are 2^64 possible values for that floating-point type. But some of those floating-point values (in fact, most of them) do not represent integer values, so the floating-point type can represent fewer integer values than the integer type can.

The answer is no. This only works if ints are 32 bit, which, while true on most platforms, isn't guaranteed by the standard.

The two integers can share the same double representation.

For example, this

#include <iostream>
int main() {
    int64_t n = 2397083434877565865;
    if (static_cast<double>(n) == static_cast<double>(n - 1)) {
        std::cout << "n and (n-1) share the same double representation\n";
    }
}    

will print

> n and (n-1) share the same double representation

I.e. both 2397083434877565865 and 2397083434877565864 will convert to the same double.

Note that I used int64_t here to guarantee 64-bit integers, which - depending on your platform - might also be what int is.

You have 2 different questions:

> Are all integer values perfectly represented as doubles?

That was already answered by other people (TL;DR: it depends on the precision of int and double).

> Consider the following code sample that prints "Same": [...] Is this guaranteed to be true for any architecture, any compiler, any values of a and b?

Your code adds two ints and then converts the result to double. The sum of ints will overflow for certain values, but the sum of the two separately-converted doubles will not (typically). For those values the results will differ.

The short answer is "possibly". The portable answer is "not everywhere".

It really depends on your platform, and in particular, on

• the size and representation of double
• the range of int

For platforms using IEEE-754 doubles, it may be true if int is 53-bit or smaller. For platforms where int is larger than double, it's obviously false.

You may want be able to investigate the properties on your runtime host, using std::numeric_limits and std::nextafter.