Re-name constructor parameter to reduce confusion

mborland · mborland · commit 9bef85e10cd6 · 2025-10-20T16:02:47.000+02:00
diff --git a/include/boost/decimal/decimal128_t.hpp b/include/boost/decimal/decimal128_t.hpp
@@ -262,7 +262,7 @@ BOOST_DECIMAL_EXPORT class decimal128_t final
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal128_t(T1 coeff, T2 exp, bool sign = false) noexcept;
+    constexpr decimal128_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -733,9 +733,9 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool sign) noexcept
+constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool is_negative) noexcept
 {
-    bits_.high = sign ? detail::d128_sign_mask : UINT64_C(0);
+    bits_.high = is_negative ? detail::d128_sign_mask : UINT64_C(0);
 
     // If the coeff is not in range make it so
     // The coefficient needs at least 110 bits so there's a good chance we don't need to
@@ -747,7 +747,7 @@ constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool sign) noexcept
     {
         if (coeff > detail::d128_max_significand_value || biased_exp < 0)
         {
-            coeff_digits = detail::coefficient_rounding<decimal128_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));
+            coeff_digits = detail::coefficient_rounding<decimal128_t>(coeff, exp, biased_exp, is_negative, detail::num_digits(coeff));
         }
     }
 
@@ -786,19 +786,19 @@ constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool sign) noexcept
         {
             exp -= digit_delta;
             reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));
-            *this = decimal128_t(reduced_coeff, exp, sign);
+            *this = decimal128_t(reduced_coeff, exp, is_negative);
         }
         else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision_v<decimal128_t>)
         {
             const auto offset {detail::precision_v<decimal128_t> - coeff_digits};
             exp -= offset;
             reduced_coeff *= detail::pow10(static_cast<significand_type>(offset));
-            *this = decimal128_t(reduced_coeff, exp, sign);
+            *this = decimal128_t(reduced_coeff, exp, is_negative);
         }
         else
         {
             bits_ = exp < 0 ? zero : detail::d128_inf_mask;
-            bits_.high |= sign ? detail::d128_sign_mask : UINT64_C(0);
+            bits_.high |= is_negative ? detail::d128_sign_mask : UINT64_C(0);
         }
     }
 }
diff --git a/include/boost/decimal/decimal32_t.hpp b/include/boost/decimal/decimal32_t.hpp
@@ -288,7 +288,7 @@ BOOST_DECIMAL_EXPORT class decimal32_t final // NOLINT(cppcoreguidelines-special
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal32_t(T1 coeff, T2 exp, bool sign = false) noexcept;
+    constexpr decimal32_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -642,20 +642,20 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool sign) noexcept // NOLINT(readability-function-cognitive-complexity,misc-no-recursion)
+constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool is_negative) noexcept // NOLINT(readability-function-cognitive-complexity,misc-no-recursion)
 {
     static_assert(detail::is_integral_v<T1>, "Coefficient must be an integer");
     static_assert(detail::is_integral_v<T2>, "Exponent must be an integer");
 
-    bits_ = sign ? detail::d32_sign_mask : UINT32_C(0);
+    bits_ = is_negative ? detail::d32_sign_mask : UINT32_C(0);
 
     // If the coeff is not in range, make it so
     // Only count the number of digits if we absolutely have to
     int coeff_digits {-1};
     auto biased_exp {static_cast<int>(exp + detail::bias)};
     if (coeff > detail::d32_max_significand_value || biased_exp < 0)
     {
-        coeff_digits = detail::coefficient_rounding<decimal32_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));
+        coeff_digits = detail::coefficient_rounding<decimal32_t>(coeff, exp, biased_exp, is_negative, detail::num_digits(coeff));
     }
 
     auto reduced_coeff {static_cast<significand_type>(coeff)};
@@ -708,21 +708,21 @@ constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool sign) noexcept // NOLI
         {
             exp -= digit_delta;
             reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));
