浮点数二进制加减为何调整小指数匹配大指数而非反向？

Great question! While manual calculations might make both approaches seem interchangeable, in fixed-size binary floating-point systems (like the ubiquitous IEEE 754 standard), adjusting the smaller exponent to align with the larger one is non-negotiable for preserving precision and avoiding catastrophic errors. Let’s break down the key reasons:

• Avoids catastrophic information loss/overflow
  If we instead adjusted the larger exponent down to match the smaller one, we’d have to scale its corresponding mantissa up (multiply by (2^{\Delta E}), where (\Delta E) is the exponent difference) by left-shifting its bits. Since floating-point mantissas have a fixed number of bits (e.g., 23 explicit bits plus an implicit leading 1 for IEEE 754 single-precision), left-shifting can easily push high-order bits beyond the mantissa’s storage limit. These bits get discarded, which doesn’t just lose precision—it can completely distort the original value.
  For example: Take (1.0001_2 \times 2^{10}) (a large-exponent value) and (1.1111_2 \times 2^2) (small-exponent value). If we drop the large exponent to 2, we need to left-shift its mantissa by 8 bits, turning (1.0001_2) into (100010000_2). If our mantissa only holds 5 bits, we’re forced to truncate to (10001_2)—turning the original value of ~1088 into 68, a massive, unrecoverable error.

• Minimizes precision loss
  When we adjust the smaller exponent upward, we scale its mantissa down (divide by (2^{\Delta E})) by right-shifting. This discards only the least significant bits of the mantissa, which have the smallest impact on the overall value. The error introduced is limited to the lower end of the number’s precision, rather than wiping out critical high-order digits.
  Using the same example: Right-shifting the small exponent’s mantissa by 8 bits turns (1.1111_2) into (0.000011111_2). Even if we truncate to 5 bits, we get (0.00001_2)—the original value of ~7.75 becomes 4, which is an error, but nowhere near the magnitude of the error from the reverse approach.

• Aligns with floating-point normalization rules
  Floating-point formats require results to be normalized (a leading 1 before the binary point for normalized numbers). Adjusting the smaller exponent upward fits naturally with this process: after adding the mantissas, we only need to handle possible overflow from the addition (which requires a single left-shift and exponent increment), rather than dealing with the mess of a denormalized large value from downward exponent adjustment.

In short, manual calculations let us use arbitrary-precision mantissas, so we don’t hit these limits—but computers rely on fixed-size storage, and aligning smaller exponents upward is the only way to keep floating-point addition accurate and predictable.

内容的提问来源于stack exchange，提问作者Drummy