Ceiling Divide BigInteger extension

Author: shargon

src/Neo.Extensions/BigIntegerExtensions.cs

@@ -18,6 +18,22 @@ namespace Neo.Extensions
 {
     public static class BigIntegerExtensions
     {
+        /// <summary>
+        /// Performs integer division with ceiling (rounding up).
+        /// Example: 10 / 3 = 4 instead of 3.
+        /// </summary>
+        /// <param name="a">The dividend.</param>
+        /// <param name="b">The divisor (must be greater than zero).</param>
+        /// <returns>The result of division rounded up.</returns>
+        /// <exception cref="ArgumentException">Thrown when divisor is zero or negative.</exception>
+        public static BigInteger CeilingDivide(this BigInteger a, BigInteger b)
+        {
+            if (b <= 0)
+                throw new ArgumentException("Divider must be greater than zero.", nameof(b));
+
+            return (a + b - 1) / b;
+        }
+
         internal static int TrailingZeroCount(byte[] b)
         {
             var w = 0;

tests/Neo.Extensions.Tests/UT_BigIntegerExtensions.cs

@@ -20,6 +20,49 @@ namespace Neo.Extensions.Tests
     [TestClass]
     public class UT_BigIntegerExtensions
     {
+        [TestMethod]
+        public void CeilingDivide_DividesExactly()
+        {
+            var result = BigIntegerExtensions.CeilingDivide(9, 3);
+            Assert.AreEqual(3, result);
+        }
+
+        [TestMethod]
+        public void CeilingDivide_RoundsUp()
+        {
+            var result = BigIntegerExtensions.CeilingDivide(10, 3);
+            Assert.AreEqual(4, result);
+        }
+
+        [TestMethod]
+        public void CeilingDivide_LargeNumbers()
+        {
+            var a = BigInteger.Parse("1000000000000000000000000000000000");
+            var b = new BigInteger(7);
+            var result = BigIntegerExtensions.CeilingDivide(a, b);
+
+            Assert.AreEqual((a + b - 1) / b, result);
+        }
+
+        [TestMethod]
+        public void CeilingDivide_DivisorOne()
+        {
+            var result = BigIntegerExtensions.CeilingDivide(12345, 1);
+            Assert.AreEqual(12345, result);
+        }
+
+        [TestMethod]
+        public void CeilingDivide_ThrowsOnZeroDivisor()
+        {
+            Assert.Throws<ArgumentException>(() => BigIntegerExtensions.CeilingDivide(10, 0));
+        }
+
+        [TestMethod]
+        public void CeilingDivide_ThrowsOnNegativeDivisor()
+        {
+            Assert.Throws<ArgumentException>(() => BigIntegerExtensions.CeilingDivide(10, -5));
+        }
+
         [TestMethod]
         public void TestGetLowestSetBit()
         {