Merge pull request #739 from cppalliance/simplify_bid

mborland · web-flow · commit 1b49d859a545 · 2024-09-30T14:14:38.000-04:00
Reduce language requirement for constexpr BID conversions
diff --git a/doc/decimal/conversions.adoc b/doc/decimal/conversions.adoc
@@ -29,27 +29,54 @@ struct uint128
 
 // ----- BID Conversions -----
 
-BOOST_DECIMAL_CXX20_CONSTEXPR std::uint32_t to_bid_d32(decimal32 val) noexcept;
+constexpr std::uint32_t to_bid_d32(decimal32 val) noexcept;
 
-BOOST_DECIMAL_CXX20_CONSTEXPR std::uint32_t to_bid_d32f(decimal32_fast val) noexcept;
+constexpr decimal32 from_bid_d32(std::uint32_t bits) noexcept;
 
-BOOST_DECIMAL_CXX20_CONSTEXPR std::uint64_t to_bid_d64(decimal64 val) noexcept;
+constexpr std::uint32_t to_bid_d32f(decimal32_fast val) noexcept;
 
-BOOST_DECIMAL_CXX20_CONSTEXPR std::uint64_t to_bid_d64f(decimal64_fast val) noexcept;
+constexpr decimal32_fast from_bid_d32f(std::uint32_t bits) noexcept;
 
-BOOST_DECIMAL_CXX20_CONSTEXPR detail::uint128 to_bid_d128(decimal128 val) noexcept;
+constexpr std::uint64_t to_bid_d64(decimal64 val) noexcept;
+
+constexpr decimal64 from_bid_d64(std::uint64_t bits) noexcept;
+
+constexpr std::uint64_t to_bid_d64f(decimal64_fast val) noexcept;
+
+constexpr decimal64_fast from_bid_d64f(std::uint64_t bits) noexcept;
+
+constexpr detail::uint128 to_bid_d128(decimal128 val) noexcept;
+
+constexpr decimal128 from_bid_d128(detail::uint128 bits) noexcept;
+
+// Automatic detection if your platform has built-in unsigned __int128 or not to enable/disable the overload
+#ifdef BOOST_DECIMAL_HAS_INT128
+
+constexpr decimal128 from_bid_d128(unsigned __int128 bits) noexcept;
+
+#endif // BOOST_DECIMAL_HAS_INT128
+
+constexpr detail::uint128 to_bid_d128f(decimal128_fast val) noexcept;
+
+constexpr decimal128 from_bid_d128f(detail::uint128 bits) noexcept;
+
+#ifdef BOOST_DECIMAL_HAS_INT128
+
+constexpr decimal128 from_bid_d128f(unsigned __int128 bits) noexcept;
+
+#endif // BOOST_DECIMAL_HAS_INT128
 
 template <typename T>
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(T val) noexcept;
+constexpr auto to_bid(T val) noexcept;
 
 template <typename T = decimal32_fast>
-BOOST_DECIMAL_CXX20_CONSTEXPR T from_bid(std::uint32_t bits) noexcept;
+constexpr T from_bid(std::uint32_t bits) noexcept;
 
 template <typename T = decimal64_fast>
-BOOST_DECIMAL_CXX20_CONSTEXPR T from_bid(std::uint64_t bits) noexcept;
+constexpr T from_bid(std::uint64_t bits) noexcept;
 
 template <typename T = decimal128>
-BOOST_DECIMAL_CXX20_CONSTEXPR T from_bid(detail::uint128 bits) noexcept;
+constexpr T from_bid(detail::uint128 bits) noexcept;
 
 // ----- DPD Conversions -----
 
