Is `double` guaranteed by C++03 to represent small

Question

Does the C++03 standard guarantee that sufficiently small non-zero integers are represented exactly in double? If not, what about C++11? Note, I am not assuming IEEE compliance here.

I suspect that the answer is no, but I would love to be proved wrong.

When I say sufficiently small, I mean, bounded by some value that can be derived from the guarantees of C++03, and maybe even be calculated from values made available via std::numeric_limits<double>.

---

EDIT:

It is clear (now that I have checked) that std::numeric_limits<double>::digits is the same thing as DBL_MANT_DIG, and std::numeric_limits<double>::digits10 is the same thing as DBL_DIG, and this is true for both C++03 and C++11.

Further more, C++03 defers to C90, and C++11 defers to C99 with respect to the meaning of DBL_MANT_DIG and DBL_DIG.

Both C90 and C99 states that the minimum allowable value for DBL_DIG is 10, i.e., 10 decimal digits.

The question then is, what does that mean? Does it mean that integers of up to 10 decimal digits are guaranteed to be represented exactly in double?

In that case, what is then the purpose of DECIMAL_DIG in C99, and the following remark in C99 §5.2.4.2.2 / 12?

Conversion from (at least) double to decimal with DECIMAL_DIG digits and back should be the identity function.

---

Here is what C99 §5.2.4.2.2 / 9 has to say about DBL_DIG:

Number of decimal digits, 'q', such that any floating-point
number with 'q' decimal digits can be rounded into a
floating-point number with 'p' radix 'b' digits and back again
without change to the q decimal digits,

    { p * log10(b)              if 'b' is a power of 10
    {
    { floor((p-1) * log10(b))   otherwise

FLT_DIG   6
DBL_DIG   10
LDBL_DIG  10

I'll be happy if someone can help me unpack this.

Answer 1

From the C standard, "Characteristics of floating types <float.h>", which is normative for C++, I would assume that you can combine FLT_RADIX and FLT_MANT_DIG into useful information: The number of digits in the mantissa and the base in which they are expressed.

For example, for a single-precision IEEE754 float, this would be respectively 2 and 24, so you should be able to store integers of absolute value up to 2²⁴.

Answer 2

Well, 3.9.1 [basic.fundamental] paragraph 8 states

... The value representation of floating-point types is implementation-defined. ...

At least, the implementation has to define what representation it uses.

On the other hand, std::numeric_limits<F> defines a couple of members which seem to imply that the representation is some in the form of significand radix ^exponent:

• std::numeric_limits<F>::radix: the radix of the exponent
• std::numeric_limtis<F>::digits: the number of radix digits

I think these statements imply that you can represent integers in the range of 0 ... radix ^digits - 1 exactly.