Skip to content

Replace most binary constant masks #1298

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
mborland merged 6 commits into from
Jan 14, 2026
+50 −47
Merged

Replace most binary constant masks #1298

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
e55a5b4
Replace d32 binary masks with hex
mborland Jan 14, 2026
c825cf2
Replace d64 binary masks with hex
mborland Jan 14, 2026
98f73b8
Replace d128 masks with hex
mborland Jan 14, 2026
2fcf4cb
Replace binary decoding masks with hex
mborland Jan 14, 2026
dd64915
Replace binary constants in numeric limits
mborland Jan 14, 2026
2222b4a
Replace binary dpd decoding masks
mborland Jan 14, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 12 additions & 12 deletions include/boost/decimal/decimal128_t.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -74,27 +74,27 @@ BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE int128::uint128_t d128_snan_mask {UINT64
// s eeeeeeeeeeeeee (0TTT) 110-bits
// s 11 eeeeeeeeeeeeee (100T) 110-bits

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_sign_mask {UINT64_C(0b1'00000'00000000'0000000000'0000000000'0000000000'0000000000'0000000000)};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_combination_field_mask = UINT64_C(0b0'11'00000000'000'0000000000'0000000000'0000000000'0000000000'0000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_sign_mask {UINT64_C(0x8000000000000000)};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_combination_field_mask = UINT64_C(0x6000000000000000);

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_not_11_exp_mask = UINT64_C(0b0'11111111111111'000000000'0000000000'0000000000'0000000000'0000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_not_11_exp_mask = UINT64_C(0x7FFE000000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_not_11_exp_high_word_shift {49U};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_11_exp_mask {UINT64_C(0b0'00'11111111111111'0000000'0000000000'0000000000'0000000000'0000000000)};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_11_exp_mask {UINT64_C(0x1FFF800000000000)};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_11_exp_high_word_shift {47U};

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE int128::uint128_t d128_not_11_significand_mask {UINT64_C(0b0'00000000000000'111111111'1111111111'1111111111'1111111111'1111111111), UINT64_MAX};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE int128::uint128_t d128_11_significand_mask {UINT64_C(0b0'00'00000000000000'1111111'1111111111'1111111111'1111111111'1111111111), UINT64_MAX};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE int128::uint128_t d128_not_11_significand_mask {UINT64_C(0x1FFFFFFFFFFFF), UINT64_MAX};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE int128::uint128_t d128_11_significand_mask {UINT64_C(0x7FFFFFFFFFFF), UINT64_MAX};

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE int128::uint128_t d128_biggest_no_combination_significand {d128_not_11_significand_mask};

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d128_max_biased_exponent {UINT64_C(12287)};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE int128::uint128_t d128_max_significand_value {UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)};
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE int128::uint128_t d128_max_significand_value {UINT64_C(0x1ED09BEAD87C0), UINT64_C(0x378D8E63FFFFFFFF)};

template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE TargetDecimalType>
constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDecimalType& value, chars_format fmt) noexcept -> to_chars_result;

template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE TargetDecimalType>
constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalType& value, const chars_format fmt) noexcept -> to_chars_result;
constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalType& value, chars_format fmt) noexcept -> to_chars_result;

template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE TargetDecimalType>
constexpr auto to_chars_hex_impl(char* first, char* last, const TargetDecimalType& value) noexcept -> to_chars_result;
Expand Down Expand Up @@ -670,7 +670,7 @@ constexpr auto decimal128_t::full_significand() const noexcept -> significand_ty

if ((bits_.high & detail::d128_combination_field_mask) == detail::d128_combination_field_mask)
{
constexpr int128::uint128_t implied_bit {UINT64_C(0b10000000000000000000000000000000000000000000000000),0};
constexpr int128::uint128_t implied_bit {UINT64_C(0x2000000000000),0};
significand = implied_bit | (bits_ & detail::d128_11_significand_mask);
}
else
Expand All @@ -693,7 +693,7 @@ constexpr auto decimal128_t::to_components() const noexcept -> detail::decimal12

if ((bits_.high & detail::d128_combination_field_mask) == detail::d128_combination_field_mask)
{
constexpr int128::uint128_t implied_bit {UINT64_C(0b10000000000000000000000000000000000000000000000000),0};
constexpr int128::uint128_t implied_bit {UINT64_C(0x2000000000000),0};
significand = implied_bit | (bits_ & detail::d128_11_significand_mask);
expval = (bits_.high & detail::d128_11_exp_mask) >> detail::d128_11_exp_high_word_shift;
}
Expand Down Expand Up @@ -938,8 +938,8 @@ class numeric_limits_impl128

// Member functions
static constexpr auto (min) () -> boost::decimal::decimal128_t { return {UINT32_C(1), min_exponent}; }
static constexpr auto (max) () -> boost::decimal::decimal128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1}; }
static constexpr auto lowest () -> boost::decimal::decimal128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1, construction_sign::negative}; }
static constexpr auto (max) () -> boost::decimal::decimal128_t { return {d128_max_significand_value, max_exponent - digits + 1}; }
static constexpr auto lowest () -> boost::decimal::decimal128_t { return {d128_max_significand_value, max_exponent - digits + 1, construction_sign::negative}; }
static constexpr auto epsilon () -> boost::decimal::decimal128_t { return {UINT32_C(1), -digits + 1}; }
static constexpr auto round_error () -> boost::decimal::decimal128_t { return epsilon(); }
static constexpr auto infinity () -> boost::decimal::decimal128_t { return boost::decimal::from_bits(boost::decimal::detail::d128_inf_mask); }
Expand Down
20 changes: 10 additions & 10 deletions include/boost/decimal/decimal32_t.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -76,20 +76,20 @@ BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_snan_mask = UINT32_C(0
//
// Only is the type different in steering 11 which yields significand 100 + 21 bits giving us our 24 total bits of precision

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_sign_mask = UINT32_C(0b10000000000000000000000000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_combination_field_mask = UINT32_C(0b01100000000000000000000000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_sign_mask = UINT32_C(0x80000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_combination_field_mask = UINT32_C(0x60000000);

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_comb_11_mask = UINT32_C(0b0'11000'000000'0000000000'0000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_comb_11_mask = d32_combination_field_mask;

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_not_11_exp_mask = UINT32_C(0b01111111100000000000000000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_not_11_exp_mask = UINT32_C(0x7F800000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_not_11_exp_shift = UINT32_C(23);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_11_exp_mask = UINT32_C(0b00011111111000000000000000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_11_exp_mask = UINT32_C(0x1FE00000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_11_exp_shift = UINT32_C(21);

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_not_11_significand_mask = UINT32_C(0b00000000011111111111111111111111);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_11_significand_mask = UINT32_C(0b00000000000111111111111111111111);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_not_11_significand_mask = UINT32_C(0x7FFFFF);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_11_significand_mask = UINT32_C(0x1FFFFF); // 21 bits

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_biggest_no_combination_significand = UINT32_C(0b11111111111111111111111); // 23 bits
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_biggest_no_combination_significand = d32_not_11_significand_mask; // 23 bits

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_max_biased_exponent = UINT32_C(191);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint32_t d32_max_significand_value = UINT32_C(9'999'999);
Expand Down Expand Up @@ -1580,7 +1580,7 @@ constexpr auto decimal32_t::full_significand() const noexcept -> significand_typ

if ((bits_ & detail::d32_comb_11_mask) == detail::d32_comb_11_mask)
{
constexpr std::uint32_t implied_bit {UINT32_C(0b100000000000000000000000)};
constexpr std::uint32_t implied_bit {UINT32_C(0x800000)};
significand = implied_bit | (bits_ & detail::d32_11_significand_mask);
}
else
Expand Down Expand Up @@ -1650,7 +1650,7 @@ constexpr auto decimal32_t::to_components() const noexcept -> detail::decimal32_

if ((bits_ & detail::d32_comb_11_mask) == detail::d32_comb_11_mask)
{
constexpr std::uint32_t implied_bit {UINT32_C(0b100000000000000000000000)};
constexpr std::uint32_t implied_bit {UINT32_C(0x800000)};
significand = implied_bit | (bits_ & detail::d32_11_significand_mask);
expval = (bits_ & detail::d32_11_exp_mask) >> detail::d32_11_exp_shift;
}
Expand Down
18 changes: 9 additions & 9 deletions include/boost/decimal/decimal64_t.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -76,16 +76,16 @@ BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_snan_mask = UINT64_C(0
// s eeeeeeeeee [ttt][tttttttttt][tttttttttt][tttttttttt][tttttttttt][tttttttttt]
// s 11 eeeeeeeeee [100t][tttttttttt][tttttttttt][tttttttttt][tttttttttt][tttttttttt]

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_sign_mask = UINT64_C(0b1'00000'00000000'0000000000'0000000000'0000000000'0000000000'0000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_combination_field_mask = UINT64_C(0b0'11'00000000'000'0000000000'0000000000'0000000000'0000000000'0000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_sign_mask = UINT64_C(0x8000000000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_combination_field_mask = UINT64_C(0x6000000000000000);

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_not_11_exp_mask = UINT64_C(0b0'11'11111111'000'0000000000'0000000000'0000000000'0000000000'0000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_not_11_exp_mask = UINT64_C(0x7FE0000000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_not_11_exp_shift = UINT64_C(53);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_11_exp_mask = UINT64_C(0b0'00'1111111111'0'0000000000'0000000000'0000000000'0000000000'0000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_11_exp_mask = UINT64_C(0x1FF8000000000000);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_11_exp_shift = UINT64_C(51);

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_not_11_significand_mask = UINT64_C(0b0'00'00000000'111'1111111111'1111111111'1111111111'1111111111'1111111111);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_11_significand_mask = UINT64_C(0b0'00'0000000000'1'1111111111'1111111111'1111111111'1111111111'1111111111);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_not_11_significand_mask = UINT64_C(0x1FFFFFFFFFFFFF);
BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_11_significand_mask = UINT64_C(0x7FFFFFFFFFFFF);

BOOST_DECIMAL_INLINE_CONSTEXPR_VARIABLE std::uint64_t d64_biggest_no_combination_significand = d64_not_11_significand_mask;

Expand All @@ -97,7 +97,7 @@ template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE TargetDecimalType>
constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDecimalType& value, chars_format fmt) noexcept -> to_chars_result;

template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE TargetDecimalType>
constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalType& value, const chars_format fmt) noexcept -> to_chars_result;
constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalType& value, chars_format fmt) noexcept -> to_chars_result;

template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE TargetDecimalType>
constexpr auto to_chars_hex_impl(char* first, char* last, const TargetDecimalType& value) noexcept -> to_chars_result;
Expand Down Expand Up @@ -1166,7 +1166,7 @@ constexpr auto decimal64_t::full_significand() const noexcept -> significand_typ

if ((bits_ & detail::d64_combination_field_mask) == detail::d64_combination_field_mask)
{
constexpr std::uint64_t implied_bit {UINT64_C(0b1000'0000000000'0000000000'0000000000'0000000000'0000000000)};
constexpr std::uint64_t implied_bit {UINT64_C(0x20000000000000)};
significand = implied_bit | (bits_ & detail::d64_11_significand_mask);
}
else
Expand All @@ -1191,7 +1191,7 @@ constexpr auto decimal64_t::to_components() const noexcept -> detail::decimal64_

if ((bits_ & detail::d64_combination_field_mask) == detail::d64_combination_field_mask)
{
constexpr std::uint64_t implied_bit {UINT64_C(0b1000'0000000000'0000000000'0000000000'0000000000'0000000000)};
constexpr std::uint64_t implied_bit {UINT64_C(0x20000000000000)};
significand = implied_bit | (bits_ & detail::d64_11_significand_mask);
expval = (bits_ & detail::d64_11_exp_mask) >> detail::d64_11_exp_shift;
}
Expand Down
4 changes: 2 additions & 2 deletions include/boost/decimal/decimal_fast128_t.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -648,8 +648,8 @@ class numeric_limits_impl128f

// Member functions
static constexpr auto (min) () -> boost::decimal::decimal_fast128_t { return {UINT32_C(1), min_exponent}; }
static constexpr auto (max) () -> boost::decimal::decimal_fast128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1}; }
static constexpr auto lowest () -> boost::decimal::decimal_fast128_t { return {boost::int128::uint128_t{UINT64_C(0b1111011010000100110111110101011011000011111000000), UINT64_C(0b0011011110001101100011100110001111111111111111111111111111111111)}, max_exponent - digits + 1, construction_sign::negative}; }
static constexpr auto (max) () -> boost::decimal::decimal_fast128_t { return {boost::int128::uint128_t{UINT64_C(0x1ED09BEAD87C0), UINT64_C(0x378D8E63FFFFFFFF)}, max_exponent - digits + 1}; }
static constexpr auto lowest () -> boost::decimal::decimal_fast128_t { return {boost::int128::uint128_t{UINT64_C(0x1ED09BEAD87C0), UINT64_C(0x378D8E63FFFFFFFF)}, max_exponent - digits + 1, construction_sign::negative}; }
static constexpr auto epsilon () -> boost::decimal::decimal_fast128_t { return {UINT32_C(1), -digits + 1}; }
static constexpr auto round_error () -> boost::decimal::decimal_fast128_t { return epsilon(); }
static constexpr auto infinity () -> boost::decimal::decimal_fast128_t { return boost::decimal::direct_init_d128(boost::decimal::detail::d128_fast_inf, 0, false); }
Expand Down
31 changes: 17 additions & 14 deletions include/boost/decimal/dpd_conversion.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -458,9 +458,9 @@ constexpr auto from_dpd_d32(const std::uint32_t dpd) noexcept
}
}

constexpr std::uint32_t dpd_d32_exponent_mask {UINT32_C(0b0'00000'111111'0000000000'0000000000)};
constexpr std::uint32_t dpd_d32_significand_mask {UINT32_C(0b0'00000'000000'1111111111'1111111111)};
constexpr std::uint32_t dpd_d32_combination_mask {UINT32_C(0b0'11111'000000'0000000000'0000000000)};
constexpr std::uint32_t dpd_d32_exponent_mask {UINT32_C(0x3F00000)};
constexpr std::uint32_t dpd_d32_significand_mask {UINT32_C(0xFFFFF)};
constexpr std::uint32_t dpd_d32_combination_mask {UINT32_C(0x7C000000)};

// The bit lengths are the same as used in the standard bid format
const auto combination_field_bits {(dpd & dpd_d32_combination_mask) >> 26U};
Expand Down Expand Up @@ -505,10 +505,11 @@ constexpr auto from_dpd_d32(const std::uint32_t dpd) noexcept
// We can now decode the remainder of the significand to recover the value
std::uint8_t digits[7] {};
digits[0] = static_cast<std::uint8_t>(d0);
const auto significand_low {significand_bits & 0b1111111111};
constexpr std::uint32_t seven_digits_mask {UINT32_C(0x3FF)};
const auto significand_low {significand_bits & seven_digits_mask};
detail::decode_dpd(significand_low, digits[6], digits[5], digits[4]);
const auto significand_high {(significand_bits & 0b11111111110000000000) >> 10U};
BOOST_DECIMAL_ASSERT(significand_high <= 0b1111111111);
const auto significand_high {(significand_bits & UINT32_C(0xFFC00)) >> 10U};
BOOST_DECIMAL_ASSERT(significand_high <= seven_digits_mask);
detail::decode_dpd(significand_high, digits[3], digits[2], digits[1]);

// Now we can assemble the significand
Expand Down Expand Up @@ -664,9 +665,9 @@ constexpr auto from_dpd_d64(const std::uint64_t dpd) noexcept

// The bit lengths are the same as used in the standard bid format

constexpr std::uint64_t dpd_d64_combination_field_mask {UINT64_C(0b0'11111'00000000'0000000000'0000000000'0000000000'0000000000'0000000000)};
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)};
constexpr std::uint64_t dpd_d64_combination_field_mask {UINT64_C(0x7C00000000000000)};
constexpr std::uint64_t dpd_d64_exponent_field_mask {UINT64_C(0x3FC000000000000)};
constexpr std::uint64_t dpd_d64_significand_field_mask {UINT64_C(0x3FFFFFFFFFFFF)};

const auto combination_field_bits {(dpd & dpd_d64_combination_field_mask) >> 58U};
const auto exponent_field_bits {(dpd & dpd_d64_exponent_field_mask) >> 50U};
Expand Down Expand Up @@ -712,7 +713,8 @@ constexpr auto from_dpd_d64(const std::uint64_t dpd) noexcept
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)};
constexpr std::uint32_t declet_mask {UINT32_C(0x3FF)};
const auto declet_bits {static_cast<std::uint32_t>(significand_bits & declet_mask)};
significand_bits >>= 10U;
detail::decode_dpd(declet_bits, digits[i], digits[i - 1], digits[i - 2]);
}
Expand Down Expand Up @@ -868,9 +870,9 @@ constexpr auto from_dpd_d128(const int128::uint128_t dpd) noexcept
}
}

constexpr std::uint64_t d128_dpd_combination_field_mask_high_bits {UINT64_C(0b0'11111'00000000'0000000000'0000000000'0000000000'0000000000'0000000000)};
constexpr std::uint64_t d128_dpd_exponent_mask_high_bits {UINT64_C(0b0'00000'111111111111'0000000000'0000000000'0000000000'0000000000'000000)};
constexpr int128::uint128_t d128_dpd_significand_mask {UINT64_C(0b1111111111'1111111111'1111111111'1111111111'111111), UINT64_MAX};
constexpr std::uint64_t d128_dpd_combination_field_mask_high_bits {UINT64_C(0x7C00000000000000)};
constexpr std::uint64_t d128_dpd_exponent_mask_high_bits {UINT64_C(0x3FFC00000000000)};
constexpr int128::uint128_t d128_dpd_significand_mask {UINT64_C(0x3FFFFFFFFFFF), UINT64_MAX};

// The bit lengths are the same as used in the standard bid format
const auto combination_field_bits {(dpd.high & d128_dpd_combination_field_mask_high_bits) >> 58U};
Expand Down Expand Up @@ -918,7 +920,8 @@ constexpr auto from_dpd_d128(const int128::uint128_t dpd) noexcept
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 & 0b1111111111U)};
constexpr std::uint32_t declet_mask {UINT32_C(0x3FF)};
const auto declet_bits {static_cast<std::uint32_t>(significand_bits & declet_mask)};
significand_bits >>= 10U;
detail::decode_dpd(declet_bits, digits[i], digits[i - 1], digits[i - 2]);
}
Expand Down