Floating Point Calculator

IEEE 754 floating-point converter — convert 32-bit and 64-bit binary to decimal and back. Free online tool with bit pattern visualization, hex output, and special case detection.

Convert between binary and decimal IEEE 754

About This Calculator

The Floating Point Calculator converts between IEEE 754 binary representations and decimal numbers for 32-bit single-precision (float) and 64-bit double-precision (double) formats. It is an essential tool for programmers, computer science students, embedded systems engineers, and anyone working with low-level data representation or debugging numerical precision issues.

IEEE 754 is the industry standard for floating-point computation, adopted by virtually all modern CPUs and programming languages. A floating-point number is stored as three segments of bits: the sign (1 bit), the exponent (8 bits for 32-bit, 11 bits for 64-bit), and the fraction (23 bits for 32-bit, 52 bits for 64-bit). For normal numbers, the real value is computed as (-1)^S × 2^(E-bias) × (1.F) where the bias is 127 for single precision and 1023 for double precision. The format also encodes special cases: zero, infinity, NaN (Not a Number), and subnormal numbers.

How to Use

Select Binary → Decimal to decode a binary string into its numeric value. Enter exactly 32 bits for single precision or 64 bits for double precision using only 0 and 1 characters. The calculator decodes the sign, exponent, and fraction according to the IEEE 754 standard and displays the resulting decimal value, along with any special case (zero, infinity, NaN, or subnormal).

Select Decimal → Binary to encode any real number into its IEEE 754 representation. Enter a decimal number and the calculator shows the sign bit, exponent bits, fraction bits, full binary string, and hexadecimal equivalent for both 32-bit and 64-bit precision.

Common Use Cases

  • Debugging — Inspect how floating-point values are stored in memory during software development
  • Education — Learn how computers represent real numbers in computer science courses
  • Embedded systems — Verify binary representations when working with sensor data or communication protocols
  • Numerical analysis — Understand precision limitations and rounding errors in scientific computing

Precision Trade-offs

Single precision offers about 7 significant decimal digits while requiring only 4 bytes of memory. Double precision offers about 16 significant digits but uses 8 bytes. Many decimal fractions (like 0.1) cannot be represented exactly in either format due to infinite binary expansions — this is a fundamental limitation of floating-point arithmetic regardless of precision. The IEEE 754 standard handles this through rounding to the nearest representable value.

Frequently Asked Questions

What is a floating-point number in computing?

A floating-point number is a data format used to store fractional numbers in computers. The IEEE 754 standard defines how real numbers are represented using sign, exponent, and fraction bits. The most common formats are 32-bit single precision (float) and 64-bit double precision (double), which can encode a wide range of values from very small to very large numbers.

How do you convert binary to a floating-point number?

To convert binary to a floating-point number, split the binary string into three parts: the sign bit (S, 1 bit), the exponent bits (E, 8 bits for 32-bit or 11 bits for 64-bit), and the fraction bits (F, 23 or 52 bits). For normal numbers, the value is (-1)^S × 2^(E-bias) × (1.F). For 32-bit floats the bias is 127, and for 64-bit floats the bias is 1023. Special cases include zero (E=0, F=0), infinity (E=max, F=0), and NaN (E=max, F>0).

What is the difference between 32-bit and 64-bit floating-point?

The 32-bit float uses 8 exponent bits (bias 127) and 23 fraction bits, storing numbers from roughly 1.4×10^-45 to 3.4×10^38 with about 7 decimal digits of precision. The 64-bit float uses 11 exponent bits (bias 1023) and 52 fraction bits, storing numbers from 5×10^-324 to 1.8×10^308 with about 16 decimal digits of precision. Double precision offers higher accuracy but uses twice the memory.

Why can't 0.1 be stored exactly in floating-point?

The number 0.1 cannot be stored exactly in IEEE 754 floating-point because it has an infinite binary expansion (0.0001100110011... in base 2). When stored as a 32-bit float, it rounds to approximately 0.10000000149011611938477 — slightly larger than 0.1. As a 64-bit float, it rounds to 0.10000000000000000555. This precision loss is inherent to floating-point representation and affects many decimal fractions.

What are special cases in IEEE 754 floating-point?

IEEE 754 defines several special cases: ±0 (all exponent and fraction bits zero), ±∞ (all exponent bits 1, fraction bits zero), NaN (Not a Number, all exponent bits 1 with non-zero fraction), and subnormal numbers (exponent bits all zero with non-zero fraction). Subnormal numbers fill the underflow gap around zero, providing gradual underflow instead of abrupt flush-to-zero.

How do you convert a decimal number to IEEE 754 binary?

To convert a decimal to IEEE 754, first determine the sign bit (0 for positive, 1 for negative). Then convert the absolute value to binary and normalize it to scientific notation (1.xxx × 2^exp). For single precision, add the bias 127 to the exponent and convert to 8 bits. The fraction bits are the binary digits after the decimal point, padded to 23 bits. Double precision uses bias 1023 and 11 exponent bits.

What is a subnormal floating-point number?

A subnormal (or denormal) number in IEEE 754 occurs when the exponent bits are all zero but the fraction bits are non-zero. Instead of the usual implicit leading 1, subnormals use an implicit leading 0, allowing representation of numbers closer to zero. For 32-bit floats, subnormals represent values from approximately 1.4×10^-45 to 1.2×10^-38. They provide gradual underflow at the cost of reduced precision.

What is FLOPS in computing?

FLOPS stands for Floating-Point Operations Per Second. It is a measure of computer performance used in scientific computing and benchmarks. Modern GPUs can achieve teraFLOPS (10^12) or petaFLOPS (10^15), while the fastest supercomputers exceed exaFLOPS (10^18). The metric reflects how many floating-point arithmetic operations a system can perform each second.