What are the smallest values that can no longer be represented exactly in C decimal point datatypes?

For example: What is the smallest uint32_t value that can no longer be represented exactly as a double? etc.

And how to calculate these values?

> What is the smallest uint32_t value that can no longer be represented exactly as a double?

All uint32_t can be exactly represented as a double as C specifies DBL_DIG >= 10 results in C encoding exactly at least all consecutive integers values [-10¹⁰ to +10¹⁰]. That encompasses all uint32_t.

> how to calculate these values?

Refer to the C spec.

The minimal continuous range of integers value exactly encodable as a floating point type is specified by C primarily by:

FLT_DIG 6
DBL_DIG 10
LDBL_DIG 10

In the case of float, all 6 decimal digit integers are representable [-999,999.0 to +999,999.0] including +/- 1,000,000. Starting from zero and going down, the first negative integer value that may not be representable as a float is -1,000,001. This is the minimum range when FLT_RADIX == 10, which hardly exists anymore.

When FLT_RADIX == 2 (very common), the number of binary digits p in the significand is:

(p-1)*log10(2) >= xxx_DIG

solving this for float, p is at least 20. With p == 20, float can exactly encode integers [-2²⁰ to +2²⁰] or [-1,048,576 to +1,048,576].

So much for spec minimums.

Common limit

Typical float with its sign bit and 24 binary digits has a wider range than the C spec minimum. It exactly encodes integers [-2²⁴ to +2²⁴]. The first negative integer value that is not representable: -2²⁴ - 1 or -16,777,217.

What float and double are varies based on compiler, and it chooses based on the architecture. On an x86 or x86-64, a float is likely an IEEE single-precision floating point number, and double is likely an IEEE double-precision floating point number.

An IEEE single-precision float has 24 bits of precision.^[1] It can exactly represent far larger numbers than those mentioned above, but it can't represent 2^24+1 or -2^24-1 exactly.

An IEEE double-precision float has 53 bits of precision.^[1] It can exactly represent far larger numbers than those mentioned above, but it can't represent 2^53+1 or -2^53-1 exactly.

1. Subnormals (extremely small numbers) have less precision.

​1. You have a principal discrepancy in your question: you have said for "decimal point" datatypes but then mentioned "double".

double, in utmost majority of available implementations, is not decimal point type, it is binary point type (IEEE754 64-bit decimal). You might look more detailed in Internet and literature how they differ.

For the following Iʼll assume binary double and not (really rarely present and used) truly decimal types.

​2. Thatʼs, well, simple but a tiny bit tricky:))

I will assume that a platform you refer natively implements IEEE754 and, float is 32-bit binary IEEE number and double is 64-bit binary IEEE number.
In this case, float has 24-bit mantissa with leading 1 (we donʼt count denormals here) and we need the smallest value which, not including leading trailing zeros, does not fit into 24 bits. (No need to check exponent range for the question.)

For the following, "0b" is binary prefix and "**" is power operator.

16777215 = 2**24-1 is 0b111111111111111111111111 (24 consecutive ones). It fits.

16777216 = 2**24 is 0b1000000000000000000000000 (one and 24 consecutive zeros). It fits.

16777217 = 2**24+1 is 0b1000000000000000000000001 (one, 23 consecutive zeros, and one). It does not fit.

"Float" can represent: ..., 16777214, 16777215, 16777216, 16777218, 16777220, 16777222... so starting with 16777216 = 2**24, step between representable values is 2.

So, the minimum unsigned integer, not representable in "float", is 16777217.

No need to copy all these long string bits for other case - with double with its 53-bit mantissa, it would be just cumbersome. I hope the principle is declared well. For your concrete example, it means that any uint32_t value can be exactly represented in double but not in float.

​3. Also, for uint32_t and double you could merely have checked declared accuracy. uint32_t is up to 10 decimal digits (9 guaranteed). double is up to 17 decimal digits required to exactly represent any value, and 15 guaranteed to represent in it. There is obvious difference between ranges so there is no need for more precise boundary checks.