Add TrailingZeroCount and LongCeilingPowerOfTwo

BitFaster.Caching.UnitTests/BitOpsTests.cs

@@ -20,6 +20,17 @@ public void IntCeilingPowerOfTwo(int input, int power)
  BitOps.CeilingPowerOfTwo(input).Should().Be(power);
  }
 
+ [Theory]
+ [InlineData(3, 4)]
+ [InlineData(7, 8)]
+ [InlineData(15, 16)]
+ [InlineData(536870913, 1073741824)]
+ [InlineData(34359738368, 34359738368)]
+ public void LongCeilingPowerOfTwo(long input, long power)
+ {
+ BitOps.CeilingPowerOfTwo(input).Should().Be(power);
+ }
+
  [Theory]
  [InlineData(3, 4)]
  [InlineData(7, 8)]
@@ -31,6 +42,46 @@ public void UIntCeilingPowerOfTwo(uint input, uint power)
  BitOps.CeilingPowerOfTwo(input).Should().Be(power);
  }
 
+ [Theory]
+ [InlineData(3, 4)]
+ [InlineData(7, 8)]
+ [InlineData(15, 16)]
+ [InlineData(536870913, 1073741824)]
+ [InlineData(34359738368, 34359738368)]
+
+ public void UlongCeilingPowerOfTwo(ulong input, ulong power)
+ {
+ BitOps.CeilingPowerOfTwo(input).Should().Be(power);
+ }
+
+ [Theory]
+ [InlineData(0, 64)]
+ [InlineData(1, 0)]
+ [InlineData(2, 1)]
+ [InlineData(1_000_000, 6)]
+ [InlineData(34359738368, 35)]
+ [InlineData(4611686018427387904, 62)]
+ [InlineData(long.MaxValue, 0)]
+
+ public void LongTrailingZeroCount(long input, int count)
+ {
+ BitOps.TrailingZeroCount(input).Should().Be(count);
+ }
+
+ [Theory]
+ [InlineData(0, 64)]
+ [InlineData(1, 0)]
+ [InlineData(2, 1)]
+ [InlineData(1_000_000, 6)]
+ [InlineData(34359738368, 35)]
+ [InlineData(9223372036854775808, 63)]
+ [InlineData(ulong.MaxValue, 0)]
+
+ public void ULongTrailingZeroCount(ulong input, int count)
+ {
+ BitOps.TrailingZeroCount(input).Should().Be(count);
+ }
+
  [Fact]
  public void IntBitCount()
  {

BitFaster.Caching/BitOps.cs

@@ -17,6 +17,16 @@ public static int CeilingPowerOfTwo(int x)
  return (int)CeilingPowerOfTwo((uint)x);
  }
 
+ /// <summary>
+ /// Calculate the smallest power of 2 greater than the input parameter.
+ /// </summary>
+ /// <param name="x">The input parameter.</param>
+ /// <returns>Smallest power of two greater than or equal to x.</returns>
+ internal static long CeilingPowerOfTwo(long x)
+ {
+ return (long)CeilingPowerOfTwo((ulong)x);
+ }
+
  /// <summary>
  /// Calculate the smallest power of 2 greater than the input parameter.
  /// </summary>
@@ -36,7 +46,53 @@ public static uint CeilingPowerOfTwo(uint x)
 #else
  return 1u << -BitOperations.LeadingZeroCount(x - 1);
 #endif
+ }
 
+ /// <summary>
+ /// Calculate the smallest power of 2 greater than the input parameter.
+ /// </summary>
+ /// <param name="x">The input parameter.</param>
+ /// <returns>Smallest power of two greater than or equal to x.</returns>
+ internal static ulong CeilingPowerOfTwo(ulong x)
+ {
+#if NETSTANDARD2_0
+ // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+ --x;
+ x |= x >> 1;
+ x |= x >> 2;
+ x |= x >> 4;
+ x |= x >> 8;
+ x |= x >> 16;
+ x |= x >> 32;
+ return x + 1;
+#else
+ return 1ul << -BitOperations.LeadingZeroCount(x - 1);
+#endif
+ }
+
+ /// <summary>
+ /// Counts the number of trailing zero bits in the input parameter.
+ /// </summary>
+ /// <param name="x">The input parameter.</param>
+ /// <returns>The number of trailing zero bits.</returns>
+ internal static int TrailingZeroCount(long x)
+ {
+ return TrailingZeroCount((ulong)x);
+ }
+
+ /// <summary>
+ /// Counts the number of trailing zero bits in the input parameter.
+ /// </summary>
+ /// <param name="x">The input parameter.</param>
+ /// <returns>The number of trailing zero bits.</returns>
+ internal static int TrailingZeroCount(ulong x)
+ {
+#if NETSTANDARD2_0
+ // https://codereview.stackexchange.com/questions/288007/c-bit-utility-functions-popcount-trailing-zeros-count-reverse-all-bits
+ return BitCount(~x & (x - 1));
+#else
+ return BitOperations.TrailingZeroCount(x);
+#endif
  }
 
  /// <summary>