the floating-point unit (FPU)
/ FPU = eff-pee-you /
Integers are great for counting, but a lot of computing needs fractions and a huge range of magnitudes — from the distance between galaxies to the size of an atom. Floating point stores such numbers as a sign, a significand (the meaningful digits), and an exponent (where the binary point sits), much like scientific notation: 6.02 times 10^23. The floating-point unit, or FPU, is the dedicated hardware that does arithmetic on these three-part numbers, separate from the integer ALU because the steps are quite different.
Take floating-point addition to see why it needs its own machine. To add 1.5 times 2^3 and 1.0 times 2^1 you cannot just add the significands — their binary points are in different places. The FPU must: (1) compare exponents and shift the smaller number's significand right to align the binary points; (2) add the now-aligned significands with an integer adder; (3) normalize the result so the leading 1 is back in its standard position, adjusting the exponent; and (4) round the significand back to the available bits. Multiplication is in some ways simpler (multiply significands, add exponents) but still needs normalize and round. So an FPU bundles shifters, an integer adder, a multiplier, leading-zero counters for normalization, and rounding logic.
Because all this is more work than an integer op, FPUs are pipelined for throughput and operate to the IEEE-754 standard so the same program gives the same bit-exact answers across machines. The honest reality is that floating point is an approximation: most real numbers cannot be represented exactly, so every operation may round, and that rounding is the root of floating point's famous surprises — including the loss of associativity, where (a + b) + c can differ from a + (b + c).
Adding 1.5 (1.1 x 2^0 in binary) and 0.25 (1.0 x 2^-2): align by shifting 0.25's significand right 2 places to share exponent 0, add to get 1.11 x 2^0 = 1.75, which is already normalized and needs no rounding here.
Align exponents, add significands, normalize, round — four steps, not one.
An FPU computes approximations, not exact reals. Following IEEE-754 makes results reproducible across machines, but it does not make them mathematically exact — rounding still happens, and floating-point addition is not associative.