diff --git a/include/boost/decimal/bid_conversion.hpp b/include/boost/decimal/bid_conversion.hpp
@@ -20,149 +20,162 @@ namespace decimal {
 #  pragma GCC diagnostic ignored "-Wconversion"
 #endif
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d32(decimal32 val) noexcept -> std::uint32_t
+constexpr auto to_bid_d32(decimal32 val) noexcept -> std::uint32_t
 {
-    const auto bits {detail::bit_cast<std::uint32_t>(val)};
-    return bits;
+    return val.bits_;
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d32(std::uint32_t bits) noexcept -> decimal32
+constexpr auto from_bid_d32(std::uint32_t bits) noexcept -> decimal32
 {
-    const auto val {detail::bit_cast<decimal32>(bits)};
-    return val;
+    return from_bits(bits);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d32f(decimal32_fast val) noexcept -> std::uint32_t
+constexpr auto to_bid_d32f(decimal32_fast val) noexcept -> std::uint32_t
 {
     const decimal32 compliant_val {val};
-    const auto bits {detail::bit_cast<std::uint32_t>(compliant_val)};
-    return bits;
+    return to_bid_d32(compliant_val);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d32f(std::uint32_t bits) noexcept -> decimal32_fast
+constexpr auto from_bid_d32f(std::uint32_t bits) noexcept -> decimal32_fast
 {
-    const auto compliant_val {detail::bit_cast<decimal32>(bits)};
+    const auto compliant_val {from_bid_d32(bits)};
     const decimal32_fast val {compliant_val};
     return val;
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d64(decimal64 val) noexcept -> std::uint64_t
+constexpr auto to_bid_d64(decimal64 val) noexcept -> std::uint64_t
 {
-    const auto bits {detail::bit_cast<std::uint64_t>(val)};
-    return bits;
+    return val.bits_;
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d64(std::uint64_t bits) noexcept -> decimal64
+constexpr auto from_bid_d64(std::uint64_t bits) noexcept -> decimal64
 {
-    const auto val {detail::bit_cast<decimal64>(bits)};
-    return val;
+    return from_bits(bits);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d64f(decimal64_fast val) noexcept -> std::uint64_t
+constexpr auto to_bid_d64f(decimal64_fast val) noexcept -> std::uint64_t
 {
     const decimal64 compliant_val {val};
-    const auto bits {detail::bit_cast<std::uint64_t>(compliant_val)};
-    return bits;
+    return to_bid_d64(compliant_val);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d64f(std::uint64_t bits) noexcept -> decimal64_fast
+constexpr auto from_bid_d64f(std::uint64_t bits) noexcept -> decimal64_fast
 {
-    const auto compliant_val {detail::bit_cast<decimal64>(bits)};
+    const auto compliant_val {from_bid_d64(bits)};
     const decimal64_fast val {compliant_val};
     return val;
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d128(decimal128 val) noexcept -> detail::uint128
+constexpr auto to_bid_d128(decimal128 val) noexcept -> detail::uint128
 {
-    const auto bits {detail::bit_cast<detail::uint128>(val)};
-    return bits;
+    return val.bits_;
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d128(detail::uint128 bits) noexcept -> decimal128
+constexpr auto from_bid_d128(detail::uint128 bits) noexcept -> decimal128
 {
-    const auto val {detail::bit_cast<decimal128>(bits)};
-    return val;
+    return from_bits(bits);
+}
+
+#ifdef BOOST_DECIMAL_HAS_INT128
+constexpr auto from_bits_d128(detail::uint128_t bits) noexcept -> decimal128
+{
+    return from_bits(bits);
 }
+#endif
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d128f(decimal128_fast val) noexcept -> detail::uint128
+constexpr auto to_bid_d128f(decimal128_fast val) noexcept -> detail::uint128
 {
     const decimal128 compliant_val {val};
-    const auto bits {detail::bit_cast<detail::uint128>(compliant_val)};
-    return bits;
+    return to_bid_d128(compliant_val);
+}
+
+constexpr auto from_bid_d128f(detail::uint128 bits) noexcept -> decimal128_fast
+{
+    const auto compliant_val {from_bid_d128(bits)};
+    const decimal128_fast val {compliant_val};
+    return val;
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d128f(detail::uint128 bits) noexcept -> decimal128_fast
+#ifdef BOOST_DECIMAL_HAS_INT128
+constexpr auto from_bid_d128f(detail::uint128_t bits) noexcept -> decimal128_fast
 {
-    const auto compliant_val {detail::bit_cast<decimal128>(bits)};
+    const auto compliant_val {from_bid_d128(bits)};
     const decimal128_fast val {compliant_val};
     return val;
 }
+#endif
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal32 val) noexcept -> std::uint32_t
+constexpr auto to_bid(decimal32 val) noexcept -> std::uint32_t
 {
     return to_bid_d32(val);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal32_fast val) noexcept -> std::uint32_t
+constexpr auto to_bid(decimal32_fast val) noexcept -> std::uint32_t
 {
     return to_bid_d32f(val);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal64 val) noexcept -> std::uint64_t
+constexpr auto to_bid(decimal64 val) noexcept -> std::uint64_t
 {
     return to_bid_d64(val);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal64_fast val) noexcept -> std::uint64_t
+constexpr auto to_bid(decimal64_fast val) noexcept -> std::uint64_t
 {
     return to_bid_d64f(val);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal128 val) noexcept -> detail::uint128
+constexpr auto to_bid(decimal128 val) noexcept -> detail::uint128
 {
     return to_bid_d128(val);
 }
 
-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal128_fast val) noexcept -> detail::uint128
+constexpr auto to_bid(decimal128_fast val) noexcept -> detail::uint128
 {
     return to_bid_d128f(val);
 }
 
+template <typename T>
+constexpr auto to_bid(T val) noexcept
+{
+    return to_bid(val);
+}
+
 template <typename T = decimal32_fast>
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid(std::uint32_t bits) noexcept
+constexpr auto from_bid(std::uint32_t bits) noexcept
     BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T)
 {
     return from_bid_d32f(bits);
 }
 
 template <>
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid<decimal32>(std::uint32_t bits) noexcept -> decimal32
+constexpr auto from_bid<decimal32>(std::uint32_t bits) noexcept -> decimal32
 {
     return from_bid_d32(bits);
 }
 
 template <typename T = decimal64_fast>
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid(std::uint64_t bits) noexcept
+constexpr auto from_bid(std::uint64_t bits) noexcept
     BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T)
 {
     return from_bid_d64f(bits);
 }
 
 template <>
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid<decimal64>(std::uint64_t bits) noexcept -> decimal64
+constexpr auto from_bid<decimal64>(std::uint64_t bits) noexcept -> decimal64
 {
     return from_bid_d64(bits);
 }
 
 template <typename T = decimal128_fast>
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid(detail::uint128 bits) noexcept
+constexpr auto from_bid(detail::uint128 bits) noexcept
     BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T)
 {
     return from_bid_d128f(bits);
 }
 
 template <>
-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid<decimal128>(detail::uint128 bits) noexcept -> decimal128
+constexpr auto from_bid<decimal128>(detail::uint128 bits) noexcept -> decimal128
 {
     return from_bid_d128(bits);
 }
diff --git a/include/boost/decimal/decimal128.hpp b/include/boost/decimal/decimal128.hpp
@@ -228,6 +228,14 @@ BOOST_DECIMAL_EXPORT class decimal128 final
 
     friend constexpr auto not_finite(decimal128 rhs) noexcept -> bool;
 
+    friend constexpr auto to_bid_d128(decimal128 val) noexcept -> detail::uint128;
+
+    friend constexpr auto from_bid_d128(detail::uint128 bits) noexcept -> decimal128;
+
+    #ifdef BOOST_DECIMAL_HAS_INT128
+    friend constexpr auto from_bid_d128(detail::uint128_t bits) noexcept -> decimal128;
+    #endif
+
 public:
     // 3.2.4.1 construct/copy/destroy
     constexpr decimal128() noexcept = default;
diff --git a/include/boost/decimal/decimal32.hpp b/include/boost/decimal/decimal32.hpp
@@ -218,6 +218,10 @@ BOOST_DECIMAL_EXPORT class decimal32 final // NOLINT(cppcoreguidelines-special-m
     template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE DecimalType>
     friend constexpr auto sequential_less_impl(DecimalType lhs, DecimalType rhs) noexcept -> bool;
 
+    friend constexpr auto to_bid_d32(decimal32 val) noexcept -> std::uint32_t;
+
+    friend constexpr auto from_bid_d32(std::uint32_t bits) noexcept -> decimal32;
+
     template <typename DecimalType>
     friend constexpr auto to_dpd_d32(DecimalType val) noexcept
     BOOST_DECIMAL_REQUIRES_RETURN(detail::is_decimal_floating_point_v, DecimalType, std::uint32_t);
diff --git a/include/boost/decimal/decimal64.hpp b/include/boost/decimal/decimal64.hpp
@@ -225,6 +225,10 @@ BOOST_DECIMAL_EXPORT class decimal64 final
     template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE DecimalType>
     friend constexpr auto sequential_less_impl(DecimalType lhs, DecimalType rhs) noexcept -> bool;
 
+    friend constexpr auto to_bid_d64(decimal64 val) noexcept -> std::uint64_t;
+
+    friend constexpr auto from_bid_d64(std::uint64_t bits) noexcept -> decimal64;
+
 public:
     // 3.2.3.1 construct/copy/destroy
     constexpr decimal64() noexcept = default;
diff --git a/test/test_bid_conversions.cpp b/test/test_bid_conversions.cpp
@@ -18,7 +18,7 @@ void test()
     for (std::size_t i {}; i < 1024; ++i)
     {
         const T val {dist(rng)};
-        const auto bits {to_bid(val)};
+        const auto bits {to_bid<T>(val)};
         const T return_val {from_bid<T>(bits)};
         BOOST_TEST_EQ(val, return_val);
     }

Original file line number	Diff line number	Diff line change
`@@ -20,149 +20,162 @@ namespace decimal {`
`20`	`20`	`# pragma GCC diagnostic ignored "-Wconversion"`
`21`	`21`	`#endif`
`22`	`22`
`23`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d32(decimal32 val) noexcept -> std::uint32_t`
	`23`	`+constexpr auto to_bid_d32(decimal32 val) noexcept -> std::uint32_t`
`24`	`24`	`{`
`25`		`- const auto bits {detail::bit_cast<std::uint32_t>(val)};`
`26`		`- return bits;`
	`25`	`+ return val.bits_;`
`27`	`26`	`}`
`28`	`27`
`29`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d32(std::uint32_t bits) noexcept -> decimal32`
	`28`	`+constexpr auto from_bid_d32(std::uint32_t bits) noexcept -> decimal32`
`30`	`29`	`{`
`31`		`- const auto val {detail::bit_cast<decimal32>(bits)};`
`32`		`- return val;`
	`30`	`+ return from_bits(bits);`
`33`	`31`	`}`
`34`	`32`
`35`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d32f(decimal32_fast val) noexcept -> std::uint32_t`
	`33`	`+constexpr auto to_bid_d32f(decimal32_fast val) noexcept -> std::uint32_t`
`36`	`34`	`{`
`37`	`35`	`const decimal32 compliant_val {val};`
`38`		`- const auto bits {detail::bit_cast<std::uint32_t>(compliant_val)};`
`39`		`- return bits;`
	`36`	`+ return to_bid_d32(compliant_val);`
`40`	`37`	`}`
`41`	`38`
`42`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d32f(std::uint32_t bits) noexcept -> decimal32_fast`
	`39`	`+constexpr auto from_bid_d32f(std::uint32_t bits) noexcept -> decimal32_fast`
`43`	`40`	`{`
`44`		`- const auto compliant_val {detail::bit_cast<decimal32>(bits)};`
	`41`	`+ const auto compliant_val {from_bid_d32(bits)};`
`45`	`42`	`const decimal32_fast val {compliant_val};`
`46`	`43`	`return val;`
`47`	`44`	`}`
`48`	`45`
`49`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d64(decimal64 val) noexcept -> std::uint64_t`
	`46`	`+constexpr auto to_bid_d64(decimal64 val) noexcept -> std::uint64_t`
`50`	`47`	`{`
`51`		`- const auto bits {detail::bit_cast<std::uint64_t>(val)};`
`52`		`- return bits;`
	`48`	`+ return val.bits_;`
`53`	`49`	`}`
`54`	`50`
`55`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d64(std::uint64_t bits) noexcept -> decimal64`
	`51`	`+constexpr auto from_bid_d64(std::uint64_t bits) noexcept -> decimal64`
`56`	`52`	`{`
`57`		`- const auto val {detail::bit_cast<decimal64>(bits)};`
`58`		`- return val;`
	`53`	`+ return from_bits(bits);`
`59`	`54`	`}`
`60`	`55`
`61`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d64f(decimal64_fast val) noexcept -> std::uint64_t`
	`56`	`+constexpr auto to_bid_d64f(decimal64_fast val) noexcept -> std::uint64_t`
`62`	`57`	`{`
`63`	`58`	`const decimal64 compliant_val {val};`
`64`		`- const auto bits {detail::bit_cast<std::uint64_t>(compliant_val)};`
`65`		`- return bits;`
	`59`	`+ return to_bid_d64(compliant_val);`
`66`	`60`	`}`
`67`	`61`
`68`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d64f(std::uint64_t bits) noexcept -> decimal64_fast`
	`62`	`+constexpr auto from_bid_d64f(std::uint64_t bits) noexcept -> decimal64_fast`
`69`	`63`	`{`
`70`		`- const auto compliant_val {detail::bit_cast<decimal64>(bits)};`
	`64`	`+ const auto compliant_val {from_bid_d64(bits)};`
`71`	`65`	`const decimal64_fast val {compliant_val};`
`72`	`66`	`return val;`
`73`	`67`	`}`
`74`	`68`
`75`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d128(decimal128 val) noexcept -> detail::uint128`
	`69`	`+constexpr auto to_bid_d128(decimal128 val) noexcept -> detail::uint128`
`76`	`70`	`{`
`77`		`- const auto bits {detail::bit_cast<detail::uint128>(val)};`
`78`		`- return bits;`
	`71`	`+ return val.bits_;`
`79`	`72`	`}`
`80`	`73`
`81`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d128(detail::uint128 bits) noexcept -> decimal128`
	`74`	`+constexpr auto from_bid_d128(detail::uint128 bits) noexcept -> decimal128`
`82`	`75`	`{`
`83`		`- const auto val {detail::bit_cast<decimal128>(bits)};`
`84`		`- return val;`
	`76`	`+ return from_bits(bits);`
	`77`	`+}`
	`78`	`+`
	`79`	`+#ifdef BOOST_DECIMAL_HAS_INT128`
	`80`	`+constexpr auto from_bits_d128(detail::uint128_t bits) noexcept -> decimal128`
	`81`	`+{`
	`82`	`+ return from_bits(bits);`
`85`	`83`	`}`
	`84`	`+#endif`
`86`	`85`
`87`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid_d128f(decimal128_fast val) noexcept -> detail::uint128`
	`86`	`+constexpr auto to_bid_d128f(decimal128_fast val) noexcept -> detail::uint128`
`88`	`87`	`{`
`89`	`88`	`const decimal128 compliant_val {val};`
`90`		`- const auto bits {detail::bit_cast<detail::uint128>(compliant_val)};`
`91`		`- return bits;`
	`89`	`+ return to_bid_d128(compliant_val);`
	`90`	`+}`
	`91`	`+`
	`92`	`+constexpr auto from_bid_d128f(detail::uint128 bits) noexcept -> decimal128_fast`
	`93`	`+{`
	`94`	`+ const auto compliant_val {from_bid_d128(bits)};`
	`95`	`+ const decimal128_fast val {compliant_val};`
	`96`	`+ return val;`
`92`	`97`	`}`
`93`	`98`
`94`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid_d128f(detail::uint128 bits) noexcept -> decimal128_fast`
	`99`	`+#ifdef BOOST_DECIMAL_HAS_INT128`
	`100`	`+constexpr auto from_bid_d128f(detail::uint128_t bits) noexcept -> decimal128_fast`
`95`	`101`	`{`
`96`		`- const auto compliant_val {detail::bit_cast<decimal128>(bits)};`
	`102`	`+ const auto compliant_val {from_bid_d128(bits)};`
`97`	`103`	`const decimal128_fast val {compliant_val};`
`98`	`104`	`return val;`
`99`	`105`	`}`
	`106`	`+#endif`
`100`	`107`
`101`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal32 val) noexcept -> std::uint32_t`
	`108`	`+constexpr auto to_bid(decimal32 val) noexcept -> std::uint32_t`
`102`	`109`	`{`
`103`	`110`	`return to_bid_d32(val);`
`104`	`111`	`}`
`105`	`112`
`106`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal32_fast val) noexcept -> std::uint32_t`
	`113`	`+constexpr auto to_bid(decimal32_fast val) noexcept -> std::uint32_t`
`107`	`114`	`{`
`108`	`115`	`return to_bid_d32f(val);`
`109`	`116`	`}`
`110`	`117`
`111`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal64 val) noexcept -> std::uint64_t`
	`118`	`+constexpr auto to_bid(decimal64 val) noexcept -> std::uint64_t`
`112`	`119`	`{`
`113`	`120`	`return to_bid_d64(val);`
`114`	`121`	`}`
`115`	`122`
`116`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal64_fast val) noexcept -> std::uint64_t`
	`123`	`+constexpr auto to_bid(decimal64_fast val) noexcept -> std::uint64_t`
`117`	`124`	`{`
`118`	`125`	`return to_bid_d64f(val);`
`119`	`126`	`}`
`120`	`127`
`121`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal128 val) noexcept -> detail::uint128`
	`128`	`+constexpr auto to_bid(decimal128 val) noexcept -> detail::uint128`
`122`	`129`	`{`
`123`	`130`	`return to_bid_d128(val);`
`124`	`131`	`}`
`125`	`132`
`126`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto to_bid(decimal128_fast val) noexcept -> detail::uint128`
	`133`	`+constexpr auto to_bid(decimal128_fast val) noexcept -> detail::uint128`
`127`	`134`	`{`
`128`	`135`	`return to_bid_d128f(val);`
`129`	`136`	`}`
`130`	`137`
	`138`	`+template <typename T>`
	`139`	`+constexpr auto to_bid(T val) noexcept`
	`140`	`+{`
	`141`	`+ return to_bid(val);`
	`142`	`+}`
	`143`	`+`
`131`	`144`	`template <typename T = decimal32_fast>`
`132`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid(std::uint32_t bits) noexcept`
	`145`	`+constexpr auto from_bid(std::uint32_t bits) noexcept`
`133`	`146`	`BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T)`
`134`	`147`	`{`
`135`	`148`	`return from_bid_d32f(bits);`
`136`	`149`	`}`
`137`	`150`
`138`	`151`	`template <>`
`139`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid<decimal32>(std::uint32_t bits) noexcept -> decimal32`
	`152`	`+constexpr auto from_bid<decimal32>(std::uint32_t bits) noexcept -> decimal32`
`140`	`153`	`{`
`141`	`154`	`return from_bid_d32(bits);`
`142`	`155`	`}`
`143`	`156`
`144`	`157`	`template <typename T = decimal64_fast>`
`145`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid(std::uint64_t bits) noexcept`
	`158`	`+constexpr auto from_bid(std::uint64_t bits) noexcept`
`146`	`159`	`BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T)`
`147`	`160`	`{`
`148`	`161`	`return from_bid_d64f(bits);`
`149`	`162`	`}`
`150`	`163`
`151`	`164`	`template <>`
`152`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid<decimal64>(std::uint64_t bits) noexcept -> decimal64`
	`165`	`+constexpr auto from_bid<decimal64>(std::uint64_t bits) noexcept -> decimal64`
`153`	`166`	`{`
`154`	`167`	`return from_bid_d64(bits);`
`155`	`168`	`}`
`156`	`169`
`157`	`170`	`template <typename T = decimal128_fast>`
`158`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid(detail::uint128 bits) noexcept`
	`171`	`+constexpr auto from_bid(detail::uint128 bits) noexcept`
`159`	`172`	`BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T)`
`160`	`173`	`{`
`161`	`174`	`return from_bid_d128f(bits);`
`162`	`175`	`}`
`163`	`176`
`164`	`177`	`template <>`
`165`		`-BOOST_DECIMAL_CXX20_CONSTEXPR auto from_bid<decimal128>(detail::uint128 bits) noexcept -> decimal128`
	`178`	`+constexpr auto from_bid<decimal128>(detail::uint128 bits) noexcept -> decimal128`
`166`	`179`	`{`
`167`	`180`	`return from_bid_d128(bits);`
`168`	`181`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ void test()`
`18`	`18`	`for (std::size_t i {}; i < 1024; ++i)`
`19`	`19`	`{`
`20`	`20`	`const T val {dist(rng)};`
`21`		`- const auto bits {to_bid(val)};`
	`21`	`+ const auto bits {to_bid<T>(val)};`
`22`	`22`	`const T return_val {from_bid<T>(bits)};`
`23`	`23`	`BOOST_TEST_EQ(val, return_val);`
`24`	`24`	`}`