Merge pull request #1619 from evoskuil/master

Add ones_count and zeros_count bitwise utilities, comments, point tests.

Author: evoskuil

include/bitcoin/system/impl/hash/functions.ipp

@@ -236,10 +236,32 @@ INLINE constexpr size_t djb2_hash(const data_slice& data) NOEXCEPT
     return hash;
 }
 
-// Combine hash values, such as a pair of djb2_hash outputs.
+// Combine hash values, such as djb2_hash or unique_hash outputs.
 INLINE constexpr size_t hash_combine(size_t left, size_t right) NOEXCEPT
 {
-    return left ^ shift_left(right, one);
+    //// This leads to mixing null points (850k identical) with other buckets.
+    ////constexpr auto prime1 = possible_narrow_cast<size_t>(0x9e3779b97f4a7c15_u64);
+    ////constexpr auto prime2 = possible_narrow_cast<size_t>(0x517cc1b727220a95_u64);
+    ////
+    ////auto first = left;
+    ////first ^= shift_right(first, 23);
+    ////first *= prime1;
+    ////first ^= shift_right(first, 19);
+    ////
+    ////auto second = right;
+    ////second ^= shift_right(second, 13);
+    ////second *= prime2;
+    ////second ^= shift_right(second, 31);
+    ////
+    ////// seed parameter, defaults to zero.
+    ////first ^= second;
+    ////first += seed;
+    ////first ^= shift_right(first, 17);
+    ////first *= prime1;
+    ////first ^= shift_right(first, 29);
+
+    ////return first;
+    return bit_xor(left, shift_left(right));
 }
 
 } // namespace system

include/bitcoin/system/impl/math/bits.ipp

@@ -73,6 +73,18 @@ constexpr size_t right_ones(Value value) NOEXCEPT
     return to_unsigned(std::countr_one<Value>(value));
 }
 
+template <typename Value, if_unsigned_integer<Value>>
+constexpr size_t ones_count(Value value) NOEXCEPT
+{
+    return to_unsigned(std::popcount<Value>(value));
+}
+
+template <typename Value, if_unsigned_integer<Value>>
+constexpr size_t zeros_count(Value value) NOEXCEPT
+{
+    return to_unsigned(std::popcount<Value>(bit_not(value)));
+}
+
 // Bitwise logical operations.
 // ----------------------------------------------------------------------------
 

include/bitcoin/system/math/bits.hpp

@@ -51,6 +51,12 @@ constexpr size_t left_ones(Value value) NOEXCEPT;
 template <typename Value, if_unsigned_integer<Value> = true>
 constexpr size_t right_ones(Value value) NOEXCEPT;
 
+// Because std::popcount (C++20) function returns int.
+template <typename Value, if_unsigned_integer<Value> = true>
+constexpr size_t ones_count(Value value) NOEXCEPT;
+template <typename Value, if_unsigned_integer<Value> = true>
+constexpr size_t zeros_count(Value value) NOEXCEPT;
+
 /// Bitwise logical operations.
 /// ---------------------------------------------------------------------------
 

test/chain/point.cpp

@@ -162,8 +162,21 @@ BOOST_AUTO_TEST_CASE(point__to_data__writer__expected)
 // properties
 // ----------------------------------------------------------------------------
 
-// is_null
-// serialized_size
+BOOST_AUTO_TEST_CASE(point__is_null__not_null__false)
+{
+    BOOST_REQUIRE(!expected_point.is_null());
+}
+
+BOOST_AUTO_TEST_CASE(point__is_null__default_null__true)
+{
+    BOOST_REQUIRE(point{}.is_null());
+}
+
+BOOST_AUTO_TEST_CASE(point__serialized_size__always__expected)
+{
+    static_assert(point::serialized_size() == hash_size + sizeof(uint32_t));
+    BOOST_REQUIRE_EQUAL(point::serialized_size(), hash_size + sizeof(uint32_t));
+}
 
 // json
 // ----------------------------------------------------------------------------

test/hash/functions.cpp

@@ -427,6 +427,16 @@ BOOST_AUTO_TEST_CASE(functions__hash_combine__same_values__expected)
     {
         BOOST_REQUIRE_EQUAL(hash, 4893418499_u64);
     }
+
+    // Complex hash.
+    ////if constexpr (sizeof(size_t) == sizeof(uint32_t))
+    ////{
+    ////    BOOST_REQUIRE_EQUAL(hash, 3172851131_u32);
+    ////}
+    ////else
+    ////{
+    ////    BOOST_REQUIRE_EQUAL(hash, 6326001304333978798_u64);
+    ////}
 }
 
 BOOST_AUTO_TEST_SUITE_END()

test/math/bits.cpp

@@ -123,6 +123,11 @@ static_assert(right_zeros(uint8_t{ 0b11111111 }) == 0);
 static_assert(right_zeros(uint8_t{ 0b00011100 }) == 2);
 static_assert(right_zeros(uint8_t{ 0b00011101 }) == 0);
 
+static_assert(zeros_count(uint8_t{ 0b00000000 }) == 8);
+static_assert(zeros_count(uint8_t{ 0b11111111 }) == 0);
+static_assert(zeros_count(uint8_t{ 0b01111111 }) == 1);
+static_assert(zeros_count(uint8_t{ 0b11100011 }) == 3);
+
 // ones
 
 static_assert(left_ones(uint8_t{ 0b00000000 }) == 0);
@@ -135,6 +140,11 @@ static_assert(right_ones(uint8_t{ 0b11111111 }) == 8);
 static_assert(right_ones(uint8_t{ 0b11111110 }) == 0);
 static_assert(right_ones(uint8_t{ 0b11100011 }) == 2);
 
+static_assert(ones_count(uint8_t{ 0b00000000 }) == 0);
+static_assert(ones_count(uint8_t{ 0b11111111 }) == 8);
+static_assert(ones_count(uint8_t{ 0b11110000 }) == 4);
+static_assert(ones_count(uint8_t{ 0b00011110 }) == 4);
+
 // ones_complement (NOT)
 // inverts all bits (~n, !bool)
 static_assert(bit_not(-4) == 3);