Add math left_zeros, right_zeros, left_ones, right_ones.

Author: evoskuil

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

@@ -49,6 +49,30 @@ constexpr size_t bit_width(Value value) NOEXCEPT
     return is_negative(value) ? bits<Value> : bit_width(to_unsigned(value));
 }
 
+template <typename Value, if_unsigned_integer<Value>>
+constexpr size_t left_zeros(Value value) NOEXCEPT
+{
+    return to_unsigned(std::countl_zero<Value>(value));
+}
+
+template <typename Value, if_unsigned_integer<Value>>
+constexpr size_t right_zeros(Value value) NOEXCEPT
+{
+    return to_unsigned(std::countr_zero<Value>(value));
+}
+
+template <typename Value, if_unsigned_integer<Value>>
+constexpr size_t left_ones(Value value) NOEXCEPT
+{
+    return to_unsigned(std::countl_one<Value>(value));
+}
+
+template <typename Value, if_unsigned_integer<Value>>
+constexpr size_t right_ones(Value value) NOEXCEPT
+{
+    return to_unsigned(std::countr_one<Value>(value));
+}
+
 // Bitwise logical operations.
 // ----------------------------------------------------------------------------
 

include/bitcoin/system/math/bits.hpp

@@ -39,6 +39,18 @@ constexpr size_t bit_width(Value value) NOEXCEPT;
 template <typename Value, if_signed_integer<Value> = true>
 constexpr size_t bit_width(Value value) NOEXCEPT;
 
+// Because std::countl_* (C++20) functions return int.
+template <typename Value, if_unsigned_integer<Value> = true>
+constexpr size_t left_zeros(Value value) NOEXCEPT;
+template <typename Value, if_unsigned_integer<Value> = true>
+constexpr size_t right_zeros(Value value) NOEXCEPT;
+
+// Because std::countr_* (C++20) functions return int.
+template <typename Value, if_unsigned_integer<Value> = true>
+constexpr size_t left_ones(Value value) NOEXCEPT;
+template <typename Value, if_unsigned_integer<Value> = true>
+constexpr size_t right_ones(Value value) NOEXCEPT;
+
 /// Bitwise logical operations.
 /// ---------------------------------------------------------------------------
 

test/math/bits.cpp

@@ -111,6 +111,30 @@ static_assert(bit_width<int64_t>(0x800000000000_ni64) == 64u);
 static_assert(bit_width<int64_t>(0x80010000000000_ni64) == 64u);
 static_assert(bit_width<int64_t>(0x8000000000000000_ni64) == 64u);
 
+// zeroes
+
+static_assert(left_zeros(uint8_t{ 0b00000000 }) == 8);
+static_assert(left_zeros(uint8_t{ 0b11111111 }) == 0);
+static_assert(left_zeros(uint8_t{ 0b11110000 }) == 0);
+static_assert(left_zeros(uint8_t{ 0b00011110 }) == 3);
+
+static_assert(right_zeros(uint8_t{ 0b00000000 }) == 8);
+static_assert(right_zeros(uint8_t{ 0b11111111 }) == 0);
+static_assert(right_zeros(uint8_t{ 0b00011100 }) == 2);
+static_assert(right_zeros(uint8_t{ 0b00011101 }) == 0);
+
+// ones
+
+static_assert(left_ones(uint8_t{ 0b00000000 }) == 0);
+static_assert(left_ones(uint8_t{ 0b11111111 }) == 8);
+static_assert(left_ones(uint8_t{ 0b01111111 }) == 0);
+static_assert(left_ones(uint8_t{ 0b11100011 }) == 3);
+
+static_assert(right_ones(uint8_t{ 0b00000000 }) == 0);
+static_assert(right_ones(uint8_t{ 0b11111111 }) == 8);
+static_assert(right_ones(uint8_t{ 0b11111110 }) == 0);
+static_assert(right_ones(uint8_t{ 0b11100011 }) == 2);
+
 // ones_complement (NOT)
 // inverts all bits (~n, !bool)
 static_assert(bit_not(-4) == 3);