Merge pull request #743 from cppalliance/dpd128

Author: mborland

doc/decimal/conversions.adoc

@@ -84,12 +84,31 @@ constexpr std::uint32_t to_dpd_d32(decimal32 val) noexcept;
 
 constexpr std::uint32_t to_dpd_d32f(decimal32_fast val) noexcept;
 
+constexpr std::uint64_t to_dpd_d64(decimal64 val) noexcept;
+
+constexpr std::uint64_t to_dpd_d64f(decimal64_fast val) noexcept;
+
+constexpr detail::uint128 to_dpd_d128(decimal128 val) noexcept;
+
+constexpr detail::uint128 to_dpd_d128f(decimal128_fast val) noexcept;
+
 template <typename T>
 constexpr auto to_dpd(T val) noexcept;
 
 template <typename T = decimal32_fast>
 constexpr T from_dpd(std::uint32_t bits) noexcept;
 
+template <typename T = decimal64_fast>
+constexpr T from_dpd(std::uint64_t bits) noexcept;
+
+template <typename T = decimal128_fast>
+constexpr T from_dpd(detail::uint128 bits) noexcept;
+
+#ifdef BOOST_DECIMAL_HAS_INT128
+template <typename T = decimal128_fast>
+constexpr T from_dpd(unsigned __int128 bits) noexcept;
+#endif
+
 } // namespace decimal
 } // namespace boost
 ----

include/boost/decimal/bid_conversion.hpp

@@ -77,7 +77,7 @@ constexpr auto from_bid_d128(detail::uint128 bits) noexcept -> decimal128
 }
 
 #ifdef BOOST_DECIMAL_HAS_INT128
-constexpr auto from_bits_d128(detail::uint128_t bits) noexcept -> decimal128
+constexpr auto from_bid_d128(detail::uint128_t bits) noexcept -> decimal128
 {
     return from_bits(bits);
 }

include/boost/decimal/decimal128.hpp

@@ -236,6 +236,10 @@ BOOST_DECIMAL_EXPORT class decimal128 final
     friend constexpr auto from_bid_d128(detail::uint128_t bits) noexcept -> decimal128;
     #endif
 
+    template <typename DecimalType>
+    friend constexpr auto to_dpd_d128(DecimalType val) noexcept
+        BOOST_DECIMAL_REQUIRES_RETURN(detail::is_decimal_floating_point_v, DecimalType, detail::uint128);
+
 public:
     // 3.2.4.1 construct/copy/destroy
     constexpr decimal128() noexcept = default;

include/boost/decimal/decimal128_fast.hpp

@@ -123,6 +123,10 @@ class decimal128_fast final
 
     friend constexpr auto not_finite(const decimal128_fast& val) noexcept -> bool;
 
+    template <typename DecimalType>
+    friend constexpr auto to_dpd_d128(DecimalType val) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_decimal_floating_point_v, DecimalType, detail::uint128);
+
 public:
     constexpr decimal128_fast() noexcept = default;
 

include/boost/decimal/dpd_conversion.hpp

@@ -8,6 +8,7 @@
 #include <boost/decimal/bid_conversion.hpp>
 #include <boost/decimal/detail/config.hpp>
 #include <boost/decimal/detail/concepts.hpp>
+#include <boost/decimal/detail/emulated128.hpp>
 
 #ifndef BOOST_DECIMAL_BUILD_MODULE
 #include <cstdint>
@@ -425,6 +426,9 @@ template <typename DecimalType = decimal32_fast>
 constexpr auto from_dpd_d32(std::uint32_t dpd) noexcept
     BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, DecimalType)
 {
+    static_assert(std::is_same<DecimalType, decimal32>::value || std::is_same<DecimalType, decimal32_fast>::value,
+                  "Target decimal type must be 32-bits");
+
     // 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)
@@ -618,6 +622,9 @@ template <typename DecimalType = decimal64_fast>
 constexpr auto from_dpd_d64(std::uint64_t dpd) noexcept
     BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, DecimalType)
 {
+    static_assert(std::is_same<DecimalType, decimal64>::value || std::is_same<DecimalType, decimal64_fast>::value,
+                  "Target decimal type must be 64-bits");
+
     // 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)
@@ -696,6 +703,201 @@ constexpr auto from_dpd_d64(std::uint64_t dpd) noexcept
     return DecimalType{significand, exp, sign};
 }
 
+template <typename DecimalType>
+constexpr auto to_dpd_d128(DecimalType val) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_decimal_floating_point_v, DecimalType, detail::uint128)
+{
+    static_assert(std::is_same<DecimalType, decimal128>::value ||
+                  std::is_same<DecimalType, decimal128_fast>::value, "The input must be a 128-bit decimal type");
+
+    // In the non-finite cases the encodings are the same
+    // 3.5.2.a and 3.5.2.b
+    if (!isfinite(val))
+    {
+        return to_bid(val);
+    }
+
+    const auto sign {val.isneg()};
+    const auto exp {val.unbiased_exponent()};
+    const auto significand {val.full_significand()};
+
+    detail::uint128 dpd {};
+
+    // Set the sign bit as applicable
+    if (sign)
+    {
+        dpd.high |= detail::d128_sign_mask.high;
+    }
+
+    constexpr int num_digits {std::numeric_limits<DecimalType>::digits10};
+    std::uint8_t d[static_cast<std::size_t>(num_digits)] {};
+    auto temp_sig {significand};
+    for (int i = num_digits - 1; i >= 0; --i)
+    {
+        d[i] = static_cast<std::uint8_t>(temp_sig % 10U);
+        temp_sig /= 10U;
+    }
+    BOOST_DECIMAL_ASSERT(d[0] >= 0 && d[0] <= 9);
+    BOOST_DECIMAL_ASSERT(temp_sig == 0);
+
+    constexpr std::uint64_t leading_two_exp_bits_mask {0b11000000000000};
+    const auto leading_two_bits {(exp & leading_two_exp_bits_mask) >> 12U};
+    constexpr std::uint64_t trailing_exp_bits_mask {0b00111111111111};
+    const auto trailing_exp_bits {(exp & trailing_exp_bits_mask)};
+
+    std::uint64_t combination_field_bits {};
+
+    // Now based on what the value of d[0] and the leading bits of exp are we can set the value of the combination field
+    // See 3.5.2.c.1
+    // If d0 is 8 or 9 then we follow section i
+    if (d[0] >= 8)
+    {
+        const auto d0_is_nine {d[0] == 9};
+        switch (leading_two_bits)
+        {
+            case 0U:
+                combination_field_bits = d0_is_nine ? 0b11001 : 0b11000;
+                break;
+            case 1U:
+                combination_field_bits = d0_is_nine ? 0b11011 : 0b11010;
+                break;
+            case 2U:
+                combination_field_bits = d0_is_nine ? 0b11101 : 0b11100;
+                break;
+                // LCOV_EXCL_START
+            default:
+                BOOST_DECIMAL_UNREACHABLE;
+                // LCOV_EXCL_STOP
+        }
+    }
+        // If d0 is 0 to 7 then we follow section II
+    else
+    {
+        // In here the value of d[0] = 4*G2 + 2*G3 + G4
+        const auto d0_mask {static_cast<std::uint64_t>(d[0])};
+        switch (leading_two_bits)
+        {
+            case 0U:
+                // 00XXX
+                combination_field_bits |= d0_mask;
+                break;
+            case 1U:
+                // 01XXX
+                combination_field_bits = 0b01000;
+                combination_field_bits |= d0_mask;
+                break;
+            case 2U:
+                // 10XXX
+                combination_field_bits = 0b10000;
+                combination_field_bits |= d0_mask;
+                break;
+                // LCOV_EXCL_START
+            default:
+                BOOST_DECIMAL_UNREACHABLE;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    // Write the now know combination field and trailing exp bits to the result
+    dpd.high |= (combination_field_bits << 58U);
+    dpd.high |= (trailing_exp_bits << 46U);
+
+    // Now we have to encode all 11 of the declets
+    int offset {10};
+    for (std::size_t i {1}; i < num_digits - 1; i += 3U)
+    {
+        const auto declet {static_cast<detail::uint128>(detail::encode_dpd(d[i], d[i + 1], d[i + 2]))};
+        dpd |= detail::uint128(declet << (10 * offset));
+        --offset;
+    }
+
+    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[static_cast<std::size_t>(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 - 1) - i));
+    }
+
+    return DecimalType{significand, exp, sign};
+}
+
 constexpr auto to_dpd(decimal32 val) noexcept -> std::uint32_t
 {
     return to_dpd_d32(val);
@@ -706,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
 {
@@ -737,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
 

test/test_dpd_conversions.cpp

@@ -70,5 +70,11 @@ int main()
     test_float_range<decimal64>();
     test_float_range<decimal64_fast>();
 
+    test<decimal128>();
+    test<decimal128_fast>();
+
+    test_float_range<decimal128>();
+    test_float_range<decimal128_fast>();
+
     return boost::report_errors();
 }