Merge pull request #742 from cppalliance/dpd64

Implement 64 bit DPD conversions

Author: mborland

include/boost/decimal/decimal64.hpp

@@ -229,6 +229,10 @@ BOOST_DECIMAL_EXPORT class decimal64 final
 
     friend constexpr auto from_bid_d64(std::uint64_t bits) noexcept -> decimal64;
 
+    template <typename DecimalType>
+    friend constexpr auto to_dpd_d64(DecimalType val) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_decimal_floating_point_v, DecimalType, std::uint64_t);
+
 public:
     // 3.2.3.1 construct/copy/destroy
     constexpr decimal64() noexcept = default;

include/boost/decimal/decimal64_fast.hpp

@@ -119,6 +119,10 @@ class decimal64_fast final
 
     friend constexpr auto not_finite(decimal64_fast val) noexcept -> bool;
 
+    template <typename DecimalType>
+    friend constexpr auto to_dpd_d64(DecimalType val) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_decimal_floating_point_v, DecimalType, std::uint64_t);
+
 public:
     constexpr decimal64_fast() noexcept = default;
 

include/boost/decimal/dpd_conversion.hpp

@@ -421,16 +421,6 @@ constexpr auto to_dpd_d32(DecimalType val) noexcept
     return dpd;
 }
 
-constexpr auto to_dpd(decimal32 val) noexcept -> std::uint32_t
-{
-    return to_dpd_d32(val);
-}
-
-constexpr auto to_dpd(decimal32_fast val) noexcept -> std::uint32_t
-{
-    return to_dpd_d32(val);
-}
-
 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)
@@ -513,13 +503,239 @@ constexpr auto from_dpd_d32(std::uint32_t dpd) noexcept
     return DecimalType{significand, exp, sign};
 }
 
+template <typename DecimalType>
+constexpr auto to_dpd_d64(DecimalType val) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_decimal_floating_point_v, DecimalType, std::uint64_t)
+{
+    static_assert(std::is_same<DecimalType, decimal64>::value ||
+                  std::is_same<DecimalType, decimal64_fast>::value, "The input must be a 64-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()};
+
+    std::uint64_t dpd {};
+    // Set the sign bit as applicable
+    if (sign)
+    {
+        dpd |= detail::d64_sign_mask;
+    }
+
+    std::uint8_t d[std::numeric_limits<DecimalType>::digits10] {};
+    auto temp_sig {significand};
+    for (int i = 15; 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 {0b1100000000};
+    const auto leading_two_bits {(exp & leading_two_exp_bits_mask) >> 8U};
+    BOOST_DECIMAL_ASSERT(leading_two_bits >= 0 && leading_two_bits <= 2);
+    constexpr std::uint64_t trailing_exp_bits_mask {0b0011111111};
+    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 known combination field and trailing exp bits to the result
+    dpd |= (combination_field_bits << 58U);
+    dpd |= (trailing_exp_bits << 50U);
+
+    // Now we need to encode all the declets
+    // Once we have the declet right it into the result
+    int offset {4};
+    for (std::size_t i {1}; i < 15; i += 3U)
+    {
+        const auto declet {static_cast<std::uint64_t>(detail::encode_dpd(d[i], d[i + 1], d[i + 2]))};
+        dpd |= (declet << (10 * offset));
+        --offset;
+    }
+
+    return dpd;
+}
+
+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)
+{
+    // 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();
+        }
+        else if ((dpd & detail::d64_nan_mask) == detail::d64_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 & detail::d64_sign_mask) != 0};
+    const auto combination_field_bits {(dpd & detail::d64_combination_field_mask) >> 58U};
+    const auto exponent_field_bits {(dpd & detail::d64_exponent_mask) >> 50U};
+    auto significand_bits {(dpd & detail::d64_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 << 8U) + 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
+    std::uint8_t digits[16] {};
+    digits[0] = static_cast<std::uint8_t>(d0);
+    for (int i = 15; 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]);
+    }
+
+    std::uint64_t significand {};
+    for (std::uint64_t i {}; i < 16U; ++i)
+    {
+        significand += digits[i] * detail::pow10(15 - i);
+    }
+
+    return DecimalType{significand, exp, sign};
+}
+
+constexpr auto to_dpd(decimal32 val) noexcept -> std::uint32_t
+{
+    return to_dpd_d32(val);
+}
+
+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
+{
+    return to_dpd_d64(val);
+}
+
+constexpr auto to_dpd(decimal64_fast val) -> std::uint64_t
+{
+    return to_dpd_d64(val);
+}
+
+template <typename DecimalType>
+constexpr auto to_dpd(DecimalType val) noexcept
+{
+    static_assert(detail::is_decimal_floating_point_v<DecimalType>, "Must be a decimal floating point type.");
+    return to_dpd(val);
+}
+
 template <typename DecimalType = decimal32_fast>
 constexpr auto from_dpd(std::uint32_t bits) noexcept
     BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, DecimalType)
 {
     return from_dpd_d32<DecimalType>(bits);
 }
 
+template <typename DecimalType = decimal64_fast>
+constexpr auto from_dpd(std::uint64_t bits) noexcept
+    BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, DecimalType)
+{
+    return from_dpd_d64<DecimalType>(bits);
+}
 
 } // namespace decimal
 } // namespace boost

test/test_dpd_conversions.cpp

@@ -11,7 +11,7 @@ using namespace boost::decimal;
 template <typename T>
 T roundtrip(T val)
 {
-    const auto bits {to_dpd(val)};
+    const auto bits {to_dpd<T>(val)};
     return from_dpd<T>(bits);
 }
 
@@ -41,9 +41,12 @@ void test()
 template <typename T>
 void test_float_range()
 {
+    using float_type = std::conditional_t<std::is_same<T, decimal32>::value ||
+                                          std::is_same<T, decimal32_fast>::value, float, double>;
+
     std::mt19937_64 rng(42);
-    std::uniform_real_distribution<float> dist(std::numeric_limits<float>::min(),
-                                               std::numeric_limits<float>::max());
+    std::uniform_real_distribution<float_type> dist(std::numeric_limits<float_type>::min(),
+                                                    std::numeric_limits<float_type>::max());
 
     for (std::size_t i {}; i < 1024; ++i)
     {
@@ -61,5 +64,11 @@ int main()
     test_float_range<decimal32>();
     test_float_range<decimal32_fast>();
 
+    test<decimal64>();
+    test<decimal64_fast>();
+
+    test_float_range<decimal64>();
+    test_float_range<decimal64_fast>();
+
     return boost::report_errors();
 }