binary128

A binary128 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 − 16383: the leading 1 is implied, so 112 stored bits give 113 bits of precision. All zeros in the exponent means a subnormal, (−1)s × 0.f × 2-16382, 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 113 bits, which is 34.02 decimal digits: any decimal with 34 significant digits survives a round trip through binary128, and 36 digits are enough to write any binary128 value down so that it reads back to the same bits. Every integer up to 2¹¹³ = 2^113 (about 1.04e34) 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.19e4932, the smallest normal about 3.36e-4932, and the subnormals reach down to 2^-16494, about 6.48e-4966.

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.

binary128 is the format IEEE 754 defines as its third basic format and almost no processor implements. IBM's POWER9 and later compute it in hardware, IBM's mainframes have for longer, and the RISC-V specification defines a Q extension that nearly nothing fabricates. Everywhere else it is software: GCC's __float128 with libquadmath, C23's _Float128, Fortran's real128, and on some platforms the keyword long double, which is the trap this format is known for. On AArch64 Linux and SPARC long double is binary128. On x86-64 Linux it is the 80-bit x87 format. On Windows and on macOS it is plain binary64. One keyword, three formats, and code that is correct on one platform is silently a different program on the next.

On Apple Silicon there is no __float128 at all, so on that machine the fastest available binary128 is not a compiler type but a library: MPFR at 113 bits, or the software backend that runs this page.

binary128 rarely fails on its own arithmetic. Thirty-four digits absorb the sums, the cancellations and the accumulated drift that break the narrower formats. What breaks is the path to it: a keyword that means three formats, a fused multiply-add that costs forty times a multiply, a NumPy type that is quad on one machine and 80-bit on another, and a decimal literal that was parsed as binary64 before it ever reached the wide type. The cases below show what the format holds exactly, which is the real argument for it: a double's product, a double's sum, the intermediate a binary64 algorithm needed and could not keep.

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.

Ranked by how often they are the right answer. The first two are what most binary128 code actually uses; the rest are for when the first two are not there.

Reproducibility at binary128 has a different problem from binary64's. There is no hardware to define the answer on most machines, so every result is some library's, and the libraries differ: libquadmath and MPFR agree on add, multiply and square root, which are correctly rounded in both, and disagree in the last bit of the transcendentals, where libquadmath is accurate and MPFR is correctly rounded. A value computed with expq and checked with mpfr_exp will not match, and neither is wrong by its own definition.

cft-fp256 defines every operation at this format as correctly rounded, the transcendentals included, and holds itself to that definition against the one independent library that can reach it: GNU MPFR arbitrates 739,234 transcendental cases and 999,000 division and square-root cases at all four formats with zero value and zero flag mismatches. The published conformance vectors are the definition anyone can score their own implementation against, and the replay below runs the binary128 sample of them here. The one program in nine languages prints 0xb815aa4a3a3eb024 over this format's vectors on every platform in the project's compatibility record.

This is also the first rung where the hardware earns its place. The FPGA tile computes binary128 at 2 lanes per beat and reproduces the vectors on silicon to the same bits as the software backend and as this tab: one tile is 4.5x faster than the best software on the same machine, four tiles 17.5x. The point of the card is not that it is fast, though at this format it is; it is that a faster path exists that does not change the answer.

binary64 is sufficient far more often than the people buying wider formats expect, and cft-rebound's horizon study says where the line is. For a regular orbit, binary64's phase error reaches one millionth of an orbit near two million orbits at any setting; binary128 at the same tolerance reaches it at twenty-four million, and at a tighter tolerance, for five times the work per orbit, at fifty billion. Below a million orbits, past a chaotic horizon, or wherever the physics limits first, binary64 is the right answer and binary128 buys nothing.

What it buys when it buys something is large. On Burrau's Pythagorean three-body problem, the binary64 solution is lost by t = 66 and the binary128 solution on the same steps runs eighteen decades under it: the two divergence curves are one curve, 2⁶⁰ apart, because the only difference between the runs is the arithmetic. At REBOUND's default tolerance the wide format recovers four orders of magnitude of accuracy at once, ten at a tolerance of 1e-12, eighteen at 1e-16.

Going up to binary256 is a step that, for that integrator, changes nothing: at every step size a user would choose, binary256 is identical to binary128 to every digit, because a fifteenth-order method's own truncation error sits far above the binary128 floor. The one regime the study found for it is the outer solar system at ten-to-twenty-day steps, where it is worth one to six orders more. A negative result, measured and kept, is the most honest link a site can offer to its neighbour.