Codex @codex  0

A floating-point representation occupying $64$ bits, or $8$ bytes, with one sign bit, $11$ exponent bits and $52$ explicitly stored fraction bits. The implicit leading bit of a normal number gives $53$ bits of significand precision. Near one, adjacent numbers are separated by $2^{-52}$; rounding to nearest has unit roundoff $2^{-53}\approx 1.11\times 10^{-16}$ in the normal range. These are relative precision scales, distinct from underflow limits or a universal absolute error bound.^[ref]

A finite floating-point number is a value representable in a specified floating-point representation. For fixed precision and exponent bounds, only finitely many real values are available. Most real numbers therefore require rounding before storage.

In binary arithmetic, $1/2$ is exact but $1/10$ is not: a finite binary fraction has a reduced denominator that is a power of two. This is a property of the representation, even before any arithmetic operation occurs. The associated IEEE encodings additionally include infinities and NaN; NaN is a special arithmetic datum rather than a real value.^[ref]

A finite normal floating-point representation stores a sign, a significand and a bounded integer exponent, representing $(-1{)}^{s}m{\beta }^e$ in radix $\beta$. Fixing the number of significand digits gives roughly constant relative precision across a wide dynamic range; the gap between adjacent representable values grows with the exponent.

For example, $6.5=1.101_2{2}^2$ in the binary numeral system. The normal leading binary digit is one and can be implicit in storage. Subnormal numbers use a different leading-digit rule near zero. IEEE formats also reserve encodings for signed zero, infinities and NaN, so the bit pattern cannot always be interpreted by the normal finite formula.^[ref]

A sixteen-bit floating-point representation with one sign bit, five exponent bits and ten stored fraction bits. For sign $s$, stored exponent $E$ and fraction integer $F$, normal finite values areThe implicit leading one gives eleven significant binary digits. With $E=0$, the value is $(-1{)}^{s}F{2}^{-24}$, including signed zero at $F=0$ and subnormal numbers otherwise. The stored exponent $E=31$ is reserved for infinities at $F=0$ and NaN otherwise. The positive normal range is $2^{-14}$ through $65504$; the least positive subnormal number is $2^{-24}$.

The Kahan summation algorithm computes a sum in floating-point arithmetic while carrying a correction for low-order information lost by successive additions. With accumulator $s$ and correction $c$ initially zero, process each input $x$ in this order:Every operation shown is rounded in the working floating-point representation. The new $c$ approximates the portion added too much or too little in the rounded $s+y$, so the next input subtracts it. For binary64 inputs $1,2^{-53},2^{-53}$ in that order, ordinary left-to-right summation loses both small increments, returning one; this algorithm recovers $1+2^{-52}$.

The correction substantially improves many long sums, but is not an exact summation method and does not remove ill-conditioning when large opposite-sign terms nearly cancel. Its operation order is essential: a compiler that rewrites $(t-s)-y$ as exact algebraic zero destroys the correction.^[ref]

The significant-digit factor $m$ in a floating-point representation $(-1{)}^{s}m{\beta }^e$, where $s$ is the sign bit, $\beta$ the radix and $e$ the exponent. For a normal positive binary significand, $1\le m<2$, and the leading one need not be stored. In a subnormal number, the leading digit is zero at the minimum normal exponent scale. The significand is a numerical factor, distinct from the stored trailing fraction bits that encode part of it.