-            *this = decimal32_t(reduced_coeff, exp, sign);
+            *this = decimal32_t(reduced_coeff, exp, is_negative);
         }
         else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision)
         {
             // We can expand the coefficient to use the maximum number of digits
             const auto offset {detail::precision - coeff_digits};
             exp -= offset;
             reduced_coeff *= detail::pow10(static_cast<significand_type>(offset));
-            *this = decimal32_t(reduced_coeff, exp, sign);
+            *this = decimal32_t(reduced_coeff, exp, is_negative);
         }
         else
         {
             // Reset the value and make sure to preserve the sign of 0/inf
             bits_ = exp < 0 ? UINT32_C(0) : detail::d32_inf_mask;
-            bits_ |= sign ? detail::d32_sign_mask : UINT32_C(0);
+            bits_ |= is_negative ? detail::d32_sign_mask : UINT32_C(0);
         }
     }
 }
diff --git a/include/boost/decimal/decimal64_t.hpp b/include/boost/decimal/decimal64_t.hpp
@@ -325,7 +325,7 @@ BOOST_DECIMAL_EXPORT class decimal64_t final
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal64_t(T1 coeff, T2 exp, bool sign = false) noexcept;
+    constexpr decimal64_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -640,16 +640,16 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool sign) noexcept
+constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool is_negative) noexcept
 {
-    bits_ = sign ? detail::d64_sign_mask : UINT64_C(0);
+    bits_ = is_negative ? detail::d64_sign_mask : UINT64_C(0);
 
     // If the coeff is not in range, make it so
     int coeff_digits {-1};
     auto biased_exp {static_cast<int>(exp) + detail::bias_v<decimal64_t>};
     if (coeff > detail::d64_max_significand_value || biased_exp < 0)
     {
-        coeff_digits = detail::coefficient_rounding<decimal64_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));
+        coeff_digits = detail::coefficient_rounding<decimal64_t>(coeff, exp, biased_exp, is_negative, detail::num_digits(coeff));
     }
 
     auto reduced_coeff {static_cast<significand_type>(coeff)};
@@ -702,20 +702,20 @@ constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool sign) noexcept
         {
             exp -= digit_delta;
             reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));
-            *this = decimal64_t(reduced_coeff, exp, sign);
+            *this = decimal64_t(reduced_coeff, exp, is_negative);
         }
         else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision_v<decimal64_t>)
         {
             const auto offset {detail::precision_v<decimal64_t> - coeff_digits};
             exp -= offset;
             reduced_coeff *= detail::pow10(static_cast<significand_type>(offset));
-            *this = decimal64_t(reduced_coeff, exp, sign);
+            *this = decimal64_t(reduced_coeff, exp, is_negative);
         }
         else
         {
             // Reset the value and make sure to preserve the sign of 0/inf
             bits_ = exp < 0 ? UINT64_C(0) : detail::d64_inf_mask;
-            bits_ |= sign ? detail::d64_sign_mask : UINT64_C(0);
+            bits_ |= is_negative ? detail::d64_sign_mask : UINT64_C(0);
         }
     }
 }
diff --git a/include/boost/decimal/decimal_fast128_t.hpp b/include/boost/decimal/decimal_fast128_t.hpp
@@ -197,7 +197,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast128_t final
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal_fast128_t(T1 coeff, T2 exp, bool sign = false) noexcept;
+    constexpr decimal_fast128_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -471,17 +471,17 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal_fast128_t::decimal_fast128_t(T1 coeff, T2 exp, bool sign) noexcept
+constexpr decimal_fast128_t::decimal_fast128_t(T1 coeff, T2 exp, bool is_negative) noexcept
 {
     using minimum_coefficient_size = std::conditional_t<(sizeof(T1) > sizeof(significand_type)), T1, significand_type>;
 
     minimum_coefficient_size min_coeff {coeff};
 
-    sign_ = sign;
+    sign_ = is_negative;
 
     // 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, sign);
+    detail::normalize<decimal_fast128_t>(min_coeff, exp, is_negative);
 
     significand_ = static_cast<significand_type>(min_coeff);
 
diff --git a/include/boost/decimal/decimal_fast32_t.hpp b/include/boost/decimal/decimal_fast32_t.hpp
@@ -193,7 +193,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast32_t final
     constexpr decimal_fast32_t() noexcept = default;
 
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
-    constexpr decimal_fast32_t(T1 coeff, T2 exp, bool sign = false) noexcept;
+    constexpr decimal_fast32_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
 
     template <typename T1, typename T2, std::enable_if_t<!detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     constexpr decimal_fast32_t(T1, T2, bool) noexcept { static_assert(detail::is_unsigned_v<T1>, "Construction from signed integer, exponent, and sign is ambiguous, so it is disallowed. You must use an Unsigned Integer for the coefficient to construct from {coefficient, exponent, sign}"); }
@@ -461,16 +461,16 @@ BOOST_DECIMAL_EXPORT class decimal_fast32_t final
 };
 
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
-constexpr decimal_fast32_t::decimal_fast32_t(T1 coeff, T2 exp, bool sign) noexcept
+constexpr decimal_fast32_t::decimal_fast32_t(T1 coeff, T2 exp, bool is_negative) noexcept
 {
     using minimum_coefficient_size = std::conditional_t<(sizeof(T1) > sizeof(significand_type)), T1, significand_type>;
 
     minimum_coefficient_size min_coeff {coeff};
 
-    sign_ = sign;
+    sign_ = is_negative;
 
     // Normalize in the constructor, so we never have to worry about it again
-    detail::normalize<decimal_fast32_t>(min_coeff, exp, sign);
+    detail::normalize<decimal_fast32_t>(min_coeff, exp, is_negative);
 
     significand_ = static_cast<significand_type>(min_coeff);
 
diff --git a/include/boost/decimal/decimal_fast64_t.hpp b/include/boost/decimal/decimal_fast64_t.hpp
@@ -204,7 +204,7 @@ BOOST_DECIMAL_EXPORT class decimal_fast64_t final
     #else
     template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>
     #endif
-    constexpr decimal_fast64_t(T1 coeff, T2 exp, bool sign = false) noexcept;
+    constexpr decimal_fast64_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;
 
     #ifdef BOOST_DECIMAL_HAS_CONCEPTS
     template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
@@ -465,16 +465,16 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>
 #else
 template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>
 #endif
-constexpr decimal_fast64_t::decimal_fast64_t(T1 coeff, T2 exp, bool sign) noexcept
+constexpr decimal_fast64_t::decimal_fast64_t(T1 coeff, T2 exp, bool is_negative) noexcept
 {
     using minimum_coefficient_size = std::conditional_t<(sizeof(T1) > sizeof(significand_type)), T1, significand_type>;
 
     minimum_coefficient_size min_coeff {coeff};
 
-    sign_ = sign;
+    sign_ = is_negative;
 
     // Normalize the value, so we don't have to worry about it with operations
-    detail::normalize<decimal_fast64_t>(min_coeff, exp, sign);
+    detail::normalize<decimal_fast64_t>(min_coeff, exp, is_negative);
 
     significand_ = static_cast<significand_type>(min_coeff);
 

Original file line number	Diff line number	Diff line change
`@@ -262,7 +262,7 @@ BOOST_DECIMAL_EXPORT class decimal128_t final`
`262`	`262`	`#else`
`263`	`263`	`template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>`
`264`	`264`	`#endif`
`265`		`- constexpr decimal128_t(T1 coeff, T2 exp, bool sign = false) noexcept;`
	`265`	`+ constexpr decimal128_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;`
`266`	`266`
`267`	`267`	`#ifdef BOOST_DECIMAL_HAS_CONCEPTS`
`268`	`268`	`template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>`
`@@ -733,9 +733,9 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>`
`733`	`733`	`#else`
`734`	`734`	`template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>`
`735`	`735`	`#endif`
`736`		`-constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool sign) noexcept`
	`736`	`+constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool is_negative) noexcept`
`737`	`737`	`{`
`738`		`- bits_.high = sign ? detail::d128_sign_mask : UINT64_C(0);`
	`738`	`+ bits_.high = is_negative ? detail::d128_sign_mask : UINT64_C(0);`
`739`	`739`
`740`	`740`	`// If the coeff is not in range make it so`
`741`	`741`	`// The coefficient needs at least 110 bits so there's a good chance we don't need to`
`@@ -747,7 +747,7 @@ constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool sign) noexcept`
`747`	`747`	`{`
`748`	`748`	`if (coeff > detail::d128_max_significand_value \|\| biased_exp < 0)`
`749`	`749`	`{`
`750`		`- coeff_digits = detail::coefficient_rounding<decimal128_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));`
	`750`	`+ coeff_digits = detail::coefficient_rounding<decimal128_t>(coeff, exp, biased_exp, is_negative, detail::num_digits(coeff));`
`751`	`751`	`}`
`752`	`752`	`}`
`753`	`753`
`@@ -786,19 +786,19 @@ constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool sign) noexcept`
`786`	`786`	`{`
`787`	`787`	`exp -= digit_delta;`
`788`	`788`	`reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));`
`789`		`- *this = decimal128_t(reduced_coeff, exp, sign);`
	`789`	`+ *this = decimal128_t(reduced_coeff, exp, is_negative);`
`790`	`790`	`}`
`791`	`791`	`else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision_v<decimal128_t>)`
`792`	`792`	`{`
`793`	`793`	`const auto offset {detail::precision_v<decimal128_t> - coeff_digits};`
`794`	`794`	`exp -= offset;`
`795`	`795`	`reduced_coeff *= detail::pow10(static_cast<significand_type>(offset));`
`796`		`- *this = decimal128_t(reduced_coeff, exp, sign);`
	`796`	`+ *this = decimal128_t(reduced_coeff, exp, is_negative);`
`797`	`797`	`}`
`798`	`798`	`else`
`799`	`799`	`{`
`800`	`800`	`bits_ = exp < 0 ? zero : detail::d128_inf_mask;`
`801`		`- bits_.high \|= sign ? detail::d128_sign_mask : UINT64_C(0);`
	`801`	`+ bits_.high \|= is_negative ? detail::d128_sign_mask : UINT64_C(0);`
`802`	`802`	`}`
`803`	`803`	`}`
`804`	`804`	`}`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ BOOST_DECIMAL_EXPORT class decimal32_t final // NOLINT(cppcoreguidelines-special`
`288`	`288`	`#else`
`289`	`289`	`template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>`
`290`	`290`	`#endif`
`291`		`- constexpr decimal32_t(T1 coeff, T2 exp, bool sign = false) noexcept;`
	`291`	`+ constexpr decimal32_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;`
`292`	`292`
`293`	`293`	`#ifdef BOOST_DECIMAL_HAS_CONCEPTS`
`294`	`294`	`template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>`
`@@ -642,20 +642,20 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>`
`642`	`642`	`#else`
`643`	`643`	`template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>`
`644`	`644`	`#endif`
`645`		`-constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool sign) noexcept // NOLINT(readability-function-cognitive-complexity,misc-no-recursion)`
	`645`	`+constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool is_negative) noexcept // NOLINT(readability-function-cognitive-complexity,misc-no-recursion)`
`646`	`646`	`{`
`647`	`647`	`static_assert(detail::is_integral_v<T1>, "Coefficient must be an integer");`
`648`	`648`	`static_assert(detail::is_integral_v<T2>, "Exponent must be an integer");`
`649`	`649`
`650`		`- bits_ = sign ? detail::d32_sign_mask : UINT32_C(0);`
	`650`	`+ bits_ = is_negative ? detail::d32_sign_mask : UINT32_C(0);`
`651`	`651`
`652`	`652`	`// If the coeff is not in range, make it so`
`653`	`653`	`// Only count the number of digits if we absolutely have to`
`654`	`654`	`int coeff_digits {-1};`
`655`	`655`	`auto biased_exp {static_cast<int>(exp + detail::bias)};`
`656`	`656`	`if (coeff > detail::d32_max_significand_value \|\| biased_exp < 0)`
`657`	`657`	`{`
`658`		`- coeff_digits = detail::coefficient_rounding<decimal32_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));`
	`658`	`+ coeff_digits = detail::coefficient_rounding<decimal32_t>(coeff, exp, biased_exp, is_negative, detail::num_digits(coeff));`
`659`	`659`	`}`
`660`	`660`
`661`	`661`	`auto reduced_coeff {static_cast<significand_type>(coeff)};`
`@@ -708,21 +708,21 @@ constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool sign) noexcept // NOLI`
`708`	`708`	`{`
`709`	`709`	`exp -= digit_delta;`
`710`	`710`	`reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));`
`711`		`- *this = decimal32_t(reduced_coeff, exp, sign);`
	`711`	`+ *this = decimal32_t(reduced_coeff, exp, is_negative);`
`712`	`712`	`}`
`713`	`713`	`else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision)`
`714`	`714`	`{`
`715`	`715`	`// We can expand the coefficient to use the maximum number of digits`
`716`	`716`	`const auto offset {detail::precision - coeff_digits};`
`717`	`717`	`exp -= offset;`
`718`	`718`	`reduced_coeff *= detail::pow10(static_cast<significand_type>(offset));`
`719`		`- *this = decimal32_t(reduced_coeff, exp, sign);`
	`719`	`+ *this = decimal32_t(reduced_coeff, exp, is_negative);`
`720`	`720`	`}`
`721`	`721`	`else`
`722`	`722`	`{`
`723`	`723`	`// Reset the value and make sure to preserve the sign of 0/inf`
`724`	`724`	`bits_ = exp < 0 ? UINT32_C(0) : detail::d32_inf_mask;`
`725`		`- bits_ \|= sign ? detail::d32_sign_mask : UINT32_C(0);`
	`725`	`+ bits_ \|= is_negative ? detail::d32_sign_mask : UINT32_C(0);`
`726`	`726`	`}`
`727`	`727`	`}`
`728`	`728`	`}`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ BOOST_DECIMAL_EXPORT class decimal64_t final`
`325`	`325`	`#else`
`326`	`326`	`template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool> = true>`
`327`	`327`	`#endif`
`328`		`- constexpr decimal64_t(T1 coeff, T2 exp, bool sign = false) noexcept;`
	`328`	`+ constexpr decimal64_t(T1 coeff, T2 exp, bool is_negative = false) noexcept;`
`329`	`329`
`330`	`330`	`#ifdef BOOST_DECIMAL_HAS_CONCEPTS`
`331`	`331`	`template <BOOST_DECIMAL_SIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>`
`@@ -640,16 +640,16 @@ template <BOOST_DECIMAL_UNSIGNED_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL T2>`
`640`	`640`	`#else`
`641`	`641`	`template <typename T1, typename T2, std::enable_if_t<detail::is_unsigned_v<T1> && detail::is_integral_v<T2>, bool>>`
`642`	`642`	`#endif`
`643`		`-constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool sign) noexcept`
	`643`	`+constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool is_negative) noexcept`
`644`	`644`	`{`
`645`		`- bits_ = sign ? detail::d64_sign_mask : UINT64_C(0);`
	`645`	`+ bits_ = is_negative ? detail::d64_sign_mask : UINT64_C(0);`
`646`	`646`
`647`	`647`	`// If the coeff is not in range, make it so`
`648`	`648`	`int coeff_digits {-1};`
`649`	`649`	`auto biased_exp {static_cast<int>(exp) + detail::bias_v<decimal64_t>};`
`650`	`650`	`if (coeff > detail::d64_max_significand_value \|\| biased_exp < 0)`
`651`	`651`	`{`
`652`		`- coeff_digits = detail::coefficient_rounding<decimal64_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));`
	`652`	`+ coeff_digits = detail::coefficient_rounding<decimal64_t>(coeff, exp, biased_exp, is_negative, detail::num_digits(coeff));`
`653`	`653`	`}`
`654`	`654`
`655`	`655`	`auto reduced_coeff {static_cast<significand_type>(coeff)};`
`@@ -702,20 +702,20 @@ constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool sign) noexcept`
`702`	`702`	`{`
`703`	`703`	`exp -= digit_delta;`
`704`	`704`	`reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));`
`705`		`- *this = decimal64_t(reduced_coeff, exp, sign);`
	`705`	`+ *this = decimal64_t(reduced_coeff, exp, is_negative);`
`706`	`706`	`}`
`707`	`707`	`else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision_v<decimal64_t>)`
`708`	`708`	`{`
`709`	`709`	`const auto offset {detail::precision_v<decimal64_t> - coeff_digits};`
`710`	`710`	`exp -= offset;`
`711`	`711`	`reduced_coeff *= detail::pow10(static_cast<significand_type>(offset));`
`712`		`- *this = decimal64_t(reduced_coeff, exp, sign);`
	`712`	`+ *this = decimal64_t(reduced_coeff, exp, is_negative);`
`713`	`713`	`}`
`714`	`714`	`else`
`715`	`715`	`{`
`716`	`716`	`// Reset the value and make sure to preserve the sign of 0/inf`
`717`	`717`	`bits_ = exp < 0 ? UINT64_C(0) : detail::d64_inf_mask;`
`718`		`- bits_ \|= sign ? detail::d64_sign_mask : UINT64_C(0);`
	`718`	`+ bits_ \|= is_negative ? detail::d64_sign_mask : UINT64_C(0);`
`719`	`719`	`}`
`720`	`720`	`}`
`721`	`721`	`}`