Fix sign on non-finite DPD conversions

Author: mborland

include/boost/decimal/dpd_conversion.hpp

@@ -435,21 +435,26 @@ constexpr auto from_dpd_d32(const std::uint32_t dpd) noexcept
     static_assert(std::is_same<DecimalType, decimal32_t>::value || std::is_same<DecimalType, decimal_fast32_t>::value,
                   "Target decimal type must be 32-bits");
 
+    const auto sign {(dpd & detail::d32_sign_mask) != 0};
+
     // First we check for non-finite values
     // Since they are in the same initial format as BID it's easy to check with our existing masks
     if ((dpd & detail::d32_inf_mask) == detail::d32_inf_mask)
     {
         if ((dpd & detail::d32_snan_mask) == detail::d32_snan_mask)
         {
-            return std::numeric_limits<DecimalType>::signaling_NaN();
+            return sign ? -std::numeric_limits<DecimalType>::signaling_NaN() :
+                           std::numeric_limits<DecimalType>::signaling_NaN();
         }
         else if ((dpd & detail::d32_nan_mask) == detail::d32_nan_mask)
         {
-            return std::numeric_limits<DecimalType>::quiet_NaN();
+            return sign ? -std::numeric_limits<DecimalType>::quiet_NaN() :
+                           std::numeric_limits<DecimalType>::quiet_NaN();
         }
         else
         {
-            return std::numeric_limits<DecimalType>::infinity();
+            return sign ? -std::numeric_limits<DecimalType>::infinity() :
+                           std::numeric_limits<DecimalType>::infinity();
         }
     }
 
@@ -458,7 +463,6 @@ constexpr auto from_dpd_d32(const std::uint32_t dpd) noexcept
     constexpr std::uint32_t dpd_d32_combination_mask {UINT32_C(0b0'11111'000000'0000000000'0000000000)};
 
     // The bit lengths are the same as used in the standard bid format
-    const auto sign {(dpd & detail::d32_sign_mask) != 0};
     const auto combination_field_bits {(dpd & dpd_d32_combination_mask) >> 26U};
     const auto exponent_field_bits {(dpd & dpd_d32_exponent_mask) >> 20U};
     const auto significand_bits {(dpd & dpd_d32_significand_mask)};
@@ -635,21 +639,26 @@ constexpr auto from_dpd_d64(const std::uint64_t dpd) noexcept
     static_assert(std::is_same<DecimalType, decimal64_t>::value || std::is_same<DecimalType, decimal_fast64_t>::value,
                   "Target decimal type must be 64-bits");
 
+    const auto sign {(dpd & detail::d64_sign_mask) != 0};
+
     // First we check for non-finite values
     // Since they are in the same initial format as BID it's easy to check with our existing masks
     if ((dpd & detail::d64_inf_mask) == detail::d64_inf_mask)
     {
         if ((dpd & detail::d64_snan_mask) == detail::d64_snan_mask)
         {
-            return std::numeric_limits<DecimalType>::signaling_NaN();
+            return sign ? -std::numeric_limits<DecimalType>::signaling_NaN() :
+                           std::numeric_limits<DecimalType>::signaling_NaN();
         }
         else if ((dpd & detail::d64_nan_mask) == detail::d64_nan_mask)
         {
-            return std::numeric_limits<DecimalType>::quiet_NaN();
+            return sign ? -std::numeric_limits<DecimalType>::quiet_NaN() :
+                           std::numeric_limits<DecimalType>::quiet_NaN();
         }
         else
         {
-            return std::numeric_limits<DecimalType>::infinity();
+            return sign ? -std::numeric_limits<DecimalType>::infinity() :
+                           std::numeric_limits<DecimalType>::infinity();
         }
     }
 
@@ -659,7 +668,6 @@ constexpr auto from_dpd_d64(const std::uint64_t dpd) noexcept
     constexpr std::uint64_t dpd_d64_exponent_field_mask {UINT64_C(0b0'00000'11111111'0000000000'0000000000'0000000000'0000000000'0000000000)};
     constexpr std::uint64_t dpd_d64_significand_field_mask {UINT64_C(0b0'00000'00000000'1111111111'1111111111'1111111111'1111111111'1111111111)};
 
-    const auto sign {(dpd & detail::d64_sign_mask) != 0};
     const auto combination_field_bits {(dpd & dpd_d64_combination_field_mask) >> 58U};
     const auto exponent_field_bits {(dpd & dpd_d64_exponent_field_mask) >> 50U};
     auto significand_bits {(dpd & dpd_d64_significand_field_mask)};
@@ -841,19 +849,24 @@ constexpr auto from_dpd_d128(const int128::uint128_t dpd) noexcept
     static_assert(std::is_same<DecimalType, decimal128_t>::value || std::is_same<DecimalType, decimal_fast128_t>::value,
                   "Target decimal type must be 128-bits");
 
+    const auto sign {(dpd.high & detail::d128_sign_mask) != 0};
+
     if ((dpd & detail::d128_inf_mask) == detail::d128_inf_mask)
     {
         if ((dpd & detail::d128_snan_mask) == detail::d128_snan_mask)
         {
-            return std::numeric_limits<DecimalType>::signaling_NaN();
+            return sign ? -std::numeric_limits<DecimalType>::signaling_NaN() :
+                           std::numeric_limits<DecimalType>::signaling_NaN();
         }
         else if ((dpd & detail::d128_nan_mask) == detail::d128_nan_mask)
         {
-            return std::numeric_limits<DecimalType>::quiet_NaN();
+            return sign ? -std::numeric_limits<DecimalType>::quiet_NaN() :
+                           std::numeric_limits<DecimalType>::quiet_NaN();
         }
         else
         {
-            return std::numeric_limits<DecimalType>::infinity();
+            return sign ? -std::numeric_limits<DecimalType>::infinity() :
+                           std::numeric_limits<DecimalType>::infinity();
         }
     }
 
@@ -862,7 +875,6 @@ constexpr auto from_dpd_d128(const int128::uint128_t dpd) noexcept
     constexpr int128::uint128_t d128_dpd_significand_mask {UINT64_C(0b1111111111'1111111111'1111111111'1111111111'111111), UINT64_MAX};
 
     // The bit lengths are the same as used in the standard bid format
-    const auto sign {(dpd.high & detail::d128_sign_mask) != 0};
     const auto combination_field_bits {(dpd.high & d128_dpd_combination_field_mask_high_bits) >> 58U};
     const auto exponent_field_bits {(dpd.high & d128_dpd_exponent_mask_high_bits) >> 46U};
     auto significand_bits {(dpd & d128_dpd_significand_mask)};