diff --git a/include/bitcoin/system/impl/math/bits.ipp b/include/bitcoin/system/impl/math/bits.ipp index e65902d0b3..35f182df47 100644 --- a/include/bitcoin/system/impl/math/bits.ipp +++ b/include/bitcoin/system/impl/math/bits.ipp @@ -39,7 +39,7 @@ template > constexpr size_t bit_width(Value value) NOEXCEPT { // zero-based position of msb. - return ceilinged_log2(value); + return is_zero(value) ? zero : add1(floored_log2(value)); } // Called by machine::number (for to_unnegated). diff --git a/include/bitcoin/system/impl/math/bytes.ipp b/include/bitcoin/system/impl/math/bytes.ipp index 4584c34654..09052f5661 100644 --- a/include/bitcoin/system/impl/math/bytes.ipp +++ b/include/bitcoin/system/impl/math/bytes.ipp @@ -38,7 +38,7 @@ constexpr size_t byte_width(Integral value) NOEXCEPT // (zero-based position of msb) + 7 / 8. // (bit_width(value) + 7) / 8 // (ceilinged_log2(value) + 7) / 8 - return ceilinged_log256(value); + return is_zero(value) ? zero : add1(floored_log256(value)); } // Called by machine::number (for little-endian chunk sizing). diff --git a/include/bitcoin/system/impl/math/logarithm.ipp b/include/bitcoin/system/impl/math/logarithm.ipp index b7bf99beb0..f81d14f443 100644 --- a/include/bitcoin/system/impl/math/logarithm.ipp +++ b/include/bitcoin/system/impl/math/logarithm.ipp @@ -53,7 +53,7 @@ constexpr Exponent ceilinged_log_(Base base, Value value) NOEXCEPT const auto factor = possible_narrow_and_sign_cast(base); Exponent exponent = 0; - while (value > 0) { ++exponent; value /= factor; } + while (value > 1) { ++exponent; value /= factor; } return exponent; } } @@ -125,7 +125,7 @@ constexpr Exponent ceilinged_log2(Value value) NOEXCEPT // base2 integral optimization over normal form. return possible_narrow_and_sign_cast( - std::bit_width(to_unsigned(value))); + std::bit_width(sub1(to_unsigned(value)))); } // Called by bc::bit_width. @@ -134,12 +134,12 @@ template > constexpr Exponent ceilinged_log2(Value value) NOEXCEPT { - if (is_log_overflow<2>(value)) + if (is_log_overflow<2>(value) || is_one(value)) return 0; // base2 uintx optimization over normal form. return possible_narrow_and_sign_cast( - add1(mp::msb(value))); + add1(mp::msb(value - 1))); } // Called by bc::byte_width. @@ -159,24 +159,24 @@ constexpr Exponent ceilinged_log256(Value value) NOEXCEPT if constexpr (size == sizeof(uint64_t)) { - if (compare > 0x00ffffffffffffff_u64) return 8; - if (compare > 0x0000ffffffffffff_u64) return 7; - if (compare > 0x000000ffffffffff_u64) return 6; - if (compare > 0x00000000ffffffff_u64) return 5; + if (compare > 0x0100000000000000_u64) return 8; + if (compare > 0x0001000000000000_u64) return 7; + if (compare > 0x0000010000000000_u64) return 6; + if (compare > 0x0000000100000000_u64) return 5; } if constexpr (size >= sizeof(uint32_t)) { - if (compare > 0x00ffffff_u32) return 4; - if (compare > 0x0000ffff_u32) return 3; + if (compare > 0x01000000_u32) return 4; + if (compare > 0x00010000_u32) return 3; } if constexpr (size >= sizeof(uint16_t)) { - if (compare > 0x00ff_u16) return 2; + if (compare > 0x0100_u16) return 2; } - return (compare > 0x00_u8) ? 1 : 0; + return (compare > 0x01_u8) ? 1 : 0; } // Called by bc::byte_width. diff --git a/test/chain/block.cpp b/test/chain/block.cpp index b15cb9fff0..3a983dc342 100644 --- a/test/chain/block.cpp +++ b/test/chain/block.cpp @@ -780,7 +780,7 @@ BOOST_AUTO_TEST_CASE(block__merkle_branch__medium_power_of_two__expected) BOOST_AUTO_TEST_CASE(block__merkle_branch__power_of_two_minus_one__expected) { constexpr auto leaf = 1023u; - constexpr auto size = sub1(ceilinged_log2(add1(leaf))); + constexpr auto size = ceilinged_log2(add1(leaf)); const auto branch = block::merkle_branch(leaf, add1(leaf)); BOOST_REQUIRE_EQUAL(branch.size(), size); BOOST_REQUIRE_EQUAL(branch.front().sibling, 1022u); @@ -792,7 +792,7 @@ BOOST_AUTO_TEST_CASE(block__merkle_branch__power_of_two_minus_one__expected) BOOST_AUTO_TEST_CASE(block__merkle_branch__odd_large_leaf_with_duplication__expected) { constexpr auto leaf = 2047u; - constexpr auto size = sub1(ceilinged_log2(add1(leaf))); + constexpr auto size = ceilinged_log2(add1(leaf)); const auto branch = block::merkle_branch(leaf, add1(leaf)); BOOST_REQUIRE_EQUAL(branch.size(), size); BOOST_REQUIRE_EQUAL(branch.front().sibling, 2046u); diff --git a/test/chain/compact.cpp b/test/chain/compact.cpp index be31e6eabe..06ec139e66 100644 --- a/test/chain/compact.cpp +++ b/test/chain/compact.cpp @@ -261,14 +261,11 @@ static_assert(compact::expand(compact::compress(uint256_t(42))) == uint256_t(42) // (exponent > 32 && mantissa > 0x00ffff) // strict (33 with 1|2) //) -// > 0x0000 <= 0x00ff (overflow if exponent > 31 and ceilinged_log256(mantissa) > 1) -static_assert(ceilinged_log256(0x00000001ul) == 1); -static_assert(ceilinged_log256(0x000000fful) == 1); +// > 0x0000 <= 0x00ff (overflow if exponent > 31 and byte_width(mantissa) > 1) +static_assert(byte_width(0x000000fful) == 1); -// > 0x00ff <= 0x0000ffff (eoverflow if exponent > 30 and ceilinged_log256(mantissa) > 2) -static_assert(ceilinged_log256(0x00000100ul) == 2); -static_assert(ceilinged_log256(0x0000fffful) == 2); +// > 0x00ff <= 0x0000ffff (overflow if exponent > 30 and byte_width(mantissa) > 2) +static_assert(byte_width(0x0000fffful) == 2); -// > 0x0000ffff (<= 0x007ffffful) (overflow if exponent > 29 and ceilinged_log256(mantissa) > 3) -static_assert(ceilinged_log256(0x00010000ul) == 3); -static_assert(ceilinged_log256(0x007ffffful) == 3); +// > 0x0000ffff (<= 0x007ffffful) (overflow if exponent > 29 and byte_width(mantissa) > 3) +static_assert(byte_width(0x007ffffful) == 3); diff --git a/test/math/bytes.cpp b/test/math/bytes.cpp index 5fe74b2dfd..29b4883ba6 100644 --- a/test/math/bytes.cpp +++ b/test/math/bytes.cpp @@ -20,6 +20,8 @@ BOOST_AUTO_TEST_SUITE(bytes_tests) +constexpr auto foo = byte_width(1_u8); + // byte_width (unsigned/positive) static_assert(byte_width(0_u8) == 0); static_assert(byte_width(1_u8) == 1); diff --git a/test/math/logarithm.cpp b/test/math/logarithm.cpp index 0ff54e39b8..1d168d37f1 100644 --- a/test/math/logarithm.cpp +++ b/test/math/logarithm.cpp @@ -100,9 +100,9 @@ static_assert( is_power2(9223372036854775808u)); // ceilinged_log -static_assert(ceilinged_log(-2, 2u) == 0u); -static_assert(ceilinged_log(2u, -2) == 0u); -static_assert(ceilinged_log(-2, -2) == 0u); +static_assert(ceilinged_log(-2, 1u) == 0u); +static_assert(ceilinged_log(2u, -1) == 0u); +static_assert(ceilinged_log(-2, -1) == 0u); static_assert(ceilinged_log(-0, 0) == 0u); static_assert(ceilinged_log(-0, 0u) == 0u); @@ -124,33 +124,33 @@ static_assert(ceilinged_log(1, 1u) == 0u); static_assert(ceilinged_log(1u, 1) == 0u); static_assert(ceilinged_log(1u, 1u) == 0u); -static_assert(ceilinged_log(2, 1) == 1u); -static_assert(ceilinged_log(2, 1u) == 1u); -static_assert(ceilinged_log(2u, 1) == 1u); -static_assert(ceilinged_log(2u, 1u) == 1u); - -static_assert(ceilinged_log(2, 2) == 2u); -static_assert(ceilinged_log(2, 2u) == 2u); -static_assert(ceilinged_log(2u, 2) == 2u); -static_assert(ceilinged_log(2u, 2u) == 2u); - -static_assert(ceilinged_log(3, 2) == 1u); -static_assert(ceilinged_log(3, 2u) == 1u); -static_assert(ceilinged_log(3u, 2) == 1u); -static_assert(ceilinged_log(3u, 2u) == 1u); - -static_assert(ceilinged_log(2, 3) == 2u); -static_assert(ceilinged_log(2, 3u) == 2u); -static_assert(ceilinged_log(2u, 3) == 2u); -static_assert(ceilinged_log(2u, 3u) == 2u); - -static_assert(ceilinged_log(10, 1) == 1); -static_assert(ceilinged_log(10, 10) == 2); -static_assert(ceilinged_log(10, 100) == 3); -static_assert(ceilinged_log(10, 1000) == 4); -static_assert(ceilinged_log(10, 10000) == 5); -static_assert(ceilinged_log(10, 100000) == 6); -static_assert(ceilinged_log(10, 1000000) == 7); +static_assert(ceilinged_log(2, 1) == 0u); +static_assert(ceilinged_log(2, 1u) == 0u); +static_assert(ceilinged_log(2u, 1) == 0u); +static_assert(ceilinged_log(2u, 1u) == 0u); + +static_assert(ceilinged_log(2, 2) == 1u); +static_assert(ceilinged_log(2, 2u) == 1u); +static_assert(ceilinged_log(2u, 2) == 1u); +static_assert(ceilinged_log(2u, 2u) == 1u); + +static_assert(ceilinged_log(3, 3) == 1u); +static_assert(ceilinged_log(3, 3u) == 1u); +static_assert(ceilinged_log(3u, 3) == 1u); +static_assert(ceilinged_log(3u, 3u) == 1u); + +static_assert(ceilinged_log(2, 4) == 2u); +static_assert(ceilinged_log(2, 4u) == 2u); +static_assert(ceilinged_log(2u, 4) == 2u); +static_assert(ceilinged_log(2u, 4u) == 2u); + +static_assert(ceilinged_log(10, 1) == 0); +static_assert(ceilinged_log(10, 10) == 1); +static_assert(ceilinged_log(10, 100) == 2); +static_assert(ceilinged_log(10, 1000) == 3); +static_assert(ceilinged_log(10, 10000) == 4); +static_assert(ceilinged_log(10, 100000) == 5); +static_assert(ceilinged_log(10, 1000000) == 6); // floored_log @@ -217,208 +217,207 @@ static_assert(ceilinged_log2(max_uint32) == to_bits(sizeof(uint32_t))); // Also mixing in signed and unsigned types. -// Third case (2) is redundant with second (2). -static_assert(ceilinged_log2((1u << 0) + 0) == 1u); -static_assert(ceilinged_log2((1u << 0) + 1) == 2u); -////static_assert(ceilinged_log2((1u << 1) + 0) == 2u); +static_assert(ceilinged_log2((1u << 0) + 0) == 0u); +static_assert(ceilinged_log2((1u << 0) + 1) == 1u); +static_assert(ceilinged_log2((1u << 1) + 0) == 1u); static_assert(ceilinged_log2((1u << 1) + 1) == 2u); -static_assert(ceilinged_log2((1u << 2) + 0) == 3u); +static_assert(ceilinged_log2((1u << 2) + 0) == 2u); static_assert(ceilinged_log2((1u << 2) + 1) == 3u); -static_assert(ceilinged_log2((1u << 3) + 0) == 4u); +static_assert(ceilinged_log2((1u << 3) + 0) == 3u); static_assert(ceilinged_log2((1u << 3) + 1) == 4u); -static_assert(ceilinged_log2((1u << 4) + 0) == 5u); +static_assert(ceilinged_log2((1u << 4) + 0) == 4u); static_assert(ceilinged_log2((1u << 4) + 1) == 5u); -static_assert(ceilinged_log2((1u << 5) + 0) == 6u); +static_assert(ceilinged_log2((1u << 5) + 0) == 5u); static_assert(ceilinged_log2((1u << 5) + 1) == 6u); -static_assert(ceilinged_log2((1u << 6) + 0) == 7u); +static_assert(ceilinged_log2((1u << 6) + 0) == 6u); static_assert(ceilinged_log2((1u << 6) + 1) == 7u); -static_assert(ceilinged_log2((1u << 7) + 0) == 8u); +static_assert(ceilinged_log2((1u << 7) + 0) == 7u); static_assert(ceilinged_log2((1u << 7) + 1) == 8u); -static_assert(ceilinged_log2((1u << 8) + 0) == 9u); +static_assert(ceilinged_log2((1u << 8) + 0) == 8u); static_assert(ceilinged_log2((1u << 8) + 1) == 9u); -static_assert(ceilinged_log2((1u << 9) + 0) == 10u); +static_assert(ceilinged_log2((1u << 9) + 0) == 9u); static_assert(ceilinged_log2((1u << 9) + 1) == 10u); -static_assert(ceilinged_log2((1 << 10) + 0) == 11); +static_assert(ceilinged_log2((1 << 10) + 0) == 10); static_assert(ceilinged_log2((1 << 10) + 1) == 11); -static_assert(ceilinged_log2((1 << 11) + 0) == 12); +static_assert(ceilinged_log2((1 << 11) + 0) == 11); static_assert(ceilinged_log2((1 << 11) + 1) == 12); -static_assert(ceilinged_log2((1 << 12) + 0) == 13); +static_assert(ceilinged_log2((1 << 12) + 0) == 12); static_assert(ceilinged_log2((1 << 12) + 1) == 13); -static_assert(ceilinged_log2((1 << 13) + 0) == 14); +static_assert(ceilinged_log2((1 << 13) + 0) == 13); static_assert(ceilinged_log2((1 << 13) + 1) == 14); -static_assert(ceilinged_log2((1 << 14) + 0) == 15); +static_assert(ceilinged_log2((1 << 14) + 0) == 14); static_assert(ceilinged_log2((1 << 14) + 1) == 15); -static_assert(ceilinged_log2((1 << 15) + 0) == 16); +static_assert(ceilinged_log2((1 << 15) + 0) == 15); static_assert(ceilinged_log2((1 << 15) + 1) == 16); -static_assert(ceilinged_log2((1 << 16) + 0) == 17); +static_assert(ceilinged_log2((1 << 16) + 0) == 16); static_assert(ceilinged_log2((1 << 16) + 1) == 17); -static_assert(ceilinged_log2((1 << 17) + 0) == 18); +static_assert(ceilinged_log2((1 << 17) + 0) == 17); static_assert(ceilinged_log2((1 << 17) + 1) == 18); -static_assert(ceilinged_log2((1 << 18) + 0) == 19); +static_assert(ceilinged_log2((1 << 18) + 0) == 18); static_assert(ceilinged_log2((1 << 18) + 1) == 19); -static_assert(ceilinged_log2((1 << 19) + 0) == 20); +static_assert(ceilinged_log2((1 << 19) + 0) == 19); static_assert(ceilinged_log2((1 << 19) + 1) == 20); -static_assert(ceilinged_log2((1 << 20) + 0) == 21); +static_assert(ceilinged_log2((1 << 20) + 0) == 20); static_assert(ceilinged_log2((1 << 20) + 1) == 21); -static_assert(ceilinged_log2((1 << 21) + 0) == 22); +static_assert(ceilinged_log2((1 << 21) + 0) == 21); static_assert(ceilinged_log2((1 << 21) + 1) == 22); -static_assert(ceilinged_log2((1 << 22) + 0) == 23); +static_assert(ceilinged_log2((1 << 22) + 0) == 22); static_assert(ceilinged_log2((1 << 22) + 1) == 23); -static_assert(ceilinged_log2((1 << 23) + 0) == 24); +static_assert(ceilinged_log2((1 << 23) + 0) == 23); static_assert(ceilinged_log2((1 << 23) + 1) == 24); -static_assert(ceilinged_log2((1 << 24) + 0) == 25); +static_assert(ceilinged_log2((1 << 24) + 0) == 24); static_assert(ceilinged_log2((1 << 24) + 1) == 25); -static_assert(ceilinged_log2((1 << 25) + 0) == 26); +static_assert(ceilinged_log2((1 << 25) + 0) == 25); static_assert(ceilinged_log2((1 << 25) + 1) == 26); -static_assert(ceilinged_log2((1 << 26) + 0) == 27); +static_assert(ceilinged_log2((1 << 26) + 0) == 26); static_assert(ceilinged_log2((1 << 26) + 1) == 27); -static_assert(ceilinged_log2((1 << 27) + 0) == 28); +static_assert(ceilinged_log2((1 << 27) + 0) == 27); static_assert(ceilinged_log2((1 << 27) + 1) == 28); -static_assert(ceilinged_log2((1 << 28) + 0) == 29); +static_assert(ceilinged_log2((1 << 28) + 0) == 28); static_assert(ceilinged_log2((1 << 28) + 1) == 29); -static_assert(ceilinged_log2((1 << 29) + 0) == 30); +static_assert(ceilinged_log2((1 << 29) + 0) == 29); static_assert(ceilinged_log2((1 << 29) + 1) == 30u); -static_assert(ceilinged_log2((1 << 30) + 0) == 31u); +static_assert(ceilinged_log2((1 << 30) + 0) == 30u); static_assert(ceilinged_log2((1 << 30) + 1) == 31u); -static_assert(ceilinged_log2((1ll << 31) + 0) == 32u); +static_assert(ceilinged_log2((1ll << 31) + 0) == 31u); static_assert(ceilinged_log2((1ll << 31) + 1) == 32u); -static_assert(ceilinged_log2(power2(15u)) == 15 + 1); -static_assert(ceilinged_log2(power2(15u)) == 15u + 1u); -static_assert(ceilinged_log2(power(2, 15u)) == 15 + 1); -static_assert(ceilinged_log2(power(2u, 15u)) == 15u + 1u); +static_assert(ceilinged_log2(power2(15u)) == 15); +static_assert(ceilinged_log2(power2(15u)) == 15u); +static_assert(ceilinged_log2(power(2, 15u)) == 15); +static_assert(ceilinged_log2(power(2u, 15u)) == 15u); // Also mixing in signed and unsigned types. -// Third case (2) is redundant with second (2). -static_assert(ceilinged_log2(uint256_t((1u << 0) + 0)) == 1u); -static_assert(ceilinged_log2(uint256_t((1u << 0) + 1)) == 2u); -////static_assert(ceilinged_log2(uint256_t((1u << 1) + 0)) == 2u); +static_assert(ceilinged_log2(uint256_t((1u << 0) + 0)) == 0u); +static_assert(ceilinged_log2(uint256_t((1u << 0) + 1)) == 1u); +static_assert(ceilinged_log2(uint256_t((1u << 1) + 0)) == 1u); static_assert(ceilinged_log2(uint256_t((1u << 1) + 1)) == 2u); -static_assert(ceilinged_log2(uint256_t((1u << 2) + 0)) == 3u); +static_assert(ceilinged_log2(uint256_t((1u << 2) + 0)) == 2u); static_assert(ceilinged_log2(uint256_t((1u << 2) + 1)) == 3u); -static_assert(ceilinged_log2(uint256_t((1u << 3) + 0)) == 4u); +static_assert(ceilinged_log2(uint256_t((1u << 3) + 0)) == 3u); static_assert(ceilinged_log2(uint256_t((1u << 3) + 1)) == 4u); -static_assert(ceilinged_log2(uint256_t((1u << 4) + 0)) == 5u); +static_assert(ceilinged_log2(uint256_t((1u << 4) + 0)) == 4u); static_assert(ceilinged_log2(uint256_t((1u << 4) + 1)) == 5u); -static_assert(ceilinged_log2(uint256_t((1u << 5) + 0)) == 6u); +static_assert(ceilinged_log2(uint256_t((1u << 5) + 0)) == 5u); static_assert(ceilinged_log2(uint256_t((1u << 5) + 1)) == 6u); -static_assert(ceilinged_log2(uint256_t((1u << 6) + 0)) == 7u); +static_assert(ceilinged_log2(uint256_t((1u << 6) + 0)) == 6u); static_assert(ceilinged_log2(uint256_t((1u << 6) + 1)) == 7u); -static_assert(ceilinged_log2(uint256_t((1u << 7) + 0)) == 8u); +static_assert(ceilinged_log2(uint256_t((1u << 7) + 0)) == 7u); static_assert(ceilinged_log2(uint256_t((1u << 7) + 1)) == 8u); -static_assert(ceilinged_log2(uint256_t((1u << 8) + 0)) == 9u); +static_assert(ceilinged_log2(uint256_t((1u << 8) + 0)) == 8u); static_assert(ceilinged_log2(uint256_t((1u << 8) + 1)) == 9u); -static_assert(ceilinged_log2(uint256_t((1u << 9) + 0)) == 10u); +static_assert(ceilinged_log2(uint256_t((1u << 9) + 0)) == 9u); static_assert(ceilinged_log2(uint256_t((1u << 9) + 1)) == 10u); -static_assert(ceilinged_log2(uint256_t((1 << 10) + 0)) == 11); +static_assert(ceilinged_log2(uint256_t((1 << 10) + 0)) == 10); static_assert(ceilinged_log2(uint256_t((1 << 10) + 1)) == 11); -static_assert(ceilinged_log2(uint256_t((1 << 11) + 0)) == 12); +static_assert(ceilinged_log2(uint256_t((1 << 11) + 0)) == 11); static_assert(ceilinged_log2(uint256_t((1 << 11) + 1)) == 12); -static_assert(ceilinged_log2(uint256_t((1 << 12) + 0)) == 13); +static_assert(ceilinged_log2(uint256_t((1 << 12) + 0)) == 12); static_assert(ceilinged_log2(uint256_t((1 << 12) + 1)) == 13); -static_assert(ceilinged_log2(uint256_t((1 << 13) + 0)) == 14); +static_assert(ceilinged_log2(uint256_t((1 << 13) + 0)) == 13); static_assert(ceilinged_log2(uint256_t((1 << 13) + 1)) == 14); -static_assert(ceilinged_log2(uint256_t((1 << 14) + 0)) == 15); +static_assert(ceilinged_log2(uint256_t((1 << 14) + 0)) == 14); static_assert(ceilinged_log2(uint256_t((1 << 14) + 1)) == 15); -static_assert(ceilinged_log2(uint256_t((1 << 15) + 0)) == 16); +static_assert(ceilinged_log2(uint256_t((1 << 15) + 0)) == 15); static_assert(ceilinged_log2(uint256_t((1 << 15) + 1)) == 16); -static_assert(ceilinged_log2(uint256_t((1 << 16) + 0)) == 17); +static_assert(ceilinged_log2(uint256_t((1 << 16) + 0)) == 16); static_assert(ceilinged_log2(uint256_t((1 << 16) + 1)) == 17); -static_assert(ceilinged_log2(uint256_t((1 << 17) + 0)) == 18); +static_assert(ceilinged_log2(uint256_t((1 << 17) + 0)) == 17); static_assert(ceilinged_log2(uint256_t((1 << 17) + 1)) == 18); -static_assert(ceilinged_log2(uint256_t((1 << 18) + 0)) == 19); +static_assert(ceilinged_log2(uint256_t((1 << 18) + 0)) == 18); static_assert(ceilinged_log2(uint256_t((1 << 18) + 1)) == 19); -static_assert(ceilinged_log2(uint256_t((1 << 19) + 0)) == 20); +static_assert(ceilinged_log2(uint256_t((1 << 19) + 0)) == 19); static_assert(ceilinged_log2(uint256_t((1 << 19) + 1)) == 20); -static_assert(ceilinged_log2(uint256_t((1 << 20) + 0)) == 21); +static_assert(ceilinged_log2(uint256_t((1 << 20) + 0)) == 20); static_assert(ceilinged_log2(uint256_t((1 << 20) + 1)) == 21); -static_assert(ceilinged_log2(uint256_t((1 << 21) + 0)) == 22); +static_assert(ceilinged_log2(uint256_t((1 << 21) + 0)) == 21); static_assert(ceilinged_log2(uint256_t((1 << 21) + 1)) == 22); -static_assert(ceilinged_log2(uint256_t((1 << 22) + 0)) == 23); +static_assert(ceilinged_log2(uint256_t((1 << 22) + 0)) == 22); static_assert(ceilinged_log2(uint256_t((1 << 22) + 1)) == 23); -static_assert(ceilinged_log2(uint256_t((1 << 23) + 0)) == 24); +static_assert(ceilinged_log2(uint256_t((1 << 23) + 0)) == 23); static_assert(ceilinged_log2(uint256_t((1 << 23) + 1)) == 24); -static_assert(ceilinged_log2(uint256_t((1 << 24) + 0)) == 25); +static_assert(ceilinged_log2(uint256_t((1 << 24) + 0)) == 24); static_assert(ceilinged_log2(uint256_t((1 << 24) + 1)) == 25); -static_assert(ceilinged_log2(uint256_t((1 << 25) + 0)) == 26); +static_assert(ceilinged_log2(uint256_t((1 << 25) + 0)) == 25); static_assert(ceilinged_log2(uint256_t((1 << 25) + 1)) == 26); -static_assert(ceilinged_log2(uint256_t((1 << 26) + 0)) == 27); +static_assert(ceilinged_log2(uint256_t((1 << 26) + 0)) == 26); static_assert(ceilinged_log2(uint256_t((1 << 26) + 1)) == 27); -static_assert(ceilinged_log2(uint256_t((1 << 27) + 0)) == 28); +static_assert(ceilinged_log2(uint256_t((1 << 27) + 0)) == 27); static_assert(ceilinged_log2(uint256_t((1 << 27) + 1)) == 28); -static_assert(ceilinged_log2(uint256_t((1 << 28) + 0)) == 29); +static_assert(ceilinged_log2(uint256_t((1 << 28) + 0)) == 28); static_assert(ceilinged_log2(uint256_t((1 << 28) + 1)) == 29); -static_assert(ceilinged_log2(uint256_t((1 << 29) + 0)) == 30); +static_assert(ceilinged_log2(uint256_t((1 << 29) + 0)) == 29); static_assert(ceilinged_log2(uint256_t((1 << 29) + 1)) == 30u); -static_assert(ceilinged_log2(uint256_t((1 << 30) + 0)) == 31u); +static_assert(ceilinged_log2(uint256_t((1 << 30) + 0)) == 30u); static_assert(ceilinged_log2(uint256_t((1 << 30) + 1)) == 31u); -static_assert(ceilinged_log2(uint256_t((1ll << 31) + 0)) == 32u); +static_assert(ceilinged_log2(uint256_t((1ll << 31) + 0)) == 31u); static_assert(ceilinged_log2(uint256_t((1ll << 31) + 1)) == 32u); static_assert(ceilinged_log2(to_uintx(base16_hash("ffffffffffffffff"))) == 64u); -static_assert(ceilinged_log2(to_uintx(base16_hash("010000000000000000"))) == 65u); +static_assert(ceilinged_log2(to_uintx(base16_hash("010000000000000000"))) == 64u); static_assert(ceilinged_log2(to_uintx(base16_hash("ffffffffffffffffffffffffffffffff"))) == 128u); -static_assert(ceilinged_log2(to_uintx(base16_hash("0100000000000000000000000000000000"))) == 129u); +static_assert(ceilinged_log2(to_uintx(base16_hash("0100000000000000000000000000000000"))) == 128u); static_assert(ceilinged_log2(to_uintx(base16_hash("f000000000000000000000000000000000000000000000000000000000000000"))) == 256u); -static_assert(ceilinged_log2(to_uintx(base16_hash("010000000000000000000000000000000000000000000000000000000000000000"))) == 257u); +static_assert(ceilinged_log2(to_uintx(base16_hash("010000000000000000000000000000000000000000000000000000000000000000"))) == 256u); static_assert(ceilinged_log2(to_uintx(base16_hash("f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"))) == 512u); -static_assert(ceilinged_log2(to_uintx(base16_hash("0100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"))) == 513u); +static_assert(ceilinged_log2(to_uintx(base16_hash("0100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"))) == 512u); // ceilinged_log256 -static_assert(ceilinged_log256(0x0100000000000000ull) == 8); -static_assert(ceilinged_log256(0x01000000000000ull) == 7); -static_assert(ceilinged_log256(0x010000000000ull) == 6); -static_assert(ceilinged_log256(0x0100000000ull) == 5); -static_assert(ceilinged_log256(0x01000000ull) == 4); -static_assert(ceilinged_log256(0x010000ull) == 3); -static_assert(ceilinged_log256(0x0100ull) == 2); -static_assert(ceilinged_log256(0x01ull) == 1); +static_assert(ceilinged_log256(0x0100000000000000ull) == 7); +static_assert(ceilinged_log256(0x01000000000000ull) == 6); +static_assert(ceilinged_log256(0x010000000000ull) == 5); +static_assert(ceilinged_log256(0x0100000000ull) == 4); +static_assert(ceilinged_log256(0x01000000ull) == 3); +static_assert(ceilinged_log256(0x010000ull) == 2); +static_assert(ceilinged_log256(0x0100ull) == 1); +static_assert(ceilinged_log256(0x01ull) == 0); static_assert(ceilinged_log256(0x00ull) == 0); // uint256_t -static_assert(ceilinged_log256(uint256_t(0x0100000000000000ull)) == 8); -static_assert(ceilinged_log256(uint256_t(0x01000000000000ull)) == 7); -static_assert(ceilinged_log256(uint256_t(0x010000000000ull)) == 6); -static_assert(ceilinged_log256(uint256_t(0x0100000000ull)) == 5); -static_assert(ceilinged_log256(uint256_t(0x01000000ull)) == 4); -static_assert(ceilinged_log256(uint256_t(0x010000ull)) == 3); -static_assert(ceilinged_log256(uint256_t(0x0100ull)) == 2); -static_assert(ceilinged_log256(uint256_t(0x01ull)) == 1); +static_assert(ceilinged_log256(uint256_t(0x0100000000000000ull)) == 7); +static_assert(ceilinged_log256(uint256_t(0x01000000000000ull)) == 6); +static_assert(ceilinged_log256(uint256_t(0x010000000000ull)) == 5); +static_assert(ceilinged_log256(uint256_t(0x0100000000ull)) == 4); +static_assert(ceilinged_log256(uint256_t(0x01000000ull)) == 3); +static_assert(ceilinged_log256(uint256_t(0x010000ull)) == 2); +static_assert(ceilinged_log256(uint256_t(0x0100ull)) == 1); +static_assert(ceilinged_log256(uint256_t(0x01ull)) == 0); static_assert(ceilinged_log256(uint256_t(0x00ull)) == 0); // ceilinged_log static_assert(ceilinged_log<0u>(42) == 0u); -static_assert(ceilinged_log<2u>((1u << 0) + 0) == 1u); -////static_assert(ceilinged_log<2u>((1u << 0) + 1) == 2u); -static_assert(ceilinged_log<2u>((1u << 1) + 0) == 2u); +static_assert(ceilinged_log<2u>((1u << 0) + 0) == 0u); +static_assert(ceilinged_log<2u>((1u << 0) + 1) == 1u); +static_assert(ceilinged_log<2u>((1u << 1) + 0) == 1u); static_assert(ceilinged_log<2u>((1u << 1) + 1) == 2u); -static_assert(ceilinged_log<2u>((1u << 2) + 0) == 3u); +static_assert(ceilinged_log<2u>((1u << 2) + 0) == 2u); static_assert(ceilinged_log<2u>((1u << 2) + 1) == 3u); -static_assert(ceilinged_log<2u>((1u << 3) + 0) == 4u); +static_assert(ceilinged_log<2u>((1u << 3) + 0) == 3u); static_assert(ceilinged_log<2u>((1u << 3) + 1) == 4u); -static_assert(ceilinged_log<2u>((1u << 4) + 0) == 5u); +static_assert(ceilinged_log<2u>((1u << 4) + 0) == 4u); static_assert(ceilinged_log<2u>((1u << 4) + 1) == 5u); -static_assert(ceilinged_log<2u>((1u << 5) + 0) == 6u); +static_assert(ceilinged_log<2u>((1u << 5) + 0) == 5u); static_assert(ceilinged_log<2u>((1u << 5) + 1) == 6u); -static_assert(ceilinged_log<2u>((1u << 6) + 0) == 7u); +static_assert(ceilinged_log<2u>((1u << 6) + 0) == 6u); static_assert(ceilinged_log<2u>((1u << 6) + 1) == 7u); -static_assert(ceilinged_log<2u>((1u << 7) + 0) == 8u); +static_assert(ceilinged_log<2u>((1u << 7) + 0) == 7u); static_assert(ceilinged_log<2u>((1u << 7) + 1) == 8u); -static_assert(ceilinged_log<2u>((1u << 8) + 0) == 9u); +static_assert(ceilinged_log<2u>((1u << 8) + 0) == 8u); static_assert(ceilinged_log<2u>((1u << 8) + 1) == 9u); -static_assert(ceilinged_log<2u>((1u << 9) + 0) == 10u); +static_assert(ceilinged_log<2u>((1u << 9) + 0) == 9u); static_assert(ceilinged_log<2u, size_t>((1u << 9) + 1) == 10u); -static_assert(ceilinged_log<256u>(0x0100000000000000ull) == 8); -static_assert(ceilinged_log<256u>(0x01000000000000ull) == 7); -static_assert(ceilinged_log<256u>(0x010000000000ull) == 6); -static_assert(ceilinged_log<256u>(0x0100000000ull) == 5); -static_assert(ceilinged_log<256u>(0x01000000ull) == 4); -static_assert(ceilinged_log<256u>(0x010000ull) == 3); -static_assert(ceilinged_log<256u>(0x0100ull) == 2); -static_assert(ceilinged_log<256u>(0x01ull) == 1); +static_assert(ceilinged_log<256u>(0x0100000000000001ull) == 8); +static_assert(ceilinged_log<256u>(0x0100000000000000ull) == 7); +static_assert(ceilinged_log<256u>(0x01000000000000ull) == 6); +static_assert(ceilinged_log<256u>(0x010000000000ull) == 5); +static_assert(ceilinged_log<256u>(0x0100000000ull) == 4); +static_assert(ceilinged_log<256u>(0x01000000ull) == 3); +static_assert(ceilinged_log<256u>(0x010000ull) == 2); +static_assert(ceilinged_log<256u>(0x0100ull) == 1); +static_assert(ceilinged_log<256u>(0x01ull) == 0); static_assert(ceilinged_log<256u>(0x00ull) == 0); -static_assert(ceilinged_log<10u, int>(1000000) == 7); -static_assert(ceilinged_log<10u>(1000000) == 7); +static_assert(ceilinged_log<10u, int>(1000000) == 6); +static_assert(ceilinged_log<10u>(1000000) == 6); static_assert(ceilinged_log<2>(uint256_t{ 255 }) == 8u); // floored_log2 @@ -432,10 +431,9 @@ static_assert(floored_log2(max_uint32) == sub1(to_bits(sizeof(uint32_t)))); // Also mixing in signed and unsigned types. -// Third case (2) is redundant with second (2). static_assert(floored_log2((1u << 0) + 0) == 0u); static_assert(floored_log2((1u << 0) + 1) == 1u); -////static_assert(floored_log2((1u << 1) + 0) == 1u); +static_assert(floored_log2((1u << 1) + 0) == 1u); static_assert(floored_log2((1u << 1) + 1) == 1u); static_assert(floored_log2((1u << 2) + 0) == 2u); static_assert(floored_log2((1u << 2) + 1) == 2u); @@ -504,10 +502,9 @@ static_assert(floored_log2(power2(15u)) == 15u); static_assert(floored_log2(power(2, 15u)) == 15); static_assert(floored_log2(power(2u, 15u)) == 15u); -// Third case (2) is redundant with second (2). static_assert(floored_log2(uint256_t((1u << 0) + 0)) == 0u); static_assert(floored_log2(uint256_t((1u << 0) + 1)) == 1u); -////static_assert(floored_log2(uint256_t((1u << 1) + 0)) == 1u); +static_assert(floored_log2(uint256_t((1u << 1) + 0)) == 1u); static_assert(floored_log2(uint256_t((1u << 1) + 1)) == 1u); static_assert(floored_log2(uint256_t((1u << 2) + 0)) == 2u); static_assert(floored_log2(uint256_t((1u << 2) + 1)) == 2u); @@ -600,7 +597,7 @@ static_assert(floored_log256(uint256_t(0x00ull)) == 0); static_assert(floored_log<0u>(42) == 0u); static_assert(floored_log<2u>((1u << 0) + 0) == 0u); static_assert(floored_log<2u>((1u << 0) + 1) == 1u); -////static_assert(floored_log<2u>((1u << 1) + 0) == 1u); +static_assert(floored_log<2u>((1u << 1) + 0) == 1u); static_assert(floored_log<2u>((1u << 1) + 1) == 1u); static_assert(floored_log<2u>((1u << 2) + 0) == 2u); static_assert(floored_log<2u>((1u << 2) + 1) == 2u); @@ -644,22 +641,22 @@ BOOST_AUTO_TEST_CASE(logarithm__ceilinged_log2_uintx__maximums__sizeof_maximum) BOOST_AUTO_TEST_CASE(logarithm__ceilinged_log2_uintx__powers_of_2__expected) { - BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx((1ull << 32) + 0)), 33u); + BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx((1ull << 32) + 0)), 32u); BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx((1ull << 32) + 1)), 33u); - BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx((1ull << 63) + 0)), 64u); + BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx((1ull << 63) + 0)), 63u); BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx((1ull << 63) + 1)), 64u); } BOOST_AUTO_TEST_CASE(logarithm__ceilinged_log2_uintx__pow2__identity) { - BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx(power2(15u))), 15 + 1); - BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx(power2(15u))), 15u + 1u); + BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx(power2(15u))), 15); + BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx(power2(15u))), 15u); } BOOST_AUTO_TEST_CASE(logarithm__ceilinged_log2_uintx__power_2__identity) { - BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx(power(2, 15u))), 15 + 1); - BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx(power(2u, 15u))), 15u + 1u); + BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx(power(2, 15u))), 15); + BOOST_REQUIRE_EQUAL(ceilinged_log2(uintx(power(2u, 15u))), 15u); } BOOST_AUTO_TEST_CASE(logarithm__floored_log2_uintx__maximums__sizeof_maximum_minus_one)