IEEE 754 Floating-Point Converter

About the IEEE 754 Floating-Point Converter

Type a number and see how it is stored as an IEEE 754 binary floating-point value in half (binary16), bfloat16, single (binary32), double (binary64) and quadruple (binary128) precision: the sign, exponent and fraction bits, the hex pattern, and the exact stored value with every digit, so you can see the rounding error instead of guessing it. Or enter a bit pattern such as 3DCCCCCD and read the number back, including subnormals, signed zeros, infinities and NaNs with their payloads.

The page works with exact rational arithmetic: a decimal like 0.1 is rounded once, straight to the target format, using any of the five IEEE rounding directions — never through a JavaScript number first. The arithmetic panel performs one correctly rounded IEEE operation, which shows step by step why 0.1 + 0.2 is 0.30000000000000004 in double precision.

Common uses

• Understanding floating-point rounding errors, and explaining them to students or in code reviews.
• Decoding a float or double from a hex dump, a network packet, a register or a binary file.
• Checking the bit patterns and limits of half and bfloat16 values used in GPU and machine-learning code.
• Producing exact test values for parsers and printers (shortest round-trip decimals, C hex floats, signed zeros, subnormals, NaN payloads).

How a binary floating-point number is stored

IEEE Std 754-2019 (clause 3.4) encodes a binary floating-point number in three fields: a sign bit s, a biased exponent E of w bits and a trailing significand (fraction) T of t bits. With bias = 2^(w−1) − 1:

• If 0 < E < all ones, the number is normal: (−1)^s × 1.T × 2^(E − bias). The leading 1 is implicit, so the precision is p = t + 1 bits.
• If E = 0 and T ≠ 0, the number is subnormal: (−1)^s × 0.T × 2^(1 − bias). These fill the gap between zero and the smallest normal number (gradual underflow).
• If E = 0 and T = 0, it is ±0; if E is all ones, it is ±∞ (T = 0) or NaN (T ≠ 0).

Half precision has w = 5, t = 10 (bias 15); single w = 8, t = 23 (bias 127); double w = 11, t = 52 (bias 1023); quad w = 15, t = 112 (bias 16383). The format facts panel lists the range and precision each one gives.

Why 0.1 + 0.2 ≠ 0.3

Most decimal fractions have no finite binary expansion, so each one is rounded when stored. In double precision 0.1 becomes 0.1000000000000000055511151231257827…, 0.2 becomes 0.2000000000000000111022302462515654…, and 0.3 becomes 0.2999999999999999888977697537484345…. The exact sum of the first two is 0.3000000000000000166533453693773481…, and IEEE addition rounds that to the nearest double, 0.3000000000000000444089209850062616… — one step (one ULP) above the double nearest to 0.3. Nothing is broken: both results are correctly rounded, they just come from different roundings. Compare floating-point results with a tolerance, or use decimal or integer arithmetic (for money, count cents) when exact decimal results matter.

Rounding directions

IEEE 754-2019 (clause 4.3) defines roundTiesToEven — the default for binary formats, used by virtually all hardware and languages — plus roundTiesToAway, roundTowardZero, roundTowardPositive and roundTowardNegative. Ties-to-even picks the neighbour whose last significand bit is 0, so ties do not drift up or down on average. When a result is too large, the two nearest modes give ±∞, toward-zero gives the largest finite number, and the directed modes give ∞ on one side and the largest finite number on the other (clause 7.4).

NaNs, payloads and signed zeros

A NaN has an all-ones exponent and a non-zero fraction. IEEE 754-2019 (clause 6.2.1) says the first fraction bit should be 1 for a quiet NaN and 0 for a signalling NaN; the remaining bits are the payload, which programs can use to carry diagnostic information. This page shows and preserves the payload; arithmetic here returns the default quiet NaN (payload 0), while real hardware may pass an input’s payload through. −0 and +0 compare equal but behave differently: 1/−0 is −∞, and a sum of opposite numbers is +0 except when rounding toward −∞.

About bfloat16

bfloat16 is not one of the IEEE 754 formats: it is the upper half of a binary32 value — the same sign and 8-bit exponent, with a 7-bit fraction — popular in machine learning because it keeps single precision’s range. The page encodes it with the IEEE rules (subnormals, ±∞, NaN) and rounds the exact value to nearest, ties to even. Some software and hardware instead convert a single-precision value by simply dropping its lower 16 bits; that is rounding toward zero from single precision, so for a decimal input it can differ in the last bit from the toward-zero setting here, which rounds the exact value.

Limitations

• Only binary interchange formats are covered: not the x87 80-bit extended format, IEEE decimal formats (decimal32/64/128), IBM hexadecimal floating point or the 8-bit FP8 formats.
• The arithmetic panel performs one operation at a time (+, −, ×, ÷) and does not evaluate expressions.
• Numbers whose decimal exponent is beyond ±5,100 are outside every format here; they convert to ±∞, ±0 or the largest or smallest value according to the rounding direction, and their rounding error is not printed digit by digit.

Privacy

Everything happens in your browser. What you enter or open here is not uploaded or stored by MySmartCoPilot.