Add 128-bit from_dpd conversion overload

Author: mborland

include/boost/decimal/dpd_conversion.hpp

@@ -814,6 +814,90 @@ constexpr auto to_dpd_d128(DecimalType val) noexcept
     return dpd;
 }
 
+template <typename DecimalType = decimal128_fast>
+constexpr auto from_dpd_d128(detail::uint128 dpd) noexcept
+    BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, DecimalType)
+{
+    static_assert(std::is_same<DecimalType, decimal128>::value || std::is_same<DecimalType, decimal128_fast>::value,
+                  "Target decimal type must be 128-bits");
+
+    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();
+        }
+        else if ((dpd & detail::d128_nan_mask) == detail::d128_nan_mask)
+        {
+            return std::numeric_limits<DecimalType>::quiet_NaN();
+        }
+        else
+        {
+            return std::numeric_limits<DecimalType>::infinity();
+        }
+    }
+
+    // The bit lengths are the same as used in the standard bid format
+    const auto sign {(dpd.high & detail::d128_sign_mask.high) != 0};
+    const auto combination_field_bits {(dpd.high & detail::d128_combination_field_mask.high) >> 58U};
+    const auto exponent_field_bits {(dpd.high & detail::d128_exponent_mask.high) >> 46U};
+    auto significand_bits {(dpd & detail::d128_significand_mask)};
+
+    // Case 1: 3.5.2.c.1.i
+    // Combination field bits are 110XX or 11110X
+    std::uint64_t d0 {};
+    std::uint64_t leading_biased_exp_bits {};
+    if (combination_field_bits >= 0b11000)
+    {
+        // d0 = 8 + G4
+        // Must be equal to 8 or 9
+        d0 = 8U + (combination_field_bits & 0b00001);
+        BOOST_DECIMAL_ASSERT(d0 == 8 || d0 == 9);
+
+        // leading exp bits are 2*G2 + G3
+        // Must be equal to 0, 1 or 2
+        leading_biased_exp_bits = 2U * ((combination_field_bits & 0b00100) >> 2U) + ((combination_field_bits & 0b00010) >> 1U);
+        BOOST_DECIMAL_ASSERT(leading_biased_exp_bits <= 2U);
+    }
+    // Case 2: 3.5.2.c.1.ii
+    // Combination field bits are 0XXXX or 10XXX
+    else
+    {
+        // d0 = 4 * G2 + 2 * G3 + G4
+        // Must be in the range 0-7
+        d0 = combination_field_bits & 0b00111;
+        BOOST_DECIMAL_ASSERT(d0 <= 7);
+
+        // Leading exp bits are 2 * G0 + G1
+        // Must be equal to 0, 1 or 2
+        leading_biased_exp_bits = (combination_field_bits & 0b11000) >> 3U;
+        BOOST_DECIMAL_ASSERT(leading_biased_exp_bits <= 2U);
+    }
+
+    // Now that we have the bits we can calculate the exponents value
+    const auto complete_exp {(leading_biased_exp_bits << 12U) + exponent_field_bits};
+    const auto exp {static_cast<std::int32_t>(complete_exp) - detail::bias_v<DecimalType>};
+
+    // We can now decode the remainder of the significand to recover the value
+    constexpr auto num_digits {std::numeric_limits<DecimalType>::digits10};
+    std::uint8_t digits[num_digits] {};
+    digits[0] = static_cast<std::uint8_t>(d0);
+    for (int i = num_digits - 1; i > 0; i -= 3)
+    {
+        const auto declet_bits {static_cast<std::uint32_t>(significand_bits & 0b1111111111)};
+        significand_bits >>= 10U;
+        detail::decode_dpd(declet_bits, digits[i], digits[i - 1], digits[i - 2]);
+    }
+
+    detail::uint128 significand {};
+    for (int i {}; i < num_digits; ++i)
+    {
+        significand += static_cast<detail::uint128>(digits[i]) * detail::pow10(static_cast<detail::uint128>(num_digits - i));
+    }
+
+    return DecimalType{significand, exp, sign};
+}
+
 constexpr auto to_dpd(decimal32 val) noexcept -> std::uint32_t
 {
     return to_dpd_d32(val);
@@ -824,16 +908,26 @@ constexpr auto to_dpd(decimal32_fast val) noexcept -> std::uint32_t
     return to_dpd_d32(val);
 }
 
-constexpr auto to_dpd(decimal64 val) -> std::uint64_t
+constexpr auto to_dpd(decimal64 val) noexcept -> std::uint64_t
 {
     return to_dpd_d64(val);
 }
 
-constexpr auto to_dpd(decimal64_fast val) -> std::uint64_t
+constexpr auto to_dpd(decimal64_fast val) noexcept -> std::uint64_t
 {
     return to_dpd_d64(val);
 }
 
+constexpr auto to_dpd(decimal128 val) noexcept -> detail::uint128
+{
+    return to_dpd_d128(val);
+}
+
+constexpr auto to_dpd(decimal128_fast val) noexcept -> detail::uint128
+{
+    return to_dpd_d128(val);
+}
+
 template <typename DecimalType>
 constexpr auto to_dpd(DecimalType val) noexcept
 {
@@ -855,6 +949,25 @@ constexpr auto from_dpd(std::uint64_t bits) noexcept
     return from_dpd_d64<DecimalType>(bits);
 }
 
+template <typename DecimalType = decimal128_fast>
+constexpr auto from_dpd(detail::uint128 bits) noexcept
+    BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, DecimalType)
+{
+    return from_dpd_d128<DecimalType>(bits);
+}
+
+#ifdef BOOST_DECIMAL_HAS_INT128
+
+template <typename DecimalType = decimal128_fast>
+constexpr auto from_dpd(detail::uint128_t bits) noexcept
+    BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, DecimalType)
+{
+    const detail::uint128 converted_bits {bits};
+    return from_dpd_d128<DecimalType>(converted_bits);
+}
+
+#endif // BOOST_DECIMAL_HAS_INT128
+
 } // namespace decimal
 } // namespace boost