Ceiling Divide BigInteger extension (#4208)

* Ceiling Divide BigInteger extension

* Update tests/Neo.Extensions.Tests/UT_BigIntegerExtensions.cs

Co-authored-by: Alvaro <[email protected]>

* Update src/Neo.Extensions/BigIntegerExtensions.cs

Co-authored-by: Alvaro <[email protected]>

* Fix: remove whitespace

---------

Co-authored-by: Alvaro <[email protected]>

Author: shargon

src/Neo.Extensions/BigIntegerExtensions.cs

@@ -18,6 +18,28 @@ 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));
+
+            var divPart = a / b;
+            var remainder = a % b;
+
+            if (remainder == 0)
+                return divPart;
+
+            return a > 0 ? divPart + 1 : divPart;
+        }
+
         internal static int TrailingZeroCount(byte[] b)
         {
             var w = 0;

tests/Neo.Extensions.Tests/UT_BigIntegerExtensions.cs

@@ -21,6 +21,57 @@ namespace Neo.Extensions.Tests
     [TestClass]
     public class UT_BigIntegerExtensions
     {
+        [TestMethod]
+        public void CeilingDivide_NegativeNumerator()
+        {
+            var numerator = new BigInteger(-7);
+            var denominator = new BigInteger(3);
+            var result = BigIntegerExtensions.CeilingDivide(numerator, denominator);
+            Assert.AreEqual(-2, result);
+        }
+        [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()
         {