Floating-point numbers

Scientific notation in base 2

The lesson Integers and their representation showed that an integer of $n$ bits represents exactly $2^n$ consecutive values. Now, numbers with decimals pose a different difficulty: between any two reals there are infinitely many others, and no finite number of bits can tell them all apart. The solution adopted by every current computer is the same one science uses to write very large or very small magnitudes: scientific notation. In base 10, the mean distance from the Earth to the Sun is written $1.496 \times 10^{11}$ meters; the number has a sign, a few significant digits (the significand, or mantissa, $1.496$) and a power of the base (the exponent, $11$), which says where the decimal point goes. If this is so, a fixed number of digits covers magnitudes of very different orders, at the price of keeping only the first digits of each.

The computer does the same in base 2. Every nonzero number is written in exactly one way as

where $s$ is the sign (0 for positive, 1 for negative), $1.m_1 m_2 \ldots$ is the significand written in binary, whose first digit is always 1, and $e$ is the exponent. That the first digit is always 1 has a practical consequence: there is no need to store it, and the bit saved goes to precision. The name floating point describes exactly this form: the point does not occupy a fixed place among the digits, but “floats” according to the exponent.

The C++ type double uses, in every current compiler, the internationally standardized binary double-precision format, of 64 bits: 1 bit for the sign, 11 bits for the exponent and 52 bits for the significand, without the leading digit. The exponent is stored biased: the 11-bit field holds $e + 1023$, so that it stores unsigned values from 1 to 2046 for exponents from $-1022$ to $1023$ (the field values 0 and 2047 are reserved for zero, very small numbers, infinity and the not-a-number value, which are covered at the end of the lesson). The type float uses the single-precision format, of 32 bits: 1 for the sign, 8 for the exponent and 23 for the significand.

The bits of a double can be seen. The following program uses std::bit_cast, from the header <bit>, which reinterprets the 64 bits of the number as an unsigned 64-bit integer, without changing any of them; here it is used without further explanation, as an instrument for looking at memory. The specification {:064b} writes that integer in binary with 64 digits, as in the previous lesson, and {:016X} in hexadecimal with 16.

#include <bit>#include <cstdint>#include <print>​int main(){    const double tenth{0.1};    // The 64 bits of the number, read as an unsigned integer.    const std::uint64_t bits{std::bit_cast<std::uint64_t>(tenth)};    std::println("{:064b}", bits);    std::println("{:016X}", bits);}

00111111101110011001100110011001100110011001100110011001100110103FB999999999999A