Computers store real numbers in a fixed number of bits, so they cannot store every real number exactly. Floating point is the scheme that packs a huge range of magnitudes into 32 or 64 bits by trading away some precision, and IEEE 754 is the standard almost every processor follows. This topic is a dependable source of encoding and precision questions, and every one of them rests on the same field layout and normalization rule. Let us encode a number by hand and see exactly where the bits go.
Fixed point vs floating point
A fixed-point representation puts the binary point at a fixed position, so many bits go to the integer part and the rest to the fraction. It is simple and fast, but its range is narrow: with the point fixed you cannot represent both very large and very small numbers in the same format.
Floating point instead stores a number as a sign, a fraction, and an exponent, much like scientific notation. Moving the exponent slides the binary point, so the same number of bits covers magnitudes from the tiny to the astronomical. The price is that precision is now relative, not absolute: large numbers are spaced further apart than small ones.
The IEEE 754 fields
IEEE 754 lays out a floating-point number in three fields, in order from the most significant bit.
Sign (1 bit): 0 for positive, 1 for negative.
Exponent, stored with a bias so it can represent negative exponents without a separate sign.
Mantissa, also called the fraction or significand, holding the digits after the leading 1.
The two common precisions divide the bits like this:
Precision | Total bits | Sign | Exponent | Mantissa | Bias |
|---|---|---|---|---|---|
Single | 32 | 1 | 8 | 23 | 127 |
Double | 64 | 1 | 11 | 52 | 1023 |
The bias is what lets a small unsigned exponent field encode a range of positive and negative actual exponents: you store the true exponent plus the bias, and subtract the bias to read it back.
Normalization and the hidden bit
Before storing, the number is normalized to the form 1.fffff times 2 to some power, with exactly one non-zero digit before the binary point. In binary that leading digit is always 1, so IEEE 754 does not store it at all. This hidden bit buys one extra bit of precision for free: the 23-bit single-precision mantissa effectively carries 24 bits of significand.
A worked encoding: put a decimal into IEEE 754 single precision
Encode the decimal value -6.75 in single precision.
Sign. The number is negative, so the sign bit is 1.
Convert the magnitude to binary. 6 is 110, and 0.75 is 0.11, so 6.75 is 110.11 in binary.
Normalize. Shift the binary point to leave one 1 before it: 110.11 becomes 1.1011 times 2 to the power 2. The exponent is 2.
Bias the exponent. Stored exponent is 2 plus 127, which is 129, or 10000001 in 8 bits.
Take the mantissa. Drop the hidden leading 1 and keep the digits after the point, 1011, padded with zeros to 23 bits: 10110000000000000000000.
Assembling sign, exponent and mantissa gives the 32-bit word:
1 10000001 10110000000000000000000Grouped into hexadecimal that is C0D80000. Reverse the steps and you get -6.75 back exactly, because 6.75 happens to be a sum of powers of two.
Rounding and the limits of precision
Most decimals are not sums of powers of two, and that is where precision bites. The decimal 0.1 has no finite binary expansion, so IEEE 754 stores the nearest representable value and rounds, which is why `0.1 + 0.2` does not print as exactly `0.3` in most languages. Single precision keeps roughly 7 significant decimal digits and double about 15 to 16. Machine epsilon, the gap between 1 and the next representable single-precision number, is 2 to the power minus 23; the spacing between consecutive representable numbers is not constant but grows with magnitude, as noted earlier. IEEE 754 also reserves exponent patterns for special values: zero, plus and minus infinity, and NaN for undefined results such as zero divided by zero. When the exponent field is all zeros and the mantissa is nonzero the number is subnormal, meaning the hidden bit is treated as 0 instead of 1, which lets the format represent values gradually smaller than the smallest normalized number instead of jumping straight to zero. Double precision exists precisely because single precision's seven digits are too few for scientific and financial computation, where the extra mantissa bits keep rounding error under control.
Where this sits, and what it is not
This is the computer organisation view of how a real number is encoded in hardware. It is distinct from the digital-electronics topic of number systems and integer representation, base conversion, and two's complement, which handles whole numbers and signed integers rather than the sign-exponent-mantissa layout here. If you have studied binary conversion and two's complement, this builds directly on that groundwork, but the exam treats float encoding as its own thing.
How this is tested in GATE
Floating Point Representation carries over 130 published questions in the KnowledgeGate bank, part of the more-than-1,700 computer organisation total. GATE questions typically ask you to encode a given decimal into single or double precision, decode a bit pattern back to a value, count the bits in each field, or reason about precision, such as the smallest representable positive number or why two nearby reals collapse to the same encoding. Every one of these follows from the field layout and the normalize-then-bias procedure above, so the worked example is the method you need.
The short version
Floating point stores sign, biased exponent and mantissa. Normalize to 1.fffff times a power of two, drop the hidden leading 1, add the bias to the exponent, and lay the fields out in order. Hand-encode one number like -6.75 into its 32 bits, and remember that most decimals only round to the nearest representable value. Do that and the encoding and precision questions become routine.
Work the encodings on the floating point representation learn module.
For neighbouring computer organisation topics, read our cache memory mapping and hit ratio and memory hierarchy and virtual memory deep-dives.
The full GATE CS syllabus in order lives in GATE Guidance by Sanchit Sir, and more explainers sit on the CS Fundamentals category.
