binary64

A binary64 value is a sign, a biased exponent and a fraction, packed as s · e · f from the most significant bit down. When the exponent field is neither all zeros nor all ones the value is (−1)s × 1.f × 2e − 1023: the leading 1 is implied, so 52 stored bits give 53 bits of precision. All zeros in the exponent means a subnormal, (−1)s × 0.f × 2-1022, which lets the format lose precision gradually rather than dropping to zero. All ones means infinity when the fraction is zero and a NaN otherwise; the fraction's top bit says whether the NaN is quiet or signaling.

Precision is 53 bits, which is 15.95 decimal digits: any decimal with 15 significant digits survives a round trip through binary64, and 17 digits are enough to write any binary64 value down so that it reads back to the same bits. Every integer up to 2⁵³ = 9,007,199,254,740,992 is exact; above it the spacing between representable numbers is 2, then 4, then 8, and an integer that lands between them is rounded to a neighbour. The largest finite value is about 1.80e308, the smallest normal about 2.23e-308, and the subnormals reach down to 2^-1074, about 4.94e-324.

The spacing is what matters in practice. Between two consecutive powers of two the representable values are evenly spaced, 2⁵² of them per binade, and the spacing doubles with every binade. Relative to the value it is always between 2⁻⁵³ and 2⁻⁵²; absolute, it depends entirely on how big the value is.

binary64 has been in silicon since the 8087 in 1980. Every desktop, server and phone processor computes it in hardware at close to its binary32 rate, and it is the number type a language gives you when you do not ask for one: double in C, C++, Java and C#, float in Python, Number in JavaScript, REAL*8 or real(8) in Fortran, the default of R, MATLAB, Julia, NumPy and every spreadsheet. When a scientific paper says "floating point" without a width, it means this.

Graphics processors are the exception that matters. A GPU is built for binary32; its binary64 rate ranges from half the binary32 rate on parts sold for simulation to one thirty-second or one sixty-fourth on parts sold for games and machine learning. The same CUDA kernel can be forty times slower on one card than on another with the same nominal peak, and that is the first thing to check before moving a double-precision workload to a GPU.

Most binary64 trouble is one of four things. A decimal that has no binary64 value, so what you typed is not what you stored. An integer past 2⁵³, where the spacing between representable numbers is already 2. A sum whose answer depends on the order the terms were added, which is every parallel reduction ever written. And a transcendental function whose last bit is left to the library, so sin on one machine is not sin on another. Each case below is computed here, by the library this page runs, and where your browser has an opinion of its own it is shown beside the contract's and compared bit for bit.

Every arithmetic operation computes the exact result and then rounds it once, under one of five attributes: to nearest with ties to even (the default everywhere), toward zero, toward −∞, toward +∞, and to nearest with ties away from zero. The directed attributes are how interval arithmetic gets rigorous bounds; ties-to-away is what some decimal conventions expect. Alongside the result, five flags record what happened: inexact when rounding changed the value, underflow when a tiny result was also inexact, overflow when the exact result was too large, divideByZero for a finite divided by zero, and invalid for an operation with no meaningful answer, such as 0/0 or ∞ − ∞, which delivers a quiet NaN.

The hardware does the arithmetic and does it correctly rounded; the tools are for everything around it. Ranked by how often they are the right answer.

The basic operations of binary64, add, subtract, multiply, divide, square root and fused multiply-add, are correctly rounded on every processor that conforms to IEEE 754, so two machines that both conform get the same bits from the same operands. The disagreement starts one clause later. The standard recommends that sin, exp, pow and the rest of its table 9.1 be correctly rounded and does not require it, so every libm is free to be off by a unit in the last place, and they are, differently. A simulation that calls exp a billion times is a different simulation on macOS and on Linux, and a run cannot be reproduced on a machine that was not the one it ran on.

cft-fp256's answer is to define one exact result for every operation, including all thirty-nine of table 9.1 correctly rounded under all five rounding attributes with exact flags, and to score every implementation of it against that definition. GNU MPFR, the only independent library that reaches this, arbitrates 739,234 transcendental cases with zero value and zero flag mismatches. The widget below asks your browser's Math the same questions.

The evidence this site carries for the definition being binary64 itself and not a look-alike is cft-rebound: REBOUND's IAS15, a fifteenth-order adaptive integrator used in orbital-dynamics research, with every floating-point operation routed through this library. At binary64 its output is REBOUND's own, bit for bit, across 1,264 recorded values, rejected steps and iteration caps included. A library that reproduces a real scientific code's bits computes IEEE binary64. The same program in nine languages, C, C++, Fortran, Python, Rust, Julia, Go, C# and R, prints the checksum 0x04110a4c30c6df4d over this format's vectors on every platform in the project's compatibility record.

The honest bridge to the wider formats is a measurement from cft-rebound's horizon study, which asked how long a binary64 orbit integration stays worth having. Round-off in binary64 is a random walk: over a 64-member ensemble the 90th-percentile phase error of a Kepler orbit grows as 2.1e-16 × orbits^1.5, and no step size or tolerance changes that law, because a smaller step only adds steps and round-off with them. It reaches one millionth of an orbit near two million orbits. A binary128 run's error is the method's instead, a ruler rather than a walk, and at a tighter tolerance it holds the same threshold for fifty billion orbits.

So binary64 is entirely sufficient for a regular system under a million orbits at that threshold, for a chaotic system past its Lyapunov horizon where the science is statistical anyway, and for anything whose physics limits it first, which is most things. The niche for a wider format is a phase of a regular system past a few million orbits, a close encounter passed with the energy still the method's, and a result demanded exact rather than close. That is what binary128.com is about.

Down the ladder, binary32 is the right choice when seven digits are enough and the lanes are worth it: graphics, audio, most machine-learning inference, and any array large enough that halving its bytes is the difference between fitting in cache and not.