IEEE 754

IEEE 754 Double-Precision Floating Point

Languages like JavaScript and Python use the IEEE 754 standard for floating-point arithmetic. This leads to the classic precision question that shows up in interviews and real-world debugging alike:

0.1 + 0.2 == 0.30000000000000004

In JavaScript, there is only a single number type — no separate integer and float types. Even integers are stored as double-precision floats, which introduces integer precision limits such as MAX_SAFE_INTEGER:

> Number.MAX_SAFE_INTEGER
9007199254740991
> Number.MAX_SAFE_INTEGER + 1
9007199254740992
> Number.MAX_SAFE_INTEGER + 2
9007199254740992
> Number.MAX_SAFE_INTEGER + 3
9007199254740994
> Number.MAX_SAFE_INTEGER + 4
9007199254740996

Internal Representation

1. A double-precision float is 64 bits, divided into three fields: sign (1 bit), exponent (11 bits), and mantissa (52 bits).
2. Internally, the value is expressed in binary scientific notation. For example, 1536 is stored as 1.1 × 2¹⁰ — the mantissa stores .1 (the fractional part after the implicit leading 1) and the exponent stores 10.
3. The exponent is stored with an exponent bias of 1023 (binary 01111111111), so the stored exponent = actual exponent + 1023.

How to Use

Enter a Number

Type a number into the input field at the top of the page. The tool will display its 64-bit binary representation in real time according to the IEEE 754 double-precision standard.

You can enter regular numbers (e.g. 3.14, 1024) or scientific notation (e.g. 1.5e10).

Understanding the Binary Display

After entering a number, each of the 64 bits is shown as a color-coded block:

• Purple (1 bit) — Sign bit. 0 = positive, 1 = negative
• Blue (11 bits) — Exponent. Stored with a bias of 1023
• Orange (52 bits) — Mantissa (significand). Stores the fractional part after the implicit leading 1

Below the bit display, the tool shows the number in both binary and decimal scientific notation to help you understand the internal representation.

If the number cannot be represented exactly (e.g. 0.1), a red warning appears at the bottom. If it can be represented exactly (e.g. 0.5), a green indicator is shown.

Quick-Try Special Values

The page provides a set of quick-try buttons for notable values:

• 0.1, 0.2, 0.3 — The classic floating-point precision trio. Notice how their mantissa bits are all truncated
• Infinity and -Infinity — Exponent bits all 1, mantissa bits all 0
• Number.EPSILON — The smallest precision unit, with an exponent corresponding to −52
• Number.MAX_SAFE_INTEGER — The largest safe integer (2⁵³ − 1), with every mantissa bit filled

Verify Classic Problems Yourself

Try entering 0.1, then 0.2. You'll see that both have truncated mantissa bits — this is the root cause of 0.1 + 0.2 !== 0.3. In binary floating point, none of these three values can be represented exactly.

Now try 9007199254740992 (MAX_SAFE_INTEGER + 1). Compare it with 9007199254740993 — they produce identical bit patterns, demonstrating why precision is lost beyond the safe integer range.

FAQ

Q: Why does 0.1 + 0.2 not equal 0.3?

This is a classic IEEE 754 precision issue. Decimal 0.1 and 0.2 cannot be represented exactly in binary floating point — just as decimal cannot represent 1/3 exactly. 0.1 in binary is an infinitely repeating fraction that gets truncated when stored, introducing a tiny rounding error. Adding two imprecise values preserves the error, yielding 0.30000000000000004 instead of 0.3. This behavior is not unique to JavaScript — it affects virtually every language that uses IEEE 754.

Q: What is JavaScript's MAX_SAFE_INTEGER and why?

Number.MAX_SAFE_INTEGER is 2⁵³ − 1 (i.e. 9007199254740991). IEEE 754 double-precision uses 52 bits for the mantissa, plus one implicit leading bit, giving 53 bits of significand. This means only integers up to 53 bits can be represented exactly. Beyond this range, consecutive integers map to the same floating-point representation — for example, 9007199254740992 === 9007199254740993 evaluates to true. Use BigInt for arbitrary-precision integer arithmetic.

Q: What is −0? Is it different from 0?

IEEE 754 stores the sign bit separately, so both +0 and −0 exist. In most operations they behave identically: −0 === +0 is true, and −0 + 0 equals 0. However, they can be distinguished in special cases: 1 / +0 is Infinity, while 1 / −0 is −Infinity. You can also use Object.is(−0, 0) which returns false. Negative zero preserves directional information — e.g. a value approaching zero from the negative side.

Q: What is NaN, and why does NaN !== NaN?

NaN (Not a Number) is a special IEEE 754 value representing undefined or unrepresentable math results, such as 0 / 0 or Math.sqrt(-1). The standard specifies that NaN is not equal to any value, including itself. This is a deliberate design choice to prevent misleading equality comparisons on meaningless results. In JavaScript, use Number.isNaN() for reliable detection — avoid the global isNaN(), which coerces its argument and can produce unexpected results.

Q: How can floating-point precision issues be solved?

Several approaches exist. For financial calculations, scale decimals to integers (e.g. work in cents instead of dollars) to avoid float arithmetic altogether. For arbitrary precision, use libraries like decimal.js or big.js, which perform decimal arithmetic via string representation. When comparing floats, avoid ===; instead check whether the absolute difference is smaller than a tolerance (e.g. Number.EPSILON). The right approach depends on your precision requirements and performance constraints.