Improve the performance of our rounding step

.drone.jsonnet

@@ -290,134 +290,134 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     linux_pipeline(
         "Linux 18.04 Clang 6.0",
         "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '14,17' },
         "clang-6.0",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 7",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '14,17' },
         "clang-7",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 8",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '14,17' },
         "clang-8",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 9",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '14,17,2a' },
         "clang-9",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 10",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '14,17,2a' },
         "clang-10",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 11",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '14,17,2a' },
         "clang-11",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 12",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '14,17,2a' },
         "clang-12",
     ),
 
     linux_pipeline(
         "Linux 22.04 Clang 13",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '14,17,20' },
         "clang-13",
     ),
 
     linux_pipeline(
         "Linux 22.04 Clang 14",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '14,17,20,2b' },
         "clang-14",
     ),
 
     linux_pipeline(
         "Linux 22.04 Clang 15",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '14,17,20,2b' },
         "clang-15",
         ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"],
     ),
 
     linux_pipeline(
         "Linux 22.04 Clang 16",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '17,20,2b' },
         "clang-16",
         ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"],
     ),
 
     linux_pipeline(
         "Linux 24.04 Clang 17",
         "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '17,20,2b' },
         "clang-17",
         ["deb http://apt.llvm.org/noble/ llvm-toolchain-noble-17 main"],
     ),
 
     linux_pipeline(
         "Linux 24.04 Clang 18",
         "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '17,20,2b' },
         "clang-18",
         ["deb http://apt.llvm.org/noble/ llvm-toolchain-noble-18 main"],
     ),
 
     linux_pipeline(
         "Linux 24.04 Clang 19",
         "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '17,20,2b' },
         "clang-19",
         ["deb http://apt.llvm.org/noble/ llvm-toolchain-noble-19 main"],
     ),
 
     linux_pipeline(
         "Linux 24.04 Clang 20",
         "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '17,20,2b' },
         "clang-20",
         ["deb http://apt.llvm.org/noble/ llvm-toolchain-noble-20 main"],
     ),
 
     linux_pipeline(
         "Linux 24.04 Clang 21",
         "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '17,20,2b' },
         "clang-21",
         ["deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"],
     ),
 
     linux_pipeline(
         "Linux 24.04 Clang 21 UBSAN",
         "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '14,17,20,2b' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '17,20,2b' } + ubsan,
         "clang-21",
         ["deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"],
     ),
 
     linux_pipeline(
         "Linux 24.04 Clang 21 ASAN",
         "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '14,17,20,2b' } + asan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '17,20,2b' } + asan,
         "clang-21",
         ["deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"],
     ),

include/boost/decimal/decimal_fast128_t.hpp

@@ -541,9 +541,19 @@ constexpr decimal_fast128_t::decimal_fast128_t(T1 coeff, T2 exp, const detail::c
         return;
     }
 
-    // Normalize the significand in the constructor, so we don't have
-    // to calculate the number of digits for operations
-    detail::normalize<decimal_fast128_t>(min_coeff, exp, is_negative);
+    // Fast path: if the coefficient already has exactly precision-many digits,
+    // normalize is a no-op apart from a num_digits call. Skip the call entirely.
+    constexpr minimum_coefficient_size min_normal_significand {
+        detail::pow10(static_cast<minimum_coefficient_size>(detail::precision_v<decimal_fast128_t> - 1))};
+    constexpr minimum_coefficient_size max_normal_significand {
+        static_cast<minimum_coefficient_size>(detail::max_significand_v<decimal_fast128_t>)};
+
+    if (min_coeff < min_normal_significand || min_coeff > max_normal_significand)
+    {
+        // Normalize the significand in the constructor, so we don't have
+        // to calculate the number of digits for operations
+        detail::normalize<decimal_fast128_t>(min_coeff, exp, is_negative);
+    }
 
     significand_ = static_cast<significand_type>(min_coeff);
 

include/boost/decimal/decimal_fast32_t.hpp

@@ -535,8 +535,18 @@ constexpr decimal_fast32_t::decimal_fast32_t(T1 coeff, T2 exp, const detail::con
         return;
     }
 
-    // Normalize in the constructor, so we never have to worry about it again
-    detail::normalize<decimal_fast32_t>(min_coeff, exp, is_negative);
+    // Fast path: if the coefficient already has exactly precision-many digits,
+    // normalize is a no-op apart from a num_digits call. Skip the call entirely.
+    constexpr minimum_coefficient_size min_normal_significand {
+        detail::pow10(static_cast<minimum_coefficient_size>(detail::precision_v<decimal_fast32_t> - 1))};
+    constexpr minimum_coefficient_size max_normal_significand {
+        static_cast<minimum_coefficient_size>(detail::max_significand_v<decimal_fast32_t>)};
+
+    if (min_coeff < min_normal_significand || min_coeff > max_normal_significand)
+    {
+        // Normalize in the constructor, so we never have to worry about it again
+        detail::normalize<decimal_fast32_t>(min_coeff, exp, is_negative);
+    }
 
     significand_ = static_cast<significand_type>(min_coeff);
 

include/boost/decimal/decimal_fast64_t.hpp

@@ -544,8 +544,18 @@ constexpr decimal_fast64_t::decimal_fast64_t(T1 coeff, T2 exp, const detail::con
         return;
     }
 
-    // Normalize the value, so we don't have to worry about it with operations
-    detail::normalize<decimal_fast64_t>(min_coeff, exp, is_negative);
+    // Fast path: if the coefficient already has exactly precision-many digits,
+    // normalize is a no-op apart from a num_digits call. Skip the call entirely.
+    constexpr minimum_coefficient_size min_normal_significand {
+        detail::pow10(static_cast<minimum_coefficient_size>(detail::precision_v<decimal_fast64_t> - 1))};
+    constexpr minimum_coefficient_size max_normal_significand {
+        static_cast<minimum_coefficient_size>(detail::max_significand_v<decimal_fast64_t>)};
+
+    if (min_coeff < min_normal_significand || min_coeff > max_normal_significand)
+    {
+        // Normalize the value, so we don't have to worry about it with operations
+        detail::normalize<decimal_fast64_t>(min_coeff, exp, is_negative);
+    }
 
     significand_ = static_cast<significand_type>(min_coeff);
 

include/boost/decimal/detail/cmath/impl/sqrt128_impl.hpp

@@ -80,8 +80,8 @@ constexpr auto sqrt128_impl(T x, int exp10val) noexcept -> T
     // ---------- Compute initial sig_z = sig_gx * r / 10^16 ----------
     // sig_z ≈ sqrt(gx) * 10^33
     // sig_z = sig_gx * r_scaled / 10^16
-    // r_scaled is 64-bit; use mul128By64 (SoftFloat-style) instead of full umul256
-    u256 sig_z = mul128By64(gx_sig, r_scaled) / scale16;
+    // r_scaled is 64-bit; use mul128_by_64 (SoftFloat-style) instead of full umul256
+    u256 sig_z = mul128_by_64(gx_sig, r_scaled) / scale16;
 
     // Precompute target = sig_gx * 10^33 (avoids recomputing in each Newton iteration)
     const u256 target = umul256(gx_sig, scale33_128);