Rust 1.98 adds algebraic floating-point methods for compiler optimizations

Rust 1.98 introduces algebraic methods for floating-point types (f32 and f64) that let the compiler apply optimizations based on mathematical properties of real numbers. These methods, covering addition, subtraction, multiplication, division, and remainder, permit operation reordering and loop vectorization, which were previously blocked by strict floating-point semantics. The change mirrors optimizations enabled by flags like -ffast-math in other languages but requires explicit adoption via the new methods.

The performance impact depends on the compiler’s ability to exploit these freedoms. For example, expressions like `a + b + c + d` must retain left-associative evaluation under standard floating-point rules, but rewriting them with `algebraic_add` allows parallel partial-sum evaluation. However, these optimizations may introduce small numerical discrepancies, so developers must weigh speed against precision for their use case. The Rust team intentionally leaves the exact optimizations unspecified, meaning behavior could vary across compiler versions or targets.

Beyond floating-point changes, Rust 1.98 stabilizes several APIs that reduce runtime overhead. The `format_into` method for integers uses a pre-allocated `NumBuffer` to avoid dynamic allocations during formatting, which is useful for high-throughput logging or serialization. String handling also improves with new UTF-16 conversion helpers (`from_utf16le`, `from_utf16be`) and `strip_circumfix`, simplifying parsing tasks. These additions follow Rust’s pattern of stabilizing functionality only after extensive testing in nightly releases.

The update also clarifies undefined behavior around `ManuallyDrop<Box<_>>`. Previously, moving a `ManuallyDrop` after explicitly dropping its contained `Box` could trigger undefined behavior due to a compiler issue, which was fixed in Rust 1.96. Rust 1.98 updates documentation to guarantee this pattern is safe, reducing footguns for low-level memory management. While not a breaking change, this clarification helps developers write more robust unsafe code by removing ambiguity in edge cases.