Faster floating point math with Rust's new API

3 hours ago

Floating point math is slower than integer math due to compiler conservatism to preserve exact results.
Rust 1.98 introduces algebraic operators (e.g., `algebraic_add`) that allow compiler optimizations for floats.
Pairwise summation with algebraic operators can match or beat NumPy speed while maintaining accuracy.
Algebraic operations enable SIMD optimizations, reducing CPU instructions per value significantly.
Combining strict and algebraic operators in algorithms balances performance and numerical precision.

Modern C++ compilers (like Clang and GCC) can produce optimal code from naive implementations, making many old performance tricks obsolete.
Fast inverse square root, once a clever optimization for old CPUs, is now comparable to naive implementations thanks to compiler and hardware advances.
Standard library features like <bit> for popcount, ranges, and algorithms offer clear, portable code that often matches or beats hand-optimized versions.

Binary search optimization in scikit-learn involves reducing branch mispredictions for speed gains.
Switching from standard binary search to a branchless version eliminates unpredictable if/while branches.
Precomputing halving values and using unsafe Rust for bounds checks further reduces work and branches.

Raw pointer languages (C, C++, unsafe Rust) are hard to optimize due to alias analysis and memory management.
Constrained languages (Haskell, Futhark, SQL) give compilers more optimization freedom through additional structure like referential transparency or declarative semantics.
Examples: Haskell stream fusion reduces nested loops to constant space; Futhark outperforms C on GPU tasks; SQL performance improves over decades via query planning.

The article explores methods to compute π, shifting from historical manual calculations to modern algorithms like Chudnovsky.
John Machin's formula was a key method for centuries, allowing William Shanks to compute π to 707 digits (with errors) in the 1800s.
Infinite series, such as arcsin expansions, provide a mathematical approach but converge very slowly for π calculations.

Static assert allows compile-time checks and self-documenting code.
constexpr enables compile-time computation, improving performance and reducing runtime overhead.
std::numeric_limits provides uniform access to type limits, replacing macros like ULLONG_MAX.

Modern C++ compilers (like Clang and GCC) can produce optimal code from naive implementations, making many old performance tricks obsolete.
Fast inverse square root, once a clever optimization for old CPUs, is now comparable to naive implementations thanks to compiler and hardware advances.
Standard library features like <bit> for popcount, ranges, and algorithms offer clear, portable code that often matches or beats hand-optimized versions.

Binary search optimization in scikit-learn involves reducing branch mispredictions for speed gains.
Switching from standard binary search to a branchless version eliminates unpredictable if/while branches.
Precomputing halving values and using unsafe Rust for bounds checks further reduces work and branches.

Raw pointer languages (C, C++, unsafe Rust) are hard to optimize due to alias analysis and memory management.
Constrained languages (Haskell, Futhark, SQL) give compilers more optimization freedom through additional structure like referential transparency or declarative semantics.
Examples: Haskell stream fusion reduces nested loops to constant space; Futhark outperforms C on GPU tasks; SQL performance improves over decades via query planning.

The article explores methods to compute π, shifting from historical manual calculations to modern algorithms like Chudnovsky.
John Machin's formula was a key method for centuries, allowing William Shanks to compute π to 707 digits (with errors) in the 1800s.
Infinite series, such as arcsin expansions, provide a mathematical approach but converge very slowly for π calculations.

Static assert allows compile-time checks and self-documenting code.
constexpr enables compile-time computation, improving performance and reducing runtime overhead.
std::numeric_limits provides uniform access to type limits, replacing macros like ULLONG_MAX.

Hasty Briefsbeta