IEEE 754 Explained: Float to Binary (Sign, Exponent, Mantissa)

IEEE 754 binary floating-point formats store a sign, an exponent, and a fraction field. Many decimal fractions cannot be represented exactly in those fields. This guide converts 3.14159 to binary32, compares binary64, and connects the layout to rounding in calculations such as 0.1 + 0.2.

What IEEE 754 Encodes

Every finite floating-point value is stored as three pieces: a sign bit, an exponent field, and a fraction (mantissa / significand). The value is roughly:

The leading 1 before the binary point is usually implied for normal numbers, so you do not store it. That trick buys one extra bit of precision. Special cases (zeros, subnormals, infinities, NaNs) bend the rules; we will cover those after the main example.

Single vs Double Precision

Two widths show up everywhere in C, JavaScript (which uses double for Number), Python, and GPU shaders.

Double is not “twice as accurate” in a casual sense; it has far more mantissa bits, so the spacing between representable numbers around 1.0 shrinks from about 1.19×10⁻⁷ (float) to about 2.22×10⁻¹⁶ (double). Use the IEEE 754 lab when you want both layouts side by side without doing the arithmetic by hand.

Step 1: Sign Bit

The sign bit is 0 for positive values and 1 for negative values, including the separate encodings of positive and negative zero. The example 3.14159 therefore starts with a zero sign bit.

Step 2: Convert to Binary Scientific Notation

Split the number into an integer part and a fractional part, convert each to binary, then normalize so there is a single 1 left of the binary point.

Integer part: 3 → 11 in binary.

Fractional part 0.14159: multiply by 2 repeatedly, recording the integer bit each time.

So far: 11.001001…. Normalize by shifting the binary point one place left:

Step 3: Pack the Mantissa

For a normal binary32 value, omit the leading 1 and round the fraction to 23 stored bits using round-to-nearest, ties-to-even. Keep enough extra bits to decide the rounding. For 3.14159, the result is:

The exact binary32 hexadecimal pattern is 0x40490FD0, representing 3.141590118408203125. This is the nearest binary32 value to 3.14159. Check it with the IEEE 754 converter.

Double Precision for the Same Number

Same sign. Same unbiased exponent of 1, but the bias is 1023, so the stored exponent is 1024 = 10000000000. The mantissa stretches to 52 bits, capturing more of the infinite binary expansion of 0.14159.

That is why printing 3.14159 as a double often looks closer to the decimal you typed, while casting to float can nudge it. Neither representation is the mathematical real number; both are nearby dyadic rationals.

Special Values You Will Meet

In JavaScript, division of a finite nonzero value by zero produces a signed infinity. Zero divided by zero and Math.sqrt(-1) produce NaN. Equality and ordered comparisons involving NaN are false; inequality comparisons are true. Use Number.isNaN to test for NaN.

Why 0.1 Repeats in Binary

Decimal 0.1 has a repeating expansion in binary, similar to how 1/3 repeats in decimal. IEEE 754 stores the closest representable value. When you add rounded approximations, the error shows up in the last bits.

For money, use integers (cents) or a decimal type. For graphics and science, floats are fine if you understand the error budget. Inspecting the bits once makes the tradeoff less mysterious. Related reading: what is binary code and binary in programming.

Reading Float Bits in a Hex Dump

The binary32 pattern 0x40490FD0 occupies four bytes. In little-endian order these appear as D0 0F 49 40. Reverse the byte order to write 40 49 0F D0, then split the bits into the sign, exponent, and fraction fields.

Hex is still the friendliest way to talk about those 32 bits. Convert nibbles with the binary converter when you need the raw 0/1 string for a paper or a unit test.

Quick Checklist for Manual Conversion

1. Write the sign bit.
2. Convert absolute value to binary (integer + fraction).
3. Normalize to 1.m × 2^e.
4. Add the bias to e and write the exponent field.
5. Copy m into the mantissa width; round the last bit if needed.
6. Sanity-check by converting bits back to decimal, or paste into the lab tool.

FAQ

Convert 3.14159 Yourself

Walk the steps above once on paper. Then confirm the bit string in the browser so you trust the layout when you see it in a crash dump or a protocol buffer.

Open the IEEE 754 Float Lab at BinaryTranslator.org, enter 3.14159, and toggle single vs double. From there you can jump to the home converter for integer bases, or decimal to binary for the integer-only